AppDomain Classe

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: System.Runtime.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Représente un domaine d'application qui est un environnement isolé dans lequel s'exécutent les applications. Cette classe ne peut pas être héritée.

public ref class AppDomain sealed : MarshalByRefObject

public ref class AppDomain : MarshalByRefObject

public ref class AppDomain sealed : MarshalByRefObject, _AppDomain, System::Security::IEvidenceFactory

public sealed class AppDomain : MarshalByRefObject

public class AppDomain : MarshalByRefObject

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class AppDomain : MarshalByRefObject, _AppDomain, System.Security.IEvidenceFactory

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AppDomain : MarshalByRefObject, _AppDomain, System.Security.IEvidenceFactory

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AppDomain : MarshalByRefObject

type AppDomain = class
    inherit MarshalByRefObject

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type AppDomain = class
    inherit MarshalByRefObject
    interface _AppDomain
    interface IEvidenceFactory

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type AppDomain = class
    inherit MarshalByRefObject
    interface _AppDomain
    interface IEvidenceFactory

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type AppDomain = class
    inherit MarshalByRefObject

Public NotInheritable Class AppDomain
Inherits MarshalByRefObject

Public Class AppDomain
Inherits MarshalByRefObject

Public NotInheritable Class AppDomain
Inherits MarshalByRefObject
Implements _AppDomain, IEvidenceFactory

Héritage: Object

MarshalByRefObject
AppDomain

Attributs: ClassInterfaceAttribute ComVisibleAttribute

Implémente: _AppDomain IEvidenceFactory

Exemples

Cet exemple montre comment créer un type , instancier un AppDomaintype 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 d’entraîner 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 des DLL volumineuses.

Notes

Sur .NET Core, l’implémentation AppDomain est limitée par conception et ne fournit pas d’isolation, de déchargement ou de limites de sécurité. Pour .NET Core, il y en a exactement un AppDomain. L’isolation et le déchargement sont fournis par le biais AssemblyLoadContextde . 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 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 et IEvidenceFactory les MarshalByRefObjectinterfaces_AppDomain.

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

Attention

La valeur par défaut de la AppDomainSetup.DisallowCodeDownload propriété est false. Ce paramètre n’est pas sécurisé 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

ActivationContext	Obtient le contexte d'activation du domaine d'application actuel.
ApplicationIdentity	Obtient l'identité de l'application dans le domaine d'application.
ApplicationTrust	Obtient des informations qui décrivent les autorisations accordées à une application et indiquent si l'application possède un niveau de confiance qui lui permet de s'exécuter.
BaseDirectory	Obtient le répertoire de base qu'utilise le programme de résolution d'assembly pour détecter les assemblys.
CurrentDomain	Obtient le domaine d'application actuel pour le Thread actuel.
DomainManager	Obtient le gestionnaire de domaine qui a été fourni par l'hôte quand le domaine d'application a été initialisé.
DynamicDirectory	Obtient le répertoire utilisé par le programme de résolution d'assembly pour détecter les assemblys créés de manière dynamique.
Evidence	Obtient le Evidence associé à ce domaine d'application.
FriendlyName	Obtient le nom convivial de ce domaine d'application.
Id	Obtient un entier qui identifie de façon 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 la confiance totale.
IsHomogenous	Obtient une valeur qui indique si le domaine d'application actuel dispose d'un jeu d'autorisations accordé à tous les assemblys chargés dans le domaine d'application.
MonitoringIsEnabled	Obtient ou définit une valeur qui indique si l'analyse de la mémoire et du processeur des domaines d'application est activée pour le processus actuel. Quand l'analyse a été activée pour un processus, elle ne peut plus être désactivée.
MonitoringSurvivedMemorySize	Obtient le nombre d’octets qui ont survécu à la dernière collection et qui sont référencés par le domaine d’application actuel.
MonitoringSurvivedProcessMemorySize	Obtient le nombre total d'octets qui ont survécu à la dernière collection pour tous les domaines d'application dans le 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 pendant leur 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 mode bac à sable (sandbox).
RelativeSearchPath	Obtient le chemin d'accès sous le répertoire de base où le programme de résolution d'assembly doit détecter les assemblys privés.
SetupInformation	Obtient les informations de configuration du domaine d'application pour cette instance.
ShadowCopyFiles	Obtient une indication précisant si le domaine d'application est configuré pour effectuer un cliché instantané des fichiers.

Méthodes

