MarshalByRefObject Class
Definition
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Enables access to objects across application domain boundaries in applications that support remoting.
public ref class MarshalByRefObject abstractpublic abstract class MarshalByRefObject[System.Serializable]
public abstract class MarshalByRefObject[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class MarshalByRefObjecttype MarshalByRefObject = class[<System.Serializable>]
type MarshalByRefObject = class[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type MarshalByRefObject = classPublic MustInherit Class MarshalByRefObject- Inheritance
-
MarshalByRefObject
- Derived
- Attributes
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.
Note
The assembly that contains Worker must be loaded into both application domains, but it could load other assemblies that would exist only in the 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.
Constructors
| MarshalByRefObject() |
Initializes a new instance of the MarshalByRefObject class. |
Methods
| CreateObjRef(Type) |
Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object. |
| Equals(Object) |
Determines whether the specified object is equal to the current object. (Inherited from Object) |
| GetHashCode() |
Serves as the default hash function. (Inherited from Object) |
| GetLifetimeService() |
Obsolete.
Retrieves the current lifetime service object that controls the lifetime policy for this instance. |
| GetType() |
Gets the Type of the current instance. (Inherited from Object) |
| InitializeLifetimeService() |
Obsolete.
Obtains a lifetime service object to control the lifetime policy for this instance. |
| MemberwiseClone() |
Creates a shallow copy of the current Object. (Inherited from Object) |
| MemberwiseClone(Boolean) |
Creates a shallow copy of the current MarshalByRefObject object. |
| ToString() |
Returns a string that represents the current object. (Inherited from Object) |
