AppDomain Classe

Definizione

Spazio dei nomi:

System

Assembly:

netstandard.dll, System.Runtime.dll

Origine:

AppDomain.cs

Rappresenta un dominio applicazione, che è un ambiente isolato in cui vengono eseguite le applicazioni. Questa classe non può essere ereditata.

public ref class AppDomain sealed : MarshalByRefObject

public sealed class AppDomain : MarshalByRefObject

type AppDomain = class
    inherit MarshalByRefObject

Public NotInheritable Class AppDomain
Inherits MarshalByRefObject

Ereditarietà

Object

MarshalByRefObject

AppDomain

Esempio

In questo esempio viene illustrato come creare una nuova AppDomainistanza di un tipo in tale nuovo AppDomainoggetto e comunicare con l'oggetto del tipo. In questo esempio viene inoltre illustrato come scaricare l'oggetto AppDomain che causa il Garbage Collection dell'oggetto.

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.

Commenti

I domini applicazione, rappresentati da AppDomain oggetti, consentono di fornire isolamento, scaricamento e limiti di sicurezza per l'esecuzione di codice gestito.

• Usare i domini applicazione per isolare le attività che potrebbero causare l'arresto di un processo. Se lo stato dell'oggetto AppDomain che esegue un'attività diventa instabile, può AppDomain essere scaricato senza influire sul processo. Questo è importante quando un processo deve essere eseguito per lunghi periodi senza riavviare. È anche possibile usare i domini applicazione per isolare le attività che non devono condividere i dati.
• Se un assembly viene caricato nel dominio applicazione predefinito, non può essere scaricato dalla memoria durante l'esecuzione del processo. Tuttavia, se si apre un secondo dominio applicazione per caricare ed eseguire l'assembly, l'assembly viene scaricato quando tale dominio applicazione viene scaricato. Usare questa tecnica per ridurre al minimo il working set di processi a esecuzione prolungata che in alcuni casi usano DLL di grandi dimensioni.

Annotazioni

In .NET Core e .NET 5+, l'implementazione AppDomain è limitata dalla progettazione e non fornisce isolamento, scaricamento o limiti di sicurezza. Queste versioni hanno esattamente un oggetto AppDomain. L'isolamento e lo scaricamento vengono forniti tramite AssemblyLoadContext. I limiti di sicurezza devono essere forniti dai limiti dei processi e dalle tecniche di comunicazione remota appropriate.

Più domini applicazione possono essere eseguiti in un unico processo; Tuttavia, non esiste una correlazione uno-a-uno tra domini applicazione e thread. Diversi thread possono appartenere a un singolo dominio applicazione e, mentre un determinato thread non è limitato a un singolo dominio applicazione, in qualsiasi momento, un thread viene eseguito in un singolo dominio applicazione.

I domini applicazione vengono creati usando il CreateDomain metodo . AppDomain Le istanze vengono usate per caricare ed eseguire assembly (Assembly). Quando un oggetto AppDomain non è più in uso, può essere scaricato.

La AppDomain classe implementa un set di eventi che consentono alle applicazioni di rispondere quando viene caricato un assembly, quando un dominio applicazione verrà scaricato o quando viene generata un'eccezione non gestita.

Per altre informazioni sull'uso dei domini applicazione, vedere Domini applicazione.

Questa classe implementa le MarshalByRefObjectinterfacce , _AppDomaine IEvidenceFactory .

Non è mai consigliabile creare un wrapper remotabile per un AppDomain oggetto . In questo modo è possibile pubblicare un riferimento remoto a tale AppDomainoggetto , esponendo metodi quali CreateInstance l'accesso remoto ed eliminando in modo efficace la sicurezza dell'accesso al codice per tale AppDomainoggetto . I client malintenzionati che si connettono al remoto AppDomain potrebbero ottenere l'accesso a qualsiasi risorsa a AppDomain cui ha accesso. Non creare wrapper remotabili per qualsiasi tipo che estende MarshalByRefObject e che implementa metodi che potrebbero essere usati da client malintenzionati per ignorare il sistema di sicurezza.

Attenzione

Il valore predefinito per la proprietàAppDomainSetup.DisallowCodeDownload è false. Questa impostazione non è sicura per i servizi. Per impedire ai servizi di scaricare codice parzialmente attendibile, impostare questa proprietà su true.

Proprietà

