MarshalByRefObject Klas

Definitie

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

Overname

Object

MarshalByRefObject

Afgeleid

IEHost.Execute.IEExecuteRemote

Microsoft.Win32.RegistryKey

System.AddIn.Pipeline.ContractBase

System.AppDomain

System.AppDomainManager

Meer…

Kenmerken

SerializableAttribute ComVisibleAttribute

Voorbeelden

Deze sectie bevat twee codevoorbeelden. In het eerste codevoorbeeld ziet u hoe u een exemplaar van een klasse maakt in een ander toepassingsdomein. In het tweede codevoorbeeld ziet u een eenvoudige klasse die kan worden gebruikt voor externe communicatie.

Voorbeeld 1

In het volgende codevoorbeeld ziet u de eenvoudigste manier om code uit te voeren in een ander toepassingsdomein. In het voorbeeld wordt een klasse gedefinieerd Worker die wordt overgenomen MarshalByRefObject, met een methode die de naam weergeeft van het toepassingsdomein waarin deze wordt uitgevoerd. In het voorbeeld worden exemplaren gemaakt van Worker in het standaardtoepassingsdomein en in een nieuw toepassingsdomein.

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 CreateInstanceWorker : MarshalByRefObject
{
    public void PrintDomain()
    {
        Console.WriteLine("Object is executing in AppDomain \"{0}\"",
            AppDomain.CurrentDomain.FriendlyName);
    }
}

class CreateInstanceAndUnwrapSourceSnippet
{
    public static void Main()
    {
        // Create an ordinary instance in the current AppDomain
        CreateInstanceWorker localWorker = new CreateInstanceWorker();
        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");
        CreateInstanceWorker remoteWorker = (CreateInstanceWorker) ad.CreateInstanceAndUnwrap(
            typeof(CreateInstanceWorker).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"
 */

open System
open System.Reflection

type Worker() =
    inherit MarshalByRefObject()
    member _.PrintDomain() =
        printfn $"Object is executing in AppDomain \"{AppDomain.CurrentDomain.FriendlyName}\""

// Create an ordinary instance in the current AppDomain
let localWorker = Worker()
localWorker.PrintDomain()

// Create a new application domain, create an instance
// of Worker in the application domain, and execute code
// there.
let ad = AppDomain.CreateDomain "New domain"
let remoteWorker = 
    ad.CreateInstanceAndUnwrap(typeof<Worker>.Assembly.FullName, "Worker") :?> 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"

Voorbeeld 2

In het volgende voorbeeld ziet u een klasse die is afgeleid van MarshalByRefObject die later in externe communicatie wordt gebruikt.

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;

public class SetObjectUriForMarshalTest  {

    class TestClass : MarshalByRefObject {
    }

    public static void Main()  {

        TestClass obj = new TestClass();

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

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

open System
open System.Runtime.Remoting
open System.Security.Permissions

type TestClass() =
    inherit MarshalByRefObject()

[<EntryPoint>]
let main _ =
    let obj = TestClass()

    RemotingServices.SetObjectUriForMarshal(obj, "testUri")
    RemotingServices.Marshal obj |> ignore

    printfn $"{RemotingServices.GetObjectUri obj}"
    0

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

Opmerkingen

Een toepassingsdomein is een partitie in een besturingssysteemproces waarin een of meer toepassingen zich bevinden. Objecten in hetzelfde toepassingsdomein communiceren rechtstreeks. Objecten in verschillende toepassingsdomeinen communiceren door kopieën van objecten over de grenzen van het toepassingsdomein te verplaatsen of door een proxy te gebruiken om berichten uit te wisselen.

MarshalByRefObject is de basisklasse voor objecten die communiceren over grenzen van toepassingsdomeinen door berichten uit te wisselen met behulp van een proxy. Objecten die niet overnemen van MarshalByRefObject , zijn impliciet marshal op waarde. Wanneer een externe toepassing verwijst naar een marshal by value-object, wordt een kopie van het object doorgegeven aan de grenzen van het toepassingsdomein.

MarshalByRefObject objecten worden rechtstreeks binnen de grenzen van het lokale toepassingsdomein geopend. De eerste keer dat een toepassing in een domein van een externe toepassing toegang krijgt tot een MarshalByRefObjectproxy, wordt doorgegeven aan de externe toepassing. Volgende aanroepen van de proxy worden teruggezet naar het object dat zich in het lokale toepassingsdomein bevindt.

Typen moeten overnemen van MarshalByRefObject wanneer het type wordt gebruikt binnen de grenzen van het toepassingsdomein en de status van het object mag niet worden gekopieerd omdat de leden van het object niet bruikbaar zijn buiten het toepassingsdomein waar ze zijn gemaakt.

Wanneer u een object hebt afgeleid voor MarshalByRefObject gebruik binnen de grenzen van het toepassingsdomein, moet u geen van de leden overschrijven en moet u de bijbehorende methoden ook niet rechtstreeks aanroepen. De runtime herkent dat klassen die zijn afgeleid van MarshalByRefObject , moeten worden marshaled over de grenzen van het app-domein.