AppDomain Class

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Source:

AppDomain.cs

Represents an application domain, which is an isolated environment where applications execute. This class cannot be inherited.

public ref class AppDomain sealed : MarshalByRefObject

public sealed class AppDomain : MarshalByRefObject

type AppDomain = class
    inherit MarshalByRefObject

Public NotInheritable Class AppDomain
Inherits MarshalByRefObject

Inheritance

Object

MarshalByRefObject

AppDomain

Examples

This example shows how to create a new AppDomain, instantiate a type in that new AppDomain, and communicate with that type's object. In addition, this example shows how to unload the AppDomain causing the object to be garbage collected.

using namespace System;
using namespace System::Reflection;
using namespace System::Threading;
using namespace System::Security::Policy;

// Because this class is derived from MarshalByRefObject, a proxy 
// to a MarshalByRefType object can be returned across an AppDomain 
// boundary.
ref class MarshalByRefType : MarshalByRefObject
{
public:
    //  Call this method via a proxy.
    void SomeMethod(String^ callingDomainName)
    {
        // Get this AppDomain's settings and display some of them.
        AppDomainSetup^ ads = AppDomain::CurrentDomain->SetupInformation;
        Console::WriteLine("AppName={0}, AppBase={1}, ConfigFile={2}", 
            ads->ApplicationName, 
            ads->ApplicationBase, 
            ads->ConfigurationFile
        );

        // Display the name of the calling AppDomain and the name 
        // of the second domain.
        // NOTE: The application's thread has transitioned between 
        // AppDomains.
        Console::WriteLine("Calling from '{0}' to '{1}'.", 
            callingDomainName, 
            Thread::GetDomain()->FriendlyName
        );
    };
};

void main()
{
    // Get and display the friendly name of the default AppDomain.
    String^ callingDomainName = Thread::GetDomain()->FriendlyName;
    Console::WriteLine(callingDomainName);

    // Get and display the full name of the EXE assembly.
    String^ exeAssembly = Assembly::GetEntryAssembly()->FullName;
    Console::WriteLine(exeAssembly);

    // Construct and initialize settings for a second AppDomain.
    AppDomainSetup^ ads = gcnew AppDomainSetup();
    ads->ApplicationBase = AppDomain::CurrentDomain->BaseDirectory;

    ads->DisallowBindingRedirects = false;
    ads->DisallowCodeDownload = true;
    ads->ConfigurationFile = 
        AppDomain::CurrentDomain->SetupInformation->ConfigurationFile;

    // Create the second AppDomain.
    AppDomain^ ad2 = AppDomain::CreateDomain("AD #2", 
        AppDomain::CurrentDomain->Evidence, ads);

    // Create an instance of MarshalbyRefType in the second AppDomain. 
    // A proxy to the object is returned.
    MarshalByRefType^ mbrt = 
        (MarshalByRefType^) ad2->CreateInstanceAndUnwrap(
            exeAssembly, 
            MarshalByRefType::typeid->FullName
        );

    // Call a method on the object via the proxy, passing the 
    // default AppDomain's friendly name in as a parameter.
    mbrt->SomeMethod(callingDomainName);

    // Unload the second AppDomain. This deletes its object and 
    // invalidates the proxy object.
    AppDomain::Unload(ad2);
    try
    {
        // Call the method again. Note that this time it fails 
        // because the second AppDomain was unloaded.
        mbrt->SomeMethod(callingDomainName);
        Console::WriteLine("Sucessful call.");
    }
    catch(AppDomainUnloadedException^)
    {
        Console::WriteLine("Failed call; this is expected.");
    }
}

/* This code produces output similar to the following: 

AppDomainX.exe
AppDomainX, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
AppName=, AppBase=C:\AppDomain\bin, ConfigFile=C:\AppDomain\bin\AppDomainX.exe.config
Calling from 'AppDomainX.exe' to 'AD #2'.
Failed call; this is expected.
 */

using System;
using System.Reflection;
using System.Threading;