Nome	Descrizione
BaseDirectory	Ottiene la directory di base utilizzata dal sistema di risoluzione dell'assembly per eseguire il probe degli assembly.
CurrentDomain	Ottiene il dominio applicazione corrente per l'oggetto corrente Thread.
DynamicDirectory	Ottiene la directory utilizzata dal resolver dell'assembly per eseguire il probe degli assembly creati dinamicamente.
FriendlyName	Ottiene il nome descrittivo di questo dominio applicazione.
Id	Ottiene un numero intero che identifica in modo univoco il dominio applicazione all'interno del processo.
IsFullyTrusted	Ottiene un valore che indica se gli assembly caricati nel dominio applicazione corrente vengono eseguiti con attendibilità totale.
IsHomogenous	Ottiene un valore che indica se il dominio applicazione corrente dispone di un set di autorizzazioni concesse a tutti gli assembly caricati nel dominio applicazione.
MonitoringIsEnabled	Ottiene o imposta un valore che indica se il monitoraggio della CPU e della memoria dei domini applicazione è abilitato per il processo corrente. Una volta abilitato il monitoraggio per un processo, non può essere disabilitato.
MonitoringSurvivedMemorySize	Ottiene il numero di byte che sono sopravvissuti all'ultima raccolta e a cui fa riferimento il dominio applicazione corrente.
MonitoringSurvivedProcessMemorySize	Ottiene i byte totali che sono sopravvissuti all'ultima raccolta per tutti i domini applicazione nel processo.
MonitoringTotalAllocatedMemorySize	Ottiene le dimensioni totali, in byte, di tutte le allocazioni di memoria effettuate dal dominio applicazione dopo la creazione, senza sottrarre memoria che è stata raccolta.
MonitoringTotalProcessorTime	Ottiene il tempo totale del processore utilizzato da tutti i thread durante l'esecuzione nel dominio applicazione corrente, dall'avvio del processo.
PermissionSet	Obsoleti. Ottiene il set di autorizzazioni di un dominio applicazione in modalità sandbox.
RelativeSearchPath	Ottiene il percorso nella directory di base in cui il resolver dell'assembly deve eseguire il probe per gli assembly privati.
SetupInformation	Ottiene le informazioni di configurazione del dominio applicazione per questa istanza.
ShadowCopyFiles	Ottiene un'indicazione se il dominio applicazione è configurato per i file di copia shadow.

Metodi

