MarshalByRefObject Classe

Definição

public ref class MarshalByRefObject abstract

[System.Serializable]
public abstract class MarshalByRefObject

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

public abstract class MarshalByRefObject

[<System.Serializable>]
type MarshalByRefObject = class

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

type MarshalByRefObject = class

Public MustInherit Class MarshalByRefObject

Herança

Object

MarshalByRefObject

Derivado

IEHost.Execute.IEExecuteRemote

Microsoft.Win32.RegistryKey

System.AddIn.Pipeline.ContractBase

System.AppDomain

System.AppDomainManager

Mais…

Atributos

SerializableAttribute ComVisibleAttribute

Exemplos

Esta seção contém dois exemplos de código. O primeiro exemplo de código mostra como criar uma instância de uma classe noutro domínio de aplicação. O segundo exemplo de código mostra uma classe simples que pode ser usada para remoto.

Exemplo 1

O seguinte exemplo de código mostra a forma mais simples de executar código noutro domínio de aplicação. O exemplo define uma classe chamada Worker que herda MarshalByRefObject, com um método que apresenta o nome do domínio de aplicação em que está a ser executado. O exemplo cria instâncias de Worker no domínio de aplicação predefinido e num novo domínio de aplicação.

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"

Exemplo 2

O exemplo seguinte demonstra uma classe derivada de MarshalByRefObject que é usada mais tarde em remoto.

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

Observações

Um domínio de aplicação é uma partição num processo do sistema operativo onde residem uma ou mais aplicações. Objetos no mesmo domínio de aplicação comunicam diretamente. Objetos em diferentes domínios de aplicação comunicam transportando cópias de objetos através dos limites do domínio de aplicação, ou usando um proxy para trocar mensagens.

MarshalByRefObject é a classe base para objetos que comunicam através dos limites do domínio da aplicação através da troca de mensagens através de um proxy. Objetos que não herdam de MarshalByRefObject são implicitamente marshal por valor. Quando uma aplicação remota faz referência a um objeto marshal por valor, uma cópia do objeto é passada através dos limites do domínio da aplicação.

MarshalByRefObject Os objetos são acedidos diretamente dentro dos limites do domínio de aplicação local. A primeira vez que uma aplicação num domínio remoto acede a um MarshalByRefObject, um proxy é passado para a aplicação remota. Chamadas subsequentes ao proxy são marshaladas de volta para o objeto que reside no domínio de aplicação local.

Os tipos devem herdar de MarshalByRefObject quando o tipo é usado através dos limites do domínio da aplicação, e o estado do objeto não pode ser copiado porque os membros do objeto não são utilizáveis fora do domínio da aplicação onde foram criados.

Quando deriva um objeto de MarshalByRefObject para uso através dos limites do domínio da aplicação, não deve sobrepor nenhum dos seus membros, nem deve chamar diretamente os seus métodos. O runtime reconhece que as classes derivadas de MarshalByRefObject devem ser organizadas através dos limites do domínio da aplicação.