AppDomain Classe

Définition

Espace de noms:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

AppDomain.cs

Représente un domaine d’application, qui est un environnement isolé où les applications s’exécutent. Cette classe ne peut pas être héritée.

public ref class AppDomain sealed : MarshalByRefObject

public sealed class AppDomain : MarshalByRefObject

type AppDomain = class
    inherit MarshalByRefObject

Public NotInheritable Class AppDomain
Inherits MarshalByRefObject

Héritage

Object

MarshalByRefObject

AppDomain

Exemples

Cet exemple montre comment créer un AppDomainnouveau type, instancier un type dans ce nouveau AppDomainet communiquer avec l’objet de ce type. En outre, cet exemple montre comment décharger l’objet AppDomain à l’origine du 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.

Remarques

Les domaines d’application, représentés par AppDomain des objets, aident à fournir une isolation, un déchargement et des limites de sécurité pour l’exécution du code managé.

• Utilisez des domaines d’application pour isoler les tâches susceptibles de réduire un processus. Si l’état de l’exécution AppDomain d’une tâche devient instable, il AppDomain peut être déchargé sans affecter le processus. Cela est important lorsqu’un processus doit s’exécuter pendant de longues périodes sans redémarrer. Vous pouvez également utiliser des domaines d’application pour isoler les tâches qui ne doivent pas partager de données.
• Si un assembly est chargé dans le domaine d’application par défaut, il ne peut pas être déchargé de la mémoire pendant l’exécution du processus. Toutefois, si vous ouvrez un deuxième domaine d’application pour charger et exécuter l’assembly, l’assembly est déchargé lorsque ce domaine d’application est déchargé. Utilisez cette technique pour réduire le jeu de travail des processus de longue durée qui utilisent occasionnellement de grandes DLL.

Note

Sur .NET Core et .NET 5+, l’implémentation AppDomain est limitée par conception et ne fournit pas d’isolation, de déchargement ou de limites de sécurité. Ces versions ont exactement un AppDomain. L’isolation et le déchargement sont fournis via AssemblyLoadContext. Les limites de sécurité doivent être fournies par les limites de processus et les techniques de communication à distance appropriées.

Plusieurs domaines d’application peuvent s’exécuter dans un seul processus ; Toutefois, il n’existe pas de corrélation un-à-un entre les domaines d’application et les threads. Plusieurs threads peuvent appartenir à un domaine d’application unique, et alors qu’un thread donné n’est pas limité à un domaine d’application unique, à tout moment donné, un thread s’exécute dans un seul domaine d’application.

Les domaines d’application sont créés à l’aide de la CreateDomain méthode. AppDomain les instances sont utilisées pour charger et exécuter des assemblys (Assembly). Lorsqu’un AppDomain élément n’est plus utilisé, il peut être déchargé.

La AppDomain classe implémente un ensemble d’événements qui permettent aux applications de répondre lorsqu’un assembly est chargé, lorsqu’un domaine d’application est déchargé ou lorsqu’une exception non gérée est levée.

Pour plus d’informations sur l’utilisation de domaines d’application, consultez Domaines d’application.

Cette classe implémente les interfaces , _AppDomainet IEvidenceFactory les MarshalByRefObjectinterfaces.

Vous ne devez jamais créer de wrapper remotable pour un AppDomain objet. Cela pourrait publier une référence distante à ce point AppDomain, exposant des méthodes telles que CreateInstance l’accès à distance et la destruction efficace de la sécurité d’accès au code pour cela AppDomain. Les clients malveillants AppDomain qui se connectent à distance peuvent obtenir l’accès à n’importe quelle ressource à qui il AppDomain a accès. Ne créez pas de wrappers remotables MarshalByRefObject pour n’importe quel type qui s’étend et implémente des méthodes qui peuvent être utilisées par des clients malveillants pour contourner le système de sécurité.

Avertissement

La valeur par défaut de la propriété AppDomainSetup.DisallowCodeDownload est false. Ce paramètre est dangereux pour les services. Pour empêcher les services de télécharger du code partiellement approuvé, définissez cette propriété sur true.

Propriétés

