MarshalByRefObject Classe

Définition

public ref class MarshalByRefObject abstract

public abstract class MarshalByRefObject

[System.Serializable]
public abstract class MarshalByRefObject

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class MarshalByRefObject

type MarshalByRefObject = class

[<System.Serializable>]
type MarshalByRefObject = class

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type MarshalByRefObject = class

Public MustInherit Class MarshalByRefObject

Héritage

Object

MarshalByRefObject

Dérivé

IEHost.Execute.IEExecuteRemote

Microsoft.Win32.RegistryKey

System.AddIn.Pipeline.ContractBase

System.AppDomain

System.AppDomainManager

Plus…

Attributs

SerializableAttribute ComVisibleAttribute

Exemples

Cette section contient deux exemples de code. Le premier exemple de code montre comment créer une instance d’une classe dans un autre domaine d’application. Le deuxième exemple de code montre une classe simple qui peut être utilisée pour la communication à distance.

Exemple 1

L’exemple de code suivant montre la façon la plus simple d’exécuter du code dans un autre domaine d’application. L’exemple définit une classe nommée Worker qui hérite de MarshalByRefObject , avec une méthode qui affiche le nom du domaine d’application dans lequel elle s’exécute. L’exemple crée des instances de Worker dans le domaine d’application par défaut et dans un nouveau domaine d’application.

using namespace System;
using namespace System::Reflection;

public ref class Worker : MarshalByRefObject
{
public:
    void PrintDomain() 
    { 
        Console::WriteLine("Object is executing in AppDomain \"{0}\"",
            AppDomain::CurrentDomain->FriendlyName); 
    }
};
 
void main()
{
    // Create an ordinary instance in the current AppDomain
    Worker^ localWorker = gcnew Worker();
    localWorker->PrintDomain();
 
    // Create a new application domain, create an instance
    // of Worker in the application domain, and execute code
    // there.
    AppDomain^ ad = AppDomain::CreateDomain("New domain");
    Worker^ remoteWorker = (Worker^) ad->CreateInstanceAndUnwrap(
        Worker::typeid->Assembly->FullName,
        "Worker");
    remoteWorker->PrintDomain();
}

/* This code produces output similar to the following:

Object is executing in AppDomain "source.exe"
Object is executing in AppDomain "New domain"
 */

using System;
using System.Reflection;

public class Worker : MarshalByRefObject
{
    public void PrintDomain()
    {
        Console.WriteLine("Object is executing in AppDomain \"{0}\"",
            AppDomain.CurrentDomain.FriendlyName);
    }
}

class Example
{
    public static void Main()
    {
        // Create an ordinary instance in the current AppDomain
        Worker localWorker = new Worker();
        localWorker.PrintDomain();

        // Create a new application domain, create an instance
        // of Worker in the application domain, and execute code
        // there.
        AppDomain ad = AppDomain.CreateDomain("New domain");
        Worker remoteWorker = (Worker) ad.CreateInstanceAndUnwrap(
            typeof(Worker).Assembly.FullName,
            "Worker");
        remoteWorker.PrintDomain();
    }
}

/* This code produces output similar to the following:

Object is executing in AppDomain "source.exe"
Object is executing in AppDomain "New domain"
 */

Imports System.Reflection

Public Class Worker
    Inherits MarshalByRefObject
    
    Public Sub PrintDomain() 
        Console.WriteLine("Object is executing in AppDomain ""{0}""", _
            AppDomain.CurrentDomain.FriendlyName)
    End Sub 
End Class 

Class Example
    
    Public Shared Sub Main() 
        ' Create an ordinary instance in the current AppDomain
        Dim localWorker As New Worker()
        localWorker.PrintDomain()
        
        ' Create a new application domain, create an instance
        ' of Worker in the application domain, and execute code
        ' there.
        Dim ad As AppDomain = AppDomain.CreateDomain("New domain")
        Dim remoteWorker As Worker = CType( _
            ad.CreateInstanceAndUnwrap( _
                GetType(Worker).Assembly.FullName, _
                "Worker"), _
            Worker)
        remoteWorker.PrintDomain()
    
    End Sub 