Nome	Descrizione
AppendPrivatePath(String)	Obsoleti. Aggiunge il nome della directory specificato all'elenco di percorsi privati.
ApplyPolicy(String)	Restituisce il nome visualizzato dell'assembly dopo l'applicazione dei criteri.
ClearPrivatePath()	Obsoleti. Reimposta il percorso che specifica il percorso degli assembly privati sulla stringa vuota ("").
ClearShadowCopyPath()	Obsoleti. Reimposta l'elenco di directory contenenti assembly copiati shadow nella stringa vuota ("").
CreateDomain(String)	Obsoleti. Crea un nuovo dominio applicazione con il nome specificato.
CreateInstance(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Crea una nuova istanza del tipo specificato definito nell'assembly specificato. I parametri specificano un binder, flag di associazione, argomenti del costruttore, informazioni specifiche delle impostazioni cultura usate per interpretare gli argomenti e attributi di attivazione facoltativi.
CreateInstance(String, String, Object[])	Crea una nuova istanza del tipo specificato definito nell'assembly specificato. Un parametro specifica una matrice di attributi di attivazione.
CreateInstance(String, String)	Crea una nuova istanza del tipo specificato definito nell'assembly specificato.
CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Crea una nuova istanza del tipo specificato definito nell'assembly specificato, specificando se il caso del nome del tipo viene ignorato; gli attributi di associazione e il binder utilizzati per selezionare il tipo da creare; gli argomenti del costruttore; la cultura; e gli attributi di attivazione.
CreateInstanceAndUnwrap(String, String, Object[])	Crea una nuova istanza del tipo specificato. I parametri specificano l'assembly in cui è definito il tipo, il nome del tipo e una matrice di attributi di attivazione.
CreateInstanceAndUnwrap(String, String)	Crea una nuova istanza del tipo specificato. I parametri specificano l'assembly in cui è definito il tipo e il nome del tipo.
CreateInstanceFrom(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Crea una nuova istanza del tipo specificato definito nel file di assembly specificato.
CreateInstanceFrom(String, String, Object[])	Crea una nuova istanza del tipo specificato definito nel file di assembly specificato.
CreateInstanceFrom(String, String)	Crea una nuova istanza del tipo specificato definito nel file di assembly specificato.
CreateInstanceFromAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Crea una nuova istanza del tipo specificato definito nel file di assembly specificato, specificando se il caso del nome del tipo viene ignorato; gli attributi di associazione e il binder utilizzati per selezionare il tipo da creare; gli argomenti del costruttore; la cultura; e gli attributi di attivazione.
CreateInstanceFromAndUnwrap(String, String, Object[])	Crea una nuova istanza del tipo specificato definito nel file di assembly specificato.
CreateInstanceFromAndUnwrap(String, String)	Crea una nuova istanza del tipo specificato definito nel file di assembly specificato.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
ExecuteAssembly(String, String[], Byte[], AssemblyHashAlgorithm)	Obsoleti. Esegue l'assembly contenuto nel file specificato, usando gli argomenti, il valore hash e l'algoritmo hash specificati.
ExecuteAssembly(String, String[])	Esegue l'assembly contenuto nel file specificato utilizzando gli argomenti specificati.
ExecuteAssembly(String)	Esegue l'assembly contenuto nel file specificato.
ExecuteAssemblyByName(AssemblyName, String[])	Esegue l'assembly dato un AssemblyNameoggetto utilizzando gli argomenti specificati.
ExecuteAssemblyByName(String, String[])	Esegue l'assembly in base al nome visualizzato, utilizzando gli argomenti specificati.
ExecuteAssemblyByName(String)	Esegue un assembly in base al nome visualizzato.
GetAssemblies()	Ottiene gli assembly caricati nel contesto di esecuzione di questo dominio applicazione.
GetCurrentThreadId()	Obsoleti. Ottiene l'identificatore del thread corrente.
GetData(String)	Ottiene il valore archiviato nel dominio applicazione corrente per il nome specificato.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Recupera l'oggetto servizio di durata corrente che controlla i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
GetType()	Ottiene il Type dell'istanza corrente. (Ereditato da Object)
InitializeLifetimeService()	Obsoleti. Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
IsCompatibilitySwitchSet(String)	Ottiene un valore booleano nullable che indica se sono impostate opzioni di compatibilità e, in tal caso, se è impostata l'opzione di compatibilità specificata.
IsDefaultAppDomain()	Restituisce un valore che indica se il dominio applicazione è il dominio applicazione predefinito per il processo.
IsFinalizingForUnload()	Indica se il dominio applicazione viene scaricato e gli oggetti che contiene vengono finalizzati da Common Language Runtime.
Load(AssemblyName)	Carica un Assembly oggetto in base al relativo AssemblyNameoggetto .
Load(Byte[], Byte[])	Assembly Carica con un'immagine basata su COFF (Common Object File Format) contenente un oggetto generatoAssembly. Vengono caricati anche i byte non elaborati che rappresentano i simboli per .Assembly
Load(Byte[])	Assembly Carica con un'immagine basata su COFF (Common Object File Format) contenente un oggetto generatoAssembly.
Load(String)	Carica un Assembly dato nome visualizzato.
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia superficiale dell'oggetto corrente MarshalByRefObject . (Ereditato da MarshalByRefObject)
ReflectionOnlyGetAssemblies()	Restituisce gli assembly caricati nel contesto di sola reflection del dominio applicazione.
SetCachePath(String)	Obsoleti. Stabilisce il percorso di directory specificato come percorso in cui vengono copiati gli assembly shadow.
SetData(String, Object)	Assegna il valore specificato alla proprietà del dominio applicazione specificata.
SetDynamicBase(String)	Obsoleti. Stabilisce il percorso di directory specificato come directory di base per le sottodirectory in cui vengono archiviati e accessibili file generati dinamicamente.
SetPrincipalPolicy(PrincipalPolicy)	Specifica il modo in cui gli oggetti entità e identità devono essere collegati a un thread se il thread tenta di eseguire l'associazione a un'entità durante l'esecuzione in questo dominio applicazione.
SetShadowCopyFiles()	Obsoleti. Attiva la copia shadow.
SetShadowCopyPath(String)	Obsoleti. Stabilisce il percorso di directory specificato come percorso degli assembly da copiare in shadow.
SetThreadPrincipal(IPrincipal)	Imposta l'oggetto principal predefinito da collegare ai thread se tenta di eseguire l'associazione a un'entità durante l'esecuzione in questo dominio applicazione.
ToString()	Ottiene una rappresentazione di stringa che include il nome descrittivo del dominio applicazione e i criteri di contesto.
Unload(AppDomain)	Obsoleti. Scarica il dominio applicazione specificato.

Eventi

Nome	Descrizione
AssemblyLoad	Si verifica quando viene caricato un assembly.
AssemblyResolve	Si verifica quando la risoluzione di un assembly ha esito negativo.
DomainUnload	Si verifica quando un oggetto AppDomain sta per essere scaricato.
FirstChanceException	Si verifica quando viene generata un'eccezione nel codice gestito, prima che il runtime cerchi nello stack di chiamate un gestore eccezioni nel dominio dell'applicazione.
ProcessExit	Si verifica quando il processo padre del dominio applicazione predefinito viene chiuso.
ReflectionOnlyAssemblyResolve	Si verifica quando la risoluzione di un assembly ha esito negativo nel contesto di sola reflection.
ResourceResolve	Si verifica quando la risoluzione di una risorsa ha esito negativo perché la risorsa non è una risorsa collegata o incorporata valida nell'assembly.
TypeResolve	Si verifica quando la risoluzione di un tipo ha esito negativo.
UnhandledException	Si verifica quando un'eccezione non viene intercettata.

Vedi anche

• Procedura: Configurare un dominio applicazione
• Procedura: Creare un dominio applicazione
• Procedura: Caricare assembly in un dominio applicazione
• Procedura: Scaricare un dominio applicazione