Nom	Description
BaseDirectory	Obtient le répertoire de base utilisé par le programme de résolution d’assembly pour rechercher des assemblys.
CurrentDomain	Obtient le domaine d’application actuel pour le domaine d’application actuel Thread.
DynamicDirectory	Obtient le répertoire utilisé par le programme de résolution d’assembly pour rechercher des assemblys créés dynamiquement.
FriendlyName	Obtient le nom convivial de ce domaine d’application.
Id	Obtient un entier qui identifie de manière unique le domaine d’application au sein du processus.
IsFullyTrusted	Obtient une valeur qui indique si les assemblys chargés dans le domaine d’application actuel s’exécutent avec une confiance totale.
IsHomogenous	Obtient une valeur qui indique si le domaine d’application actuel a un ensemble d’autorisations accordées à tous les assemblys chargés dans le domaine d’application.
MonitoringIsEnabled	Obtient ou définit une valeur qui indique si la surveillance du processeur et de la mémoire des domaines d’application est activée pour le processus actuel. Une fois la surveillance activée pour un processus, elle ne peut pas être désactivée.
MonitoringSurvivedMemorySize	Obtient le nombre d’octets qui ont survécu à la dernière collection et qui sont connus pour être référencés par le domaine d’application actuel.
MonitoringSurvivedProcessMemorySize	Obtient le total des octets qui ont survécu à partir de la dernière collection pour tous les domaines d’application du processus.
MonitoringTotalAllocatedMemorySize	Obtient la taille totale, en octets, de toutes les allocations de mémoire effectuées par le domaine d’application depuis sa création, sans soustraire la mémoire collectée.
MonitoringTotalProcessorTime	Obtient le temps processeur total utilisé par tous les threads lors de l’exécution dans le domaine d’application actuel, depuis le démarrage du processus.
PermissionSet	Obsolète. Obtient le jeu d’autorisations d’un domaine d’application en bac à sable (sandbox).
RelativeSearchPath	Obtient le chemin d’accès sous le répertoire de base dans lequel le programme de résolution d’assembly doit effectuer une sonde pour les assemblys privés.
SetupInformation	Obtient les informations de configuration du domaine d’application pour cette instance.
ShadowCopyFiles	Obtient une indication indiquant si le domaine d’application est configuré pour les fichiers de cliché instantané.

Méthodes