class Module1
{
    public static void Main()
    {
        // Get and display the friendly name of the default AppDomain.
        string callingDomainName = Thread.GetDomain().FriendlyName;
        Console.WriteLine(callingDomainName);

        // Get and display the full name of the EXE assembly.
        string exeAssembly = Assembly.GetEntryAssembly().FullName;
        Console.WriteLine(exeAssembly);

        // Construct and initialize settings for a second AppDomain.
        AppDomainSetup ads = new AppDomainSetup();
        ads.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;

        ads.DisallowBindingRedirects = false;
        ads.DisallowCodeDownload = true;
        ads.ConfigurationFile =
            AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;

        // Create the second AppDomain.
        AppDomain ad2 = AppDomain.CreateDomain("AD #2", null, ads);

        // Create an instance of MarshalbyRefType in the second AppDomain.
        // A proxy to the object is returned.
        MarshalByRefType mbrt =
            (MarshalByRefType) ad2.CreateInstanceAndUnwrap(
                exeAssembly,
                typeof(MarshalByRefType).FullName
            );

        // Call a method on the object via the proxy, passing the
        // default AppDomain's friendly name in as a parameter.
        mbrt.SomeMethod(callingDomainName);

        // Unload the second AppDomain. This deletes its object and
        // invalidates the proxy object.
        AppDomain.Unload(ad2);
        try
        {
            // Call the method again. Note that this time it fails
            // because the second AppDomain was unloaded.
            mbrt.SomeMethod(callingDomainName);
            Console.WriteLine("Sucessful call.");
        }
        catch(AppDomainUnloadedException)
        {
            Console.WriteLine("Failed call; this is expected.");
        }
    }
}

// Because this class is derived from MarshalByRefObject, a proxy
// to a MarshalByRefType object can be returned across an AppDomain
// boundary.
public class MarshalByRefType : MarshalByRefObject
{
    //  Call this method via a proxy.
    public void SomeMethod(string callingDomainName)
    {
        // Get this AppDomain's settings and display some of them.
        AppDomainSetup ads = AppDomain.CurrentDomain.SetupInformation;
        Console.WriteLine("AppName={0}, AppBase={1}, ConfigFile={2}",
            ads.ApplicationName,
            ads.ApplicationBase,
            ads.ConfigurationFile
        );

        // Display the name of the calling AppDomain and the name
        // of the second domain.
        // NOTE: The application's thread has transitioned between
        // AppDomains.
        Console.WriteLine("Calling from '{0}' to '{1}'.",
            callingDomainName,
            Thread.GetDomain().FriendlyName
        );
    }
}

/* This code produces output similar to the following:

AppDomainX.exe
AppDomainX, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
AppName=, AppBase=C:\AppDomain\bin, ConfigFile=C:\AppDomain\bin\AppDomainX.exe.config
Calling from 'AppDomainX.exe' to 'AD #2'.
Failed call; this is expected.
 */

open System
open System.Reflection
open System.Threading

// Because this class is derived from MarshalByRefObject, a proxy
// to a MarshalByRefType object can be returned across an AppDomain
// boundary.
type MarshalByRefType() =
    inherit MarshalByRefObject()
    
    //  Call this method via a proxy.
    member _.SomeMethod(callingDomainName) =
        // Get this AppDomain's settings and display some of them.
        let ads = AppDomain.CurrentDomain.SetupInformation
        printfn $"AppName={ads.ApplicationName}, AppBase={ads.ApplicationBase}, ConfigFile={ads.ConfigurationFile}"

        // Display the name of the calling AppDomain and the name
        // of the second domain.
        // NOTE: The application's thread has transitioned between
        // AppDomains.
        printfn $"Calling from '{callingDomainName}' to '{Thread.GetDomain().FriendlyName}'."

// Get and display the friendly name of the default AppDomain.
let callingDomainName = Thread.GetDomain().FriendlyName
printfn $"{callingDomainName}"

// Get and display the full name of the EXE assembly.
let exeAssembly = Assembly.GetEntryAssembly().FullName
printfn $"{exeAssembly}"

// Construct and initialize settings for a second AppDomain.
let ads = AppDomainSetup()
ads.ApplicationBase <- AppDomain.CurrentDomain.BaseDirectory

ads.DisallowBindingRedirects <- false
ads.DisallowCodeDownload <- true
ads.ConfigurationFile <-
    AppDomain.CurrentDomain.SetupInformation.ConfigurationFile

// Create the second AppDomain.
let ad2 = AppDomain.CreateDomain("AD #2", null, ads)

// Create an instance of MarshalbyRefType in the second AppDomain.
// A proxy to the object is returned.
let mbrt =
    ad2.CreateInstanceAndUnwrap(
        exeAssembly,
        typeof<MarshalByRefType>.FullName) :?> MarshalByRefType

// Call a method on the object via the proxy, passing the
// default AppDomain's friendly name in as a parameter.
mbrt.SomeMethod callingDomainName

// Unload the second AppDomain. This deletes its object and
// invalidates the proxy object.
AppDomain.Unload ad2
try
    // Call the method again. Note that this time it fails
    // because the second AppDomain was unloaded.
    mbrt.SomeMethod callingDomainName
    printfn "Sucessful call."