End Class 

' This code produces output similar to the following:
'
'Object is executing in AppDomain "source.exe"
'Object is executing in AppDomain "New domain"

Exemple 2

L’exemple suivant illustre une classe dérivée de MarshalByRefObject qui est utilisée ultérieurement dans la communication à distance.

using namespace System;
using namespace System::Runtime::Remoting;
using namespace System::Security::Permissions;

public ref class SetObjectUriForMarshalTest
{
public:
   ref class TestClass: public MarshalByRefObject{};

   [SecurityPermissionAttribute(SecurityAction::Demand, Flags=SecurityPermissionFlag::RemotingConfiguration)]   
   static void Main()
   {
      TestClass^ obj = gcnew TestClass;
      RemotingServices::SetObjectUriForMarshal( obj,  "testUri" );
      RemotingServices::Marshal(obj);
      Console::WriteLine( RemotingServices::GetObjectUri( obj ) );
   }

};

using System;
using System.Runtime.Remoting;
using System.Security.Permissions;

public class SetObjectUriForMarshalTest  {

    class TestClass : MarshalByRefObject {
    }

    [SecurityPermission(SecurityAction.Demand, Flags=SecurityPermissionFlag.RemotingConfiguration)]
    public static void Main()  {

        TestClass obj = new TestClass();

        RemotingServices.SetObjectUriForMarshal(obj, "testUri");
        RemotingServices.Marshal(obj);

        Console.WriteLine(RemotingServices.GetObjectUri(obj));
    }
}

Imports System.Runtime.Remoting
Imports System.Security.Permissions


Public Class SetObjectUriForMarshalTest
    
    Class TestClass
        Inherits MarshalByRefObject
    End Class

    <SecurityPermission(SecurityAction.Demand, Flags:= SecurityPermissionFlag.RemotingConfiguration )> _
    Public Shared Sub Main()
        Dim obj As TestClass = New TestClass()

        RemotingServices.SetObjectUriForMarshal(obj, "testUri")
        RemotingServices.Marshal(obj)

        Console.WriteLine(RemotingServices.GetObjectUri(obj))
    End Sub

End Class

Remarques

Un domaine d’application est une partition dans un processus de système d’exploitation où une ou plusieurs applications résident. Les objets dans le même domaine d’application communiquent directement. Les objets dans différents domaines d’application communiquent soit en transportant des copies d’objets au-delà des limites du domaine d’application, soit en utilisant un proxy pour échanger des messages.

MarshalByRefObject est la classe de base pour les objets qui communiquent au-delà des limites du domaine d’application en échangeant des messages à l’aide d’un proxy. Les objets qui n’héritent pas de MarshalByRefObject sont implicitement marshalés par valeur. Lorsqu’une application distante fait référence à un objet marshal by value, une copie de l’objet est passée au-delà des limites du domaine d’application.

MarshalByRefObject les objets sont accessibles directement dans les limites du domaine d’application local. La première fois qu’une application dans un domaine d’application distant accède MarshalByRefObject à un, un proxy est transmis à l’application distante. Les appels suivants sur le proxy sont marshalés de nouveau vers l’objet résidant dans le domaine d’application local.

Les types doivent hériter de MarshalByRefObject lorsque le type est utilisé au-delà des limites du domaine d’application, et l’état de l’objet ne doit pas être copié parce que les membres de l’objet ne sont pas utilisables en dehors du domaine d’application dans lequel ils ont été créés.

Lorsque vous dérivez un objet de MarshalByRefObject pour une utilisation au-delà des limites du domaine d’application, vous ne devez pas substituer l’un de ses membres, ni appeler directement ses méthodes. Le runtime reconnaît que les classes dérivées de MarshalByRefObject doivent être marshalées à travers les limites du domaine d’application.

Constructeurs

Méthodes

S’applique à