Nom	Description
AppendPrivatePath(String)	Obsolète. Ajoute le nom de répertoire spécifié à la liste de chemins d’accès privé.
ApplyPolicy(String)	Retourne le nom complet de l’assembly après l’application de la stratégie.
ClearPrivatePath()	Obsolète. Réinitialise le chemin d’accès qui spécifie l’emplacement des assemblys privés sur la chaîne vide ( » « ).
ClearShadowCopyPath()	Obsolète. Réinitialise la liste des répertoires contenant des assemblys clichés instantanés sur la chaîne vide («  »).
CreateDomain(String)	Obsolète. Crée un domaine d’application avec le nom spécifié.
CreateInstance(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Crée une instance du type spécifié défini dans l’assembly spécifié. Les paramètres spécifient un classeur, des indicateurs de liaison, des arguments de constructeur, des informations spécifiques à la culture utilisées pour interpréter des arguments et des attributs d’activation facultatifs.
CreateInstance(String, String, Object[])	Crée une instance du type spécifié défini dans l’assembly spécifié. Un paramètre spécifie un tableau d’attributs d’activation.
CreateInstance(String, String)	Crée une instance du type spécifié défini dans l’assembly spécifié.
CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Crée une instance du type spécifié défini dans l’assembly spécifié, en spécifiant si le cas du nom de type est ignoré ; les attributs de liaison et le classeur utilisés pour sélectionner le type à créer ; arguments du constructeur ; la culture ; et les attributs d’activation.
CreateInstanceAndUnwrap(String, String, Object[])	Crée une instance du type spécifié. Les paramètres spécifient l’assembly où le type est défini, le nom du type et un tableau d’attributs d’activation.
CreateInstanceAndUnwrap(String, String)	Crée une instance du type spécifié. Les paramètres spécifient l’assembly où le type est défini et le nom du type.
CreateInstanceFrom(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Crée une instance du type spécifié défini dans le fichier d’assembly spécifié.
CreateInstanceFrom(String, String, Object[])	Crée une instance du type spécifié défini dans le fichier d’assembly spécifié.
CreateInstanceFrom(String, String)	Crée une instance du type spécifié défini dans le fichier d’assembly spécifié.
CreateInstanceFromAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Crée une instance du type spécifié défini dans le fichier d’assembly spécifié, en spécifiant si le cas du nom de type est ignoré ; les attributs de liaison et le classeur utilisés pour sélectionner le type à créer ; arguments du constructeur ; la culture ; et les attributs d’activation.
CreateInstanceFromAndUnwrap(String, String, Object[])	Crée une instance du type spécifié défini dans le fichier d’assembly spécifié.
CreateInstanceFromAndUnwrap(String, String)	Crée une instance du type spécifié défini dans le fichier d’assembly spécifié.
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
ExecuteAssembly(String, String[], Byte[], AssemblyHashAlgorithm)	Obsolète. Exécute l’assembly contenu dans le fichier spécifié, à l’aide des arguments, de la valeur de hachage et de l’algorithme de hachage spécifiés.
ExecuteAssembly(String, String[])	Exécute l’assembly contenu dans le fichier spécifié, à l’aide des arguments spécifiés.
ExecuteAssembly(String)	Exécute l’assembly contenu dans le fichier spécifié.
ExecuteAssemblyByName(AssemblyName, String[])	Exécute l’assembly donné, AssemblyNameà l’aide des arguments spécifiés.
ExecuteAssemblyByName(String, String[])	Exécute l’assembly en fonction de son nom complet, à l’aide des arguments spécifiés.
ExecuteAssemblyByName(String)	Exécute un assembly en fonction de son nom complet.
GetAssemblies()	Obtient les assemblys qui ont été chargés dans le contexte d’exécution de ce domaine d’application.
GetCurrentThreadId()	Obsolète. Obtient l’identificateur de thread actuel.
GetData(String)	Obtient la valeur stockée dans le domaine d’application actuel pour le nom spécifié.
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetLifetimeService()	Obsolète. Récupère l’objet de service de durée de vie actuel qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
InitializeLifetimeService()	Obsolète. Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
IsCompatibilitySwitchSet(String)	Obtient une valeur booléenne nullable qui indique si des commutateurs de compatibilité sont définis et, le cas échéant, si le commutateur de compatibilité spécifié est défini.
IsDefaultAppDomain()	Retourne une valeur qui indique si le domaine d’application est le domaine d’application par défaut pour le processus.
IsFinalizingForUnload()	Indique si ce domaine d’application est déchargé et que les objets qu’il contient sont finalisés par le Common Language Runtime.
Load(AssemblyName)	Charge une Assembly donnée .AssemblyName
Load(Byte[], Byte[])	Charge l’image Assembly basée sur un format de fichier objet commun (COFF) contenant une valeur émise Assembly. Les octets bruts représentant les symboles du fichier Assembly sont également chargés.
Load(Byte[])	Charge l’image Assembly basée sur un format de fichier objet commun (COFF) contenant une valeur émise Assembly.
Load(String)	Charge un Assembly nom complet donné.
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l’objet actuel MarshalByRefObject . (Hérité de MarshalByRefObject)
ReflectionOnlyGetAssemblies()	Retourne les assemblys qui ont été chargés dans le contexte de réflexion uniquement du domaine d’application.
SetCachePath(String)	Obsolète. Établit le chemin d’accès du répertoire spécifié comme emplacement où les assemblys sont copiés instantanément.
SetData(String, Object)	Affecte la valeur spécifiée à la propriété de domaine d’application spécifiée.
SetDynamicBase(String)	Obsolète. Établit le chemin d’accès au répertoire spécifié comme répertoire de base pour les sous-répertoires où les fichiers générés dynamiquement sont stockés et accessibles.
SetPrincipalPolicy(PrincipalPolicy)	Spécifie comment les objets principal et d’identité doivent être attachés à un thread si le thread tente de se lier à un principal lors de l’exécution dans ce domaine d’application.
SetShadowCopyFiles()	Obsolète. Active la cliché instantané.
SetShadowCopyPath(String)	Obsolète. Établit le chemin d’accès au répertoire spécifié comme emplacement des assemblys à copier instantanément.
SetThreadPrincipal(IPrincipal)	Définit l’objet principal par défaut à attacher aux threads s’ils tentent de lier à un principal lors de l’exécution dans ce domaine d’application.
ToString()	Obtient une représentation sous forme de chaîne qui inclut le nom convivial du domaine d’application et toutes les stratégies de contexte.
Unload(AppDomain)	Obsolète. Décharge le domaine d’application spécifié.

Événements

Nom	Description
AssemblyLoad	Se produit lorsqu’un assembly est chargé.
AssemblyResolve	Se produit lorsque la résolution d’un assembly échoue.
DomainUnload	Se produit lorsqu’un AppDomain est sur le point d’être déchargé.
FirstChanceException	Se produit lorsqu’une exception est levée dans le code managé, avant que le runtime ne recherche dans la pile des appels un gestionnaire d’exceptions dans le domaine d’application.
ProcessExit	Se produit lorsque le processus parent du domaine d’application par défaut s’arrête.
ReflectionOnlyAssemblyResolve	Se produit lorsque la résolution d’un assembly échoue dans le contexte de réflexion uniquement.
ResourceResolve	Se produit lorsque la résolution d’une ressource échoue, car la ressource n’est pas une ressource liée ou incorporée valide dans l’assembly.
TypeResolve	Se produit lorsque la résolution d’un type échoue.
UnhandledException	Se produit lorsqu’une exception n’est pas interceptée.

Voir aussi

• Guide pratique pour configurer un domaine d’application
• Guide pratique pour créer un domaine d’application
• Guide pratique pour charger des assemblys dans un domaine d’application
• Guide pratique pour décharger un domaine d’application