MarshalByRefObject Class

Definition

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

Inheritance

Object

MarshalByRefObject

Derived

IEHost.Execute.IEExecuteRemote

Microsoft.IO.FileSystemInfo

Microsoft.Win32.RegistryKey

System.AddIn.Pipeline.ContractBase

System.AppDomain

More…

Attributes

SerializableAttribute ComVisibleAttribute

Examples

This section contains two code examples. The first code example shows how to create an instance of a class in another application ___domain. The second code example shows a simple class that can be used for remoting.

Example 1

The following code example shows the simplest way to execute code in another application ___domain. The example defines a class named Worker that inherits MarshalByRefObject, with a method that displays the name of the application ___domain in which it is executing. The example creates instances of Worker in the default application ___domain and in a new application ___domain.

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"

Example 2

The following example demonstrates a class derived from MarshalByRefObject that is used later in remoting.

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

Remarks

An application ___domain is a partition in an operating system process where one or more applications reside. Objects in the same application ___domain communicate directly. Objects in different application domains communicate either by transporting copies of objects across application ___domain boundaries, or by using a proxy to exchange messages.

MarshalByRefObject is the base class for objects that communicate across application ___domain boundaries by exchanging messages using a proxy. Objects that do not inherit from MarshalByRefObject are implicitly marshal by value. When a remote application references a marshal by value object, a copy of the object is passed across application ___domain boundaries.

MarshalByRefObject objects are accessed directly within the boundaries of the local application ___domain. The first time an application in a remote application ___domain accesses a MarshalByRefObject, a proxy is passed to the remote application. Subsequent calls on the proxy are marshaled back to the object residing in the local application ___domain.

Types must inherit from MarshalByRefObject when the type is used across application ___domain boundaries, and the state of the object must not be copied because the members of the object are not usable outside the application ___domain where they were created.

When you derive an object from MarshalByRefObject for use across application ___domain boundaries, you should not override any of its members, nor should you call its methods directly. The runtime recognizes that classes derived from MarshalByRefObject should be marshaled across app ___domain boundaries.