AppendPrivatePath(String)	Obsolète. Obsolète. Obsolète. Obsolète. Ajoute le nom de répertoire spécifié à la liste des chemins d’accès privée.
ApplyPolicy(String)	Retourne le nom complet d'assembly une fois que la stratégie a été appliquée.
ClearPrivatePath()	Obsolète. Obsolète. Obsolète. Obsolète. Rétablit la chaîne vide ("") comme valeur du chemin d’accès qui spécifie l’emplacement des assemblys privés.
ClearShadowCopyPath()	Obsolète. Obsolète. Obsolète. Obsolète. Rétablit la chaîne vide ("") comme valeur de la liste des répertoires contenant des clichés instantanés d'assemblys.
CreateComInstanceFrom(String, String)	Crée une instance d'un type COM spécifié. Les paramètres spécifient le nom d'un fichier qui contient un assembly contenant le type et le nom du type.
CreateComInstanceFrom(String, String, Byte[], AssemblyHashAlgorithm)	Crée une instance d'un type COM spécifié. Les paramètres spécifient le nom d'un fichier qui contient un assembly contenant le type et le nom du type.
CreateDomain(String)	Obsolète. Crée un domaine d'application portant le nom spécifié.
CreateDomain(String, Evidence)	Crée un domaine d'application portant le nom spécifié à l'aide de la preuve fournie.
CreateDomain(String, Evidence, AppDomainSetup)	Crée un domaine d'application à l'aide du nom, de la preuve et des informations de configuration du domaine d'application spécifiés.
CreateDomain(String, Evidence, AppDomainSetup, PermissionSet, StrongName[])	Crée un domaine d'application à l'aide du nom, de la preuve, des informations de configuration du domaine d'application, du jeu d'autorisations par défaut et du tableau d'assemblys ayant un niveau de confiance suffisant.
CreateDomain(String, Evidence, String, String, Boolean)	Crée un domaine d'application portant le nom donné, à l'aide de la preuve, du chemin d'accès de base de l'application, du chemin de recherche relatif et d'un paramètre spécifiant si un cliché instantané d'un assembly doit être chargé dans le domaine d'application.
CreateDomain(String, Evidence, String, String, Boolean, AppDomainInitializer, String[])	Crée un domaine d'application portant le nom donné, à l'aide de la preuve, du chemin d'accès de base de l'application, du chemin de recherche relatif et d'un paramètre spécifiant si un cliché instantané d'un assembly doit être chargé dans le domaine d'application. Spécifie une méthode de rappel qui est appelée quand le domaine d'application est initialisé, et un tableau d'arguments de type chaîne à passer à la méthode de rappel.
CreateInstance(String, String)	Crée une instance du type spécifié défini dans l'assembly déterminé.
CreateInstance(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Crée une instance du type spécifié défini dans l'assembly déterminé. Les paramètres spécifient un binder, des indicateurs de liaisons, des arguments de constructeur, les informations spécifiques à la culture utilisées pour interpréter les arguments et des attributs d'activation facultatifs.
CreateInstance(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence)	Obsolète. Obsolète. Crée une instance du type spécifié défini dans l'assembly déterminé. Les paramètres spécifient un binder, des indicateurs de liaisons, des arguments de constructeur, des informations propres à la culture utilisées pour interpréter les arguments, des attributs d’activation et l’autorisation de créer le type.
CreateInstance(String, String, Object[])	Crée une instance du type spécifié défini dans l'assembly déterminé. Un paramètre spécifie un tableau d'attributs d'activation.
CreateInstanceAndUnwrap(String, String)	Crée une instance du type spécifié. Les paramètres spécifient l'assembly dans lequel le type est défini et le nom du type.
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 indiquant si la casse du nom de type est ignorée ; les attributs de liaison et le binder utilisés pour sélectionner le type à créer ; les arguments du constructeur ; la culture et les attributs d’activation.
CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence)	Obsolète. Obsolète. Crée une instance du type spécifié. Les paramètres spécifient le nom du type et la manière dont il est recherché et créé.
CreateInstanceAndUnwrap(String, String, Object[])	Crée une instance du type spécifié. Les paramètres spécifient l'assembly dans lequel le type est défini, le nom du type et un tableau d'attributs d'activation.
CreateInstanceFrom(String, String)	Crée une instance du type spécifié défini dans le fichier d'assembly déterminé.
CreateInstanceFrom(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Crée une instance du type spécifié défini dans le fichier d'assembly déterminé.
CreateInstanceFrom(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence)	Obsolète. Obsolète. Crée une instance du type spécifié défini dans le fichier d'assembly déterminé.
CreateInstanceFrom(String, String, Object[])	Crée une instance du type spécifié défini dans le fichier d'assembly déterminé.
CreateInstanceFromAndUnwrap(String, String)	Crée une instance du type spécifié défini dans le fichier d'assembly déterminé.
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 indiquant si la casse du nom de type est ignorée ; les attributs de liaison et le binder utilisés pour sélectionner le type à créer ; les arguments du constructeur ; la culture et les attributs d’activation.
CreateInstanceFromAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence)	Obsolète. Obsolète. Crée une instance du type spécifié défini dans le fichier d'assembly déterminé.
CreateInstanceFromAndUnwrap(String, String, Object[])	Crée une instance du type spécifié défini dans le fichier d'assembly déterminé.
CreateObjRef(Type)	Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant. (Hérité de MarshalByRefObject)
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess)	Définit un assembly dynamique avec le nom et le mode d'accès spécifiés.
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence)	Obsolète. Obsolète. Définit un assembly dynamique avec le nom, le mode d'accès et la preuve spécifiés.
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence, PermissionSet, PermissionSet, PermissionSet)	Obsolète. Obsolète. Définit un assembly dynamique avec le nom, le mode d'accès, la preuve et les demandes d'autorisations spécifiés.
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>)	Définit un assembly dynamique avec le nom, le mode d'accès et les attributs personnalisés spécifiés.
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>, SecurityContextSource)	Définit un assembly dynamique avec le nom, le mode d'accès et les attributs personnalisés spécifiés, à l'aide de la source indiquée pour son contexte de sécurité.
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, PermissionSet, PermissionSet, PermissionSet)	Obsolète. Obsolète. Définit un assembly dynamique avec le nom, le mode d'accès et les demandes d'autorisations spécifiés.
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String)	Définit un assembly dynamique avec le nom, le mode d'accès et le répertoire de stockage spécifiés.
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Boolean, IEnumerable<CustomAttributeBuilder>)	Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage et l'option de synchronisation spécifiés.
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence)	Obsolète. Obsolète. Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage et la preuve spécifiés.
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet)	Obsolète. Obsolète. Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage, la preuve et les demandes d'autorisations spécifiés.
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean)	Obsolète. Obsolète. Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage, la preuve, les demandes d'autorisations et l'option de synchronisation spécifiés.
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean, IEnumerable<CustomAttributeBuilder>)	Obsolète. Obsolète. Définit un assembly dynamique avec le nom, le mode d’accès, le répertoire de stockage, la preuve, les demandes d’autorisations, l’option de synchronisation et les attributs personnalisés spécifiés.
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, PermissionSet, PermissionSet, PermissionSet)	Obsolète. Obsolète. Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage et les demandes d'autorisations spécifiés.
DoCallBack(CrossAppDomainDelegate)	Exécute le code dans un autre domaine d'application identifié par le délégué spécifié.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
ExecuteAssembly(String)	Exécute l'assembly contenu dans le fichier spécifié.
ExecuteAssembly(String, Evidence)	Obsolète. Obsolète. Exécute l'assembly contenu dans le fichier spécifié à l'aide de la preuve spécifiée.
ExecuteAssembly(String, Evidence, String[])	Obsolète. Obsolète. Exécute l’assembly contenu dans le fichier spécifié à l’aide de la preuve et des arguments spécifiés.
ExecuteAssembly(String, Evidence, String[], Byte[], AssemblyHashAlgorithm)	Obsolète. Obsolète. Exécute l’assembly contenu dans le fichier spécifié à l’aide de la preuve, des arguments, de la valeur 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, String[], Byte[], AssemblyHashAlgorithm)	Obsolète. Exécute l’assembly contenu dans le fichier spécifié à l’aide des arguments, de la valeur et de l’algorithme de hachage spécifiés.
ExecuteAssemblyByName(AssemblyName, Evidence, String[])	Obsolète. Obsolète. Exécute l'assembly à partir d'un AssemblyName, à l'aide de la preuve et des arguments spécifiés.
ExecuteAssemblyByName(AssemblyName, String[])	Exécute l’assembly à partir d’un AssemblyName, à l’aide des arguments spécifiés.
ExecuteAssemblyByName(String)	Charge un assembly en fonction de son nom complet.
ExecuteAssemblyByName(String, Evidence)	Obsolète. Obsolète. Exécute un assembly en fonction de son nom complet, à l'aide de la preuve spécifiée.
ExecuteAssemblyByName(String, Evidence, String[])	Obsolète. Obsolète. Exécute l’assembly en fonction de son nom complet, à l’aide de la preuve et 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.
GetAssemblies()	Obtient les assemblys qui ont été chargés dans le contexte d'exécution de ce domaine d'application.
GetCurrentThreadId()	Obsolète. Obsolète. Obsolète. Obsolète. Obsolète. Obtient l'identificateur du thread actuel.
GetData(String)	Obtient la valeur stockée dans le domaine d'application actuel pour le nom spécifié.
GetHashCode()	Fait office 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 en cours qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetType()	Obtient le type de l'instance actuelle.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
InitializeLifetimeService()	Donne à AppDomain une durée de vie infinie en empêchant toute création de bail.
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 les commutateurs de compatibilité sont définis, et si tel est le cas, 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 du processus.
IsFinalizingForUnload()	Indique si le déchargement de ce domaine d'application est en cours et si les objets qu'il contient sont en cours de finalisation par le Common Language Runtime.
Load(AssemblyName)	Charge Assembly en fonction de son AssemblyName.
Load(AssemblyName, Evidence)	Obsolète. Obsolète. Charge Assembly en fonction de son AssemblyName.
Load(Byte[])	Charge Assembly avec l'image au format COFF (Common Object File Format) contenant un Assembly émis.
Load(Byte[], Byte[])	Charge Assembly avec l'image au format COFF (Common Object File Format) contenant un Assembly émis. Les octets bruts représentant les symboles de Assembly sont également chargés.
Load(Byte[], Byte[], Evidence)	Obsolète. Obsolète. Charge Assembly avec l'image au format COFF (Common Object File Format) contenant un Assembly émis. Les octets bruts représentant les symboles de Assembly sont également chargés.
Load(String)	Charge Assembly en fonction de son nom complet.
Load(String, Evidence)	Obsolète. Obsolète. Charge Assembly en fonction de son nom complet.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l'objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject)
ReflectionOnlyGetAssemblies()	Retourne les assemblys qui ont été chargés dans le contexte de réflexion uniquement du domaine d'application.
SetAppDomainPolicy(PolicyLevel)	Obsolète. Obsolète. Définit le niveau de stratégie de sécurité pour ce domaine d'application.
SetCachePath(String)	Obsolète. Obsolète. Obsolète. Obsolète. Définit le chemin d'accès du répertoire spécifié comme emplacement pour les clichés instantanés des assemblys.
SetData(String, Object)	Assigne la valeur spécifiée à la propriété du domaine d'application spécifié.
SetData(String, Object, IPermission)	Assigne la valeur spécifiée à la propriété du domaine d'application spécifiée, avec une autorisation spécifiée à exiger de l'appelant quand la propriété est récupérée.
SetDynamicBase(String)	Obsolète. Obsolète. Obsolète. Obsolète. Définit le chemin de répertoire spécifié comme répertoire de base des sous-répertoires dans lesquels sont stockés les fichiers générés de manière dynamique et à partir desquels ils sont accessibles.
SetPrincipalPolicy(PrincipalPolicy)	Spécifie la façon dont les objets Principal et Identity doivent être attachés à un thread si celui-ci tente d'établir une liaison vers un principal au moment de l'exécution dans ce domaine d'application.
SetShadowCopyFiles()	Obsolète. Obsolète. Obsolète. Obsolète. Active les clichés instantanés.
SetShadowCopyPath(String)	Obsolète. Obsolète. Obsolète. Obsolète. Définit le chemin d’accès du répertoire spécifié comme emplacement pour les clichés instantanés des assemblys.
SetThreadPrincipal(IPrincipal)	Définit l'objet Principal par défaut à attacher aux threads si ceux-ci tentent d'établir une liaison vers un principal au moment 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 les stratégies de contexte.
Unload(AppDomain)	Obsolète. Décharge le domaine d'application spécifié.

Événements

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

Implémentations d’interfaces explicites

_AppDomain.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.
_AppDomain.GetTypeInfo(UInt32, UInt32, IntPtr)	Récupère les informations de type pour un objet, qui peuvent être utilisées ensuite pour obtenir les informations de type d'une interface.
_AppDomain.GetTypeInfoCount(UInt32)	Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).
_AppDomain.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Fournit l'accès aux propriétés et aux méthodes exposées par un objet.

S’applique à