with :? AppDomainUnloadedException ->
    printfn "Failed call this is expected."

(* This code produces output similar to the following:

AppDomainX.exe
AppDomainX, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
AppName=, AppBase=C:\AppDomain\bin, ConfigFile=C:\AppDomain\bin\AppDomainX.exe.config
Calling from 'AppDomainX.exe' to 'AD #2'.
Failed call this is expected.
 *)

Imports System.Reflection
Imports System.Threading

Module Module1
    Sub Main()

        ' Get and display the friendly name of the default AppDomain.
        Dim callingDomainName As String = Thread.GetDomain().FriendlyName
        Console.WriteLine(callingDomainName)

        ' Get and display the full name of the EXE assembly.
        Dim exeAssembly As String = [Assembly].GetEntryAssembly().FullName
        Console.WriteLine(exeAssembly)

        ' Construct and initialize settings for a second AppDomain.
        Dim ads As New AppDomainSetup()
        ads.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory
        ads.DisallowBindingRedirects = False
        ads.DisallowCodeDownload = True
        ads.ConfigurationFile = _
            AppDomain.CurrentDomain.SetupInformation.ConfigurationFile

        ' Create the second AppDomain.
        Dim ad2 As AppDomain = AppDomain.CreateDomain("AD #2", Nothing, ads)

        ' Create an instance of MarshalbyRefType in the second AppDomain. 
        ' A proxy to the object is returned.
        Dim mbrt As MarshalByRefType = CType( _
            ad2.CreateInstanceAndUnwrap(exeAssembly, _
                 GetType(MarshalByRefType).FullName), MarshalByRefType)

        ' Call a method on the object via the proxy, passing the default 
        ' AppDomain's friendly name in as a parameter.
        mbrt.SomeMethod(callingDomainName)

        ' Unload the second AppDomain. This deletes its object and 
        ' invalidates the proxy object.
        AppDomain.Unload(ad2)
        Try
            ' Call the method again. Note that this time it fails because 
            ' the second AppDomain was unloaded.
            mbrt.SomeMethod(callingDomainName)
            Console.WriteLine("Sucessful call.")
        Catch e As AppDomainUnloadedException
            Console.WriteLine("Failed call; this is expected.")
        End Try

    End Sub
End Module

' Because this class is derived from MarshalByRefObject, a proxy 
' to a MarshalByRefType object can be returned across an AppDomain 
' boundary.
Public Class MarshalByRefType
    Inherits MarshalByRefObject

    '  Call this method via a proxy.
    Public Sub SomeMethod(ByVal callingDomainName As String)

        ' Get this AppDomain's settings and display some of them.
        Dim ads As AppDomainSetup = AppDomain.CurrentDomain.SetupInformation
        Console.WriteLine("AppName={0}, AppBase={1}, ConfigFile={2}", _
            ads.ApplicationName, ads.ApplicationBase, ads.ConfigurationFile)

        ' Display the name of the calling AppDomain and the name 
        ' of the second domain.
        ' NOTE: The application's thread has transitioned between 
        ' AppDomains.
        Console.WriteLine("Calling from '{0}' to '{1}'.", _
            callingDomainName, Thread.GetDomain().FriendlyName)
    End Sub
End Class

'This code produces output similar to the following:
' 
' AppDomainX.exe
' AppDomainX, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
' AppName=, AppBase=C:\AppDomain\bin, ConfigFile=C:\AppDomain\bin\AppDomainX.exe.config
' Calling from 'AppDomainX.exe' to 'AD #2'.
' Failed call; this is expected.

Remarks

Application domains, which are represented by AppDomain objects, help provide isolation, unloading, and security boundaries for executing managed code.

• Use application domains to isolate tasks that might bring down a process. If the state of the AppDomain that's executing a task becomes unstable, the AppDomain can be unloaded without affecting the process. This is important when a process must run for long periods without restarting. You can also use application domains to isolate tasks that should not share data.

• If an assembly is loaded into the default application domain, it cannot be unloaded from memory while the process is running. However, if you open a second application domain to load and execute the assembly, the assembly is unloaded when that application domain is unloaded. Use this technique to minimize the working set of long-running processes that occasionally use large DLLs.

Note

On .NET Core, the AppDomain implementation is limited by design and does not provide isolation, unloading, or security boundaries. For .NET Core, there is exactly one AppDomain. Isolation and unloading are provided through AssemblyLoadContext. Security boundaries should be provided by process boundaries and appropriate remoting techniques.

Multiple application domains can run in a single process; however, there is not a one-to-one correlation between application domains and threads. Several threads can belong to a single application domain, and while a given thread is not confined to a single application domain, at any given time, a thread executes in a single application domain.

Application domains are created using the CreateDomain method. AppDomain instances are used to load and execute assemblies (Assembly). When an AppDomain is no longer in use, it can be unloaded.

The AppDomain class implements a set of events that enable applications to respond when an assembly is loaded, when an application domain will be unloaded, or when an unhandled exception is thrown.

For more information on using application domains, see Application Domains.

This class implements the MarshalByRefObject, _AppDomain, and IEvidenceFactory interfaces.

You should never create a remotable wrapper for an AppDomain object. Doing so could publish a remote reference to that AppDomain, exposing methods such as CreateInstance to remote access and effectively destroying code access security for that AppDomain. Malicious clients connecting to the remoted AppDomain could obtain access to any resource the AppDomain itself has access to. Do not create remotable wrappers for any type that extends MarshalByRefObject and that implements methods that could be used by malicious clients to bypass the security system.

Caution

The default value for the AppDomainSetup.DisallowCodeDownload property is false. This setting is unsafe for services. To prevent services from downloading partially trusted code, set this property to true.

Properties

BaseDirectory	Gets the base directory that the assembly resolver uses to probe for assemblies.
CurrentDomain	Gets the current application domain for the current Thread.
DynamicDirectory	Gets the directory that the assembly resolver uses to probe for dynamically created assemblies.
FriendlyName	Gets the friendly name of this application domain.
Id	Gets an integer that uniquely identifies the application domain within the process.
IsFullyTrusted	Gets a value that indicates whether assemblies that are loaded into the current application domain execute with full trust.
IsHomogenous	Gets a value that indicates whether the current application domain has a set of permissions that is granted to all assemblies that are loaded into the application domain.
MonitoringIsEnabled	Gets or sets a value that indicates whether CPU and memory monitoring of application domains is enabled for the current process. Once monitoring is enabled for a process, it cannot be disabled.
MonitoringSurvivedMemorySize	Gets the number of bytes that survived the last collection and that are known to be referenced by the current application domain.
MonitoringSurvivedProcessMemorySize	Gets the total bytes that survived from the last collection for all application domains in the process.
MonitoringTotalAllocatedMemorySize	Gets the total size, in bytes, of all memory allocations that have been made by the application domain since it was created, without subtracting memory that has been collected.
MonitoringTotalProcessorTime	Gets the total processor time that has been used by all threads while executing in the current application domain, since the process started.
PermissionSet	Obsolete. Gets the permission set of a sandboxed application domain.
RelativeSearchPath	Gets the path under the base directory where the assembly resolver should probe for private assemblies.
SetupInformation	Gets the application domain configuration information for this instance.
ShadowCopyFiles	Gets an indication whether the application domain is configured to shadow copy files.

Methods

AppendPrivatePath(String)	Obsolete. Appends the specified directory name to the private path list.
ApplyPolicy(String)	Returns the assembly display name after policy has been applied.
ClearPrivatePath()	Obsolete. Resets the path that specifies the location of private assemblies to the empty string ("").
ClearShadowCopyPath()	Obsolete. Resets the list of directories containing shadow copied assemblies to the empty string ("").
CreateDomain(String)	Obsolete. Creates a new application domain with the specified name.
CreateInstance(String, String)	Creates a new instance of the specified type defined in the specified assembly.
CreateInstance(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Creates a new instance of the specified type defined in the specified assembly. Parameters specify a binder, binding flags, constructor arguments, culture-specific information used to interpret arguments, and optional activation attributes.
CreateInstance(String, String, Object[])	Creates a new instance of the specified type defined in the specified assembly. A parameter specifies an array of activation attributes.
CreateInstanceAndUnwrap(String, String)	Creates a new instance of the specified type. Parameters specify the assembly where the type is defined, and the name of the type.
CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Creates a new instance of the specified type defined in the specified assembly, specifying whether the case of the type name is ignored; the binding attributes and the binder that are used to select the type to be created; the arguments of the constructor; the culture; and the activation attributes.
CreateInstanceAndUnwrap(String, String, Object[])	Creates a new instance of the specified type. Parameters specify the assembly where the type is defined, the name of the type, and an array of activation attributes.
CreateInstanceFrom(String, String)	Creates a new instance of the specified type defined in the specified assembly file.
CreateInstanceFrom(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Creates a new instance of the specified type defined in the specified assembly file.
CreateInstanceFrom(String, String, Object[])	Creates a new instance of the specified type defined in the specified assembly file.
CreateInstanceFromAndUnwrap(String, String)	Creates a new instance of the specified type defined in the specified assembly file.
CreateInstanceFromAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Creates a new instance of the specified type defined in the specified assembly file, specifying whether the case of the type name is ignored; the binding attributes and the binder that are used to select the type to be created; the arguments of the constructor; the culture; and the activation attributes.
CreateInstanceFromAndUnwrap(String, String, Object[])	Creates a new instance of the specified type defined in the specified assembly file.
CreateObjRef(Type)	Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object. (Inherited from MarshalByRefObject)
Equals(Object)	Determines whether the specified object is equal to the current object. (Inherited from Object)
ExecuteAssembly(String)	Executes the assembly contained in the specified file.
ExecuteAssembly(String, String[])	Executes the assembly contained in the specified file, using the specified arguments.
ExecuteAssembly(String, String[], Byte[], AssemblyHashAlgorithm)	Obsolete. Executes the assembly contained in the specified file, using the specified arguments, hash value, and hash algorithm.
ExecuteAssemblyByName(AssemblyName, String[])	Executes the assembly given an AssemblyName, using the specified arguments.
ExecuteAssemblyByName(String)	Executes an assembly given its display name.
ExecuteAssemblyByName(String, String[])	Executes the assembly given its display name, using the specified arguments.
GetAssemblies()	Gets the assemblies that have been loaded into the execution context of this application domain.
GetCurrentThreadId()	Obsolete. Gets the current thread identifier.
GetData(String)	Gets the value stored in the current application domain for the specified name.
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. (Inherited from MarshalByRefObject)
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. (Inherited from MarshalByRefObject)
IsCompatibilitySwitchSet(String)	Gets a nullable Boolean value that indicates whether any compatibility switches are set, and if so, whether the specified compatibility switch is set.
IsDefaultAppDomain()	Returns a value that indicates whether the application domain is the default application domain for the process.
IsFinalizingForUnload()	Indicates whether this application domain is unloading, and the objects it contains are being finalized by the common language runtime.
Load(AssemblyName)	Loads an Assembly given its AssemblyName.
Load(Byte[])	Loads the Assembly with a common object file format (COFF) based image containing an emitted Assembly.
Load(Byte[], Byte[])	Loads the Assembly with a common object file format (COFF) based image containing an emitted Assembly. The raw bytes representing the symbols for the Assembly are also loaded.
Load(String)	Loads an Assembly given its display name.
MemberwiseClone()	Creates a shallow copy of the current Object. (Inherited from Object)
MemberwiseClone(Boolean)	Creates a shallow copy of the current MarshalByRefObject object. (Inherited from MarshalByRefObject)
ReflectionOnlyGetAssemblies()	Returns the assemblies that have been loaded into the reflection-only context of the application domain.
SetCachePath(String)	Obsolete. Establishes the specified directory path as the location where assemblies are shadow copied.
SetData(String, Object)	Assigns the specified value to the specified application domain property.
SetDynamicBase(String)	Obsolete. Establishes the specified directory path as the base directory for subdirectories where dynamically generated files are stored and accessed.
SetPrincipalPolicy(PrincipalPolicy)	Specifies how principal and identity objects should be attached to a thread if the thread attempts to bind to a principal while executing in this application domain.
SetShadowCopyFiles()	Obsolete. Turns on shadow copying.
SetShadowCopyPath(String)	Obsolete. Establishes the specified directory path as the location of assemblies to be shadow copied.
SetThreadPrincipal(IPrincipal)	Sets the default principal object to be attached to threads if they attempt to bind to a principal while executing in this application domain.
ToString()	Obtains a string representation that includes the friendly name of the application domain and any context policies.
Unload(AppDomain)	Obsolete. Unloads the specified application domain.

Events

AssemblyLoad	Occurs when an assembly is loaded.
AssemblyResolve	Occurs when the resolution of an assembly fails.
DomainUnload	Occurs when an AppDomain is about to be unloaded.
FirstChanceException	Occurs when an exception is thrown in managed code, before the runtime searches the call stack for an exception handler in the application domain.
ProcessExit	Occurs when the default application domain's parent process exits.
ReflectionOnlyAssemblyResolve	Occurs when the resolution of an assembly fails in the reflection-only context.
ResourceResolve	Occurs when the resolution of a resource fails because the resource is not a valid linked or embedded resource in the assembly.
TypeResolve	Occurs when the resolution of a type fails.
UnhandledException	Occurs when an exception is not caught.

See also

• How To: Configure an Application Domain
• How To: Create an Application Domain
• How to: Load Assemblies into an Application Domain
• How to: Unload an Application Domain