Condividi tramite

MarshalByRefObject Classe

  • Riferimento

Definizione

Spazio dei nomi:
System
Assembly:
System.Runtime.dll
Assembly:
netstandard.dll
Assembly:
mscorlib.dll

Consente l'accesso a oggetti attraverso limiti di dominio nelle applicazioni che supportano servizi remoti.

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
Ereditarietà
Object
MarshalByRefObject
Derivato
Attributi
SerializableAttribute ComVisibleAttribute

Esempio

In questa sezione sono riportati due esempi di codice. Il primo esempio di codice illustra come creare un'istanza di una classe in un altro dominio applicazione. Il secondo esempio di codice mostra una classe semplice che può essere usata per la comunicazione remota.

Esempio 1

L'esempio di codice seguente illustra il modo più semplice per eseguire codice in un altro dominio applicazione. Nell'esempio viene definita una classe denominata che eredita , con un metodo che visualizza il nome del dominio applicazione Worker in cui è in MarshalByRefObject esecuzione. Nell'esempio vengono create istanze Worker di nel dominio applicazione predefinito e in un nuovo dominio applicazione.

Nota

L'assembly che contiene deve essere caricato in entrambi i domini applicazione, ma potrebbe caricare altri assembly che esisterebbero solo Worker nel nuovo dominio applicazione.

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"

Esempio 2

Nell'esempio seguente viene illustrata una classe derivata MarshalByRefObject da che viene usata più avanti nella comunicazione remota.

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

Commenti

Un dominio applicazione è una partizione in un processo del sistema operativo in cui risiedono una o più applicazioni. Gli oggetti nello stesso dominio applicazione comunicano direttamente. Gli oggetti in domini applicazione diversi comunicano trasportando copie di oggetti tra i limiti del dominio applicazione o usando un proxy per lo scambio di messaggi.

MarshalByRefObject è la classe di base per gli oggetti che comunicano attraverso i limiti del dominio applicazione scambiando messaggi tramite un proxy. Gli oggetti che non ereditano da vengono MarshalByRefObject sottoposti a marshalling implicito per valore. Quando un'applicazione remota fa riferimento a un oggetto marshalling in base al valore, una copia dell'oggetto viene passata attraverso i limiti del dominio applicazione.

MarshalByRefObject Gli oggetti sono accessibili direttamente all'interno dei limiti del dominio applicazione locale. La prima volta che un'applicazione in un dominio applicazione remoto accede a , viene passato un MarshalByRefObject proxy all'applicazione remota. Viene eseguito il marshalling delle chiamate successive sul proxy all'oggetto che risiede nel dominio applicazione locale.

I tipi devono ereditare da quando il tipo viene usato oltre i limiti del dominio applicazione e lo stato dell'oggetto non deve essere copiato perché i membri dell'oggetto non sono utilizzabili all'esterno del dominio applicazione in cui sono stati MarshalByRefObject creati.

Quando si deriva un oggetto da per l'uso tra i limiti del dominio applicazione, non è necessario eseguire l'override di alcun membro né chiamare MarshalByRefObject direttamente i relativi metodi. Il runtime riconosce che le classi derivate da MarshalByRefObject devono essere sottoposti a marshalling tra i limiti del dominio dell'app.

Costruttori

MarshalByRefObject()

Inizializza una nuova istanza della classe MarshalByRefObject.

Metodi

CreateObjRef(Type)

Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.
Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetLifetimeService()
Obsoleta.

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.
GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
InitializeLifetimeService()
Obsoleta.

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)

Si applica a