AppDomain Class

Définition

Représente un domaine d'application qui est un environnement isolé dans lequel s'exécutent les applications. Represents an application domain, which is an isolated environment where applications execute. Cette classe ne peut pas être héritée. This class cannot be inherited.

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AppDomain : MarshalByRefObject, _AppDomain, System.Security.IEvidenceFactory
Héritage
Attributs
Implémente

Exemples

Cet exemple montre comment créer un nouveau AppDomain, instancier un type dans ce nouveau AppDomainet communiquer avec l’objet de ce type.This example shows how to create a new AppDomain, instantiate a type in that new AppDomain, and communicate with that type’s object. En outre, cet exemple montre comment décharger le AppDomain à l’origine de l’objet d’être nettoyées.In addition, this example shows how to unload the AppDomain causing the object to be garbage collected.

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

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

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

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

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

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

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

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

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

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

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

/* This code produces output similar to the following: 

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

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

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

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

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

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

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

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

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

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

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

/* This code produces output similar to the following: 

AppDomainX.exe
AppDomainX, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
AppName=, AppBase=C:\AppDomain\bin, ConfigFile=C:\AppDomain\bin\AppDomainX.exe.config
Calling from 'AppDomainX.exe' to 'AD #2'.
Failed call; this is expected.
 */
Imports System
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

Domaines d’application, qui sont représentées par AppDomain objets, aider à fournir des limites d’isolation, de déchargement et de sécurité pour l’exécution de code managé.Application domains, which are represented by AppDomain objects, help provide isolation, unloading, and security boundaries for executing managed code.

  • Utiliser des domaines d’application pour isoler les tâches qui peuvent interrompre un processus.Use application domains to isolate tasks that might bring down a process. Si l’état de la AppDomain qui exécute une tâche devient instable, le AppDomain peut être déchargé sans affecter le processus.If the state of the AppDomain that's executing a task becomes unstable, the AppDomain can be unloaded without affecting the process. Ceci est important lorsqu’un processus doit s’exécuter pendant de longues périodes sans avoir à redémarrer.This is important when a process must run for long periods without restarting. Vous pouvez également utiliser des domaines d’application pour isoler les tâches qui ne doivent pas partager de données.You can also use application domains to isolate tasks that should not share data.

  • Si un assembly est chargé dans le domaine d’application par défaut, il ne peut pas être déchargée de la mémoire pendant que le processus est en cours d’exécution.If an assembly is loaded into the default application domain, it cannot be unloaded from memory while the process is running. 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é.However, if you open a second application domain to load and execute the assembly, the assembly is unloaded when that application domain is unloaded. Cette technique permet de réduire la plage de travail de processus à long terme qui utilisent parfois des DLL volumineuses.Use this technique to minimize the working set of long-running processes that occasionally use large DLLs.

Plusieurs domaines d’application peuvent s’exécuter dans un processus unique. Toutefois, il n'est pas une correspondance entre domaines d’application et les threads.Multiple application domains can run in a single process; however, there is not a one-to-one correlation between application domains and threads. Plusieurs threads peuvent appartenir à un seul domaine d’application, et pendant un thread donné n’est pas limité à un seul domaine d’application, à un moment donné, un thread s’exécute dans un seul domaine d’application.Several threads can belong to a single application domain, and while a given thread is not confined to a single application domain, at any given time, a thread executes in a single application domain.

Domaines d’application sont créés à l’aide de la CreateDomain (méthode).Application domains are created using the CreateDomain method. AppDomain instances sont utilisées pour charger et exécuter des assemblys (Assembly).AppDomain instances are used to load and execute assemblies (Assembly). Quand un AppDomain est n’est plus en cours d’utilisation, il peut être déchargé.When an AppDomain is no longer in use, it can be unloaded.

Le AppDomain classe implémente un ensemble d’événements qui permettent aux applications de répondre lorsqu’un assembly est chargé, un domaine d’application est déchargé ou quand une exception non gérée est levée.The AppDomain class implements a set of events that enable applications to respond when an assembly is loaded, when an application domain will be unloaded, or when an unhandled exception is thrown.

Pour plus d’informations sur l’utilisation des domaines d’application, consultez domaines d’Application.For more information on using application domains, see Application Domains.

Cette classe implémente le MarshalByRefObject, _AppDomain, et IEvidenceFactory interfaces.This class implements the MarshalByRefObject, _AppDomain, and IEvidenceFactory interfaces.

Vous ne devez jamais créer un wrapper accessible à distance pour un AppDomain objet.You should never create a remotable wrapper for an AppDomain object. Cela peut publier une référence à distance à cet AppDomain, exposant des méthodes telles que CreateInstance pour l’accès à distance et en détruisant ainsi la sécurité d’accès du code pour que AppDomain.Doing so could publish a remote reference to that AppDomain, exposing methods such as CreateInstance to remote access and effectively destroying code access security for that AppDomain. Clients malveillants qui se connectent à la distance AppDomain pu obtenir l’accès à n’importe quelle ressource le AppDomain lui-même a accès à.Malicious clients connecting to the remoted AppDomain could obtain access to any resource the AppDomain itself has access to. Ne créez pas de wrappers accessibles à distance pour tout type qui étend MarshalByRefObject et qui implémente des méthodes qui peuvent être utilisées par les clients malveillants pour ignorer le système de sécurité.Do not create remotable wrappers for any type that extends MarshalByRefObject and that implements methods that could be used by malicious clients to bypass the security system.

Attention

La valeur par défaut pour le AppDomainSetup.DisallowCodeDownload propriété est false.The default value for the AppDomainSetup.DisallowCodeDownload property is false. Ce paramètre n’est pas sûre pour les services.This setting is unsafe for services. Pour empêcher les services de téléchargement de code de confiance partielle, définissez cette propriété sur true.To prevent services from downloading partially trusted code, set this property to true.

Propriétés

ActivationContext

Obtient le contexte d'activation du domaine d'application actuel. Gets the activation context for the current application domain.

ApplicationIdentity

Obtient l'identité de l'application dans le domaine d'application. Gets the identity of the application in the application domain.

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. Gets information describing permissions granted to an application and whether the application has a trust level that allows it to run.

BaseDirectory

Obtient le répertoire de base qu'utilise le programme de résolution d'assembly pour détecter les assemblys. Gets the base directory that the assembly resolver uses to probe for assemblies.

CurrentDomain

Obtient le domaine d'application actuel pour le Thread actuel. Gets the current application domain for the current Thread.

DomainManager

Obtient le gestionnaire de domaine qui a été fourni par l'hôte quand le domaine d'application a été initialisé. Gets the domain manager that was provided by the host when the application domain was initialized.

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. Gets the directory that the assembly resolver uses to probe for dynamically created assemblies.

Evidence

Obtient le Evidence associé à ce domaine d'application. Gets the Evidence associated with this application domain.

FriendlyName

Obtient le nom convivial de ce domaine d'application. Gets the friendly name of this application domain.

Id

Obtient un entier qui identifie de façon unique le domaine d'application au sein du processus. Gets an integer that uniquely identifies the application domain within the process.

IsFullyTrusted

Obtient une valeur qui indique si les assemblys chargés dans le domaine d'application actuel s'exécutent avec la confiance totale. Gets a value that indicates whether assemblies that are loaded into the current application domain execute with full trust.

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. Gets a value that indicates whether the current application domain has a set of permissions that is granted to all assemblies that are loaded into the application domain.

MonitoringIsEnabled

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. Gets or sets a value that indicates whether CPU and memory monitoring of application domains is enabled for the current process. Quand l'analyse a été activée pour un processus, elle ne peut plus être désactivée. Once monitoring is enabled for a process, it cannot be disabled.

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. Gets the number of bytes that survived the last collection and that are known to be referenced by the current application domain.

MonitoringSurvivedProcessMemorySize

Obtient le nombre total d’octets qui ont survécu à la dernière collection pour tous les domaines d’application dans le processus. Gets the total bytes that survived from the last collection for all application domains in the process.

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. Gets the total size, in bytes, of all memory allocations that have been made by the application domain since it was created, without subtracting memory that has been collected.

MonitoringTotalProcessorTime

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. Gets the total processor time that has been used by all threads while executing in the current application domain, since the process started.

PermissionSet

Obtient le jeu d'autorisations d'un domaine d'application en mode bac à sable (sandbox). Gets the permission set of a sandboxed application domain.

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. Gets the path under the base directory where the assembly resolver should probe for private assemblies.

SetupInformation

Obtient les informations de configuration du domaine d'application pour cette instance. Gets the application domain configuration information for this instance.

ShadowCopyFiles

Obtient une indication précisant si le domaine d'application est configuré pour effectuer un cliché instantané des fichiers. Gets an indication whether the application domain is configured to shadow copy files.

Méthodes

AppendPrivatePath(String)

Ajoute le nom de répertoire spécifié à la liste des chemins d’accès privée. Appends the specified directory name to the private path list.

ApplyPolicy(String)

Retourne le nom complet d'assembly une fois que la stratégie a été appliquée. Returns the assembly display name after policy has been applied.

ClearPrivatePath()

Rétablit la chaîne vide ("") comme valeur du chemin d’accès qui spécifie l’emplacement des assemblys privés. Resets the path that specifies the location of private assemblies to the empty string ("").

ClearShadowCopyPath()

Rétablit la chaîne vide ("") comme valeur de la liste des répertoires contenant des clichés instantanés d'assemblys. Resets the list of directories containing shadow copied assemblies to the empty string ("").

CreateComInstanceFrom(String, String)

Crée une instance d'un type COM spécifié. Creates a new instance of a specified COM type. Les paramètres spécifient le nom d'un fichier qui contient un assembly contenant le type et le nom du type. Parameters specify the name of a file that contains an assembly containing the type and the name of the type.

CreateComInstanceFrom(String, String, Byte[], AssemblyHashAlgorithm)

Crée une instance d'un type COM spécifié. Creates a new instance of a specified COM type. Les paramètres spécifient le nom d'un fichier qui contient un assembly contenant le type et le nom du type. Parameters specify the name of a file that contains an assembly containing the type and the name of the type.

CreateDomain(String)

Crée un domaine d'application portant le nom spécifié. Creates a new application domain with the specified name.

CreateDomain(String, Evidence)

Crée un domaine d'application portant le nom spécifié à l'aide de la preuve fournie. Creates a new application domain with the given name using the supplied evidence.

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. Creates a new application domain using the specified name, evidence, and application domain setup information.

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. Creates a new application domain using the specified name, evidence, application domain setup information, default permission set, and array of fully trusted assemblies.

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. Creates a new application domain with the given name, using evidence, application base path, relative search path, and a parameter that specifies whether a shadow copy of an assembly is to be loaded into the application domain.

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. Creates a new application domain with the given name, using evidence, application base path, relative search path, and a parameter that specifies whether a shadow copy of an assembly is to be loaded into the application domain. 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. Specifies a callback method that is invoked when the application domain is initialized, and an array of string arguments to pass the callback method.

CreateInstance(String, String)

Crée une instance du type spécifié défini dans l'assembly déterminé. Creates a new instance of the specified type defined in the specified assembly.

CreateInstance(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])

Crée une instance du type spécifié défini dans l'assembly déterminé. Creates a new instance of the specified type defined in the specified assembly. 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. Parameters specify a binder, binding flags, constructor arguments, culture-specific information used to interpret arguments, and optional activation attributes.

CreateInstance(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence)

Crée une instance du type spécifié défini dans l'assembly déterminé. Creates a new instance of the specified type defined in the specified assembly. 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. Parameters specify a binder, binding flags, constructor arguments, culture-specific information used to interpret arguments, activation attributes, and authorization to create the type.

CreateInstance(String, String, Object[])

Crée une instance du type spécifié défini dans l'assembly déterminé. Creates a new instance of the specified type defined in the specified assembly. Un paramètre spécifie un tableau d'attributs d'activation. A parameter specifies an array of activation attributes.

CreateInstanceAndUnwrap(String, String)

Crée une instance du type spécifié. Creates a new instance of the specified type. Les paramètres spécifient l'assembly dans lequel le type est défini et le nom du type. Parameters specify the assembly where the type is defined, and the name of the type.

CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])

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. Creates a new instance of the specified type defined in the specified assembly, specifying whether the case of the type name is ignored; the binding attributes and the binder that are used to select the type to be created; the arguments of the constructor; the culture; and the activation attributes.

CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence)

Crée une instance du type spécifié. Creates a new instance of the specified type. Les paramètres spécifient le nom du type et la manière dont il est recherché et créé. Parameters specify the name of the type, and how it is found and created.

CreateInstanceAndUnwrap(String, String, Object[])

Crée une instance du type spécifié. Creates a new instance of the specified type. 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. Parameters specify the assembly where the type is defined, the name of the type, and an array of activation attributes.

CreateInstanceFrom(String, String)

Crée une instance du type spécifié défini dans le fichier d'assembly déterminé. Creates a new instance of the specified type defined in the specified assembly file.

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é. Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFrom(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence)

Crée une instance du type spécifié défini dans le fichier d'assembly déterminé. Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFrom(String, String, Object[])

Crée une instance du type spécifié défini dans le fichier d'assembly déterminé. Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFromAndUnwrap(String, String)

Crée une instance du type spécifié défini dans le fichier d'assembly déterminé. Creates a new instance of the specified type defined in the specified assembly file.

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. Creates a new instance of the specified type defined in the specified assembly file, specifying whether the case of the type name is ignored; the binding attributes and the binder that are used to select the type to be created; the arguments of the constructor; the culture; and the activation attributes.

CreateInstanceFromAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence)

Crée une instance du type spécifié défini dans le fichier d'assembly déterminé. Creates a new instance of the specified type defined in the specified assembly file.

CreateInstanceFromAndUnwrap(String, String, Object[])

Crée une instance du type spécifié défini dans le fichier d'assembly déterminé. Creates a new instance of the specified type defined in the specified assembly file.

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. Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess)

Définit un assembly dynamique avec le nom et le mode d'accès spécifiés. Defines a dynamic assembly with the specified name and access mode.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence)

Définit un assembly dynamique avec le nom, le mode d'accès et la preuve spécifiés. Defines a dynamic assembly using the specified name, access mode, and evidence.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence, PermissionSet, PermissionSet, PermissionSet)

Définit un assembly dynamique avec le nom, le mode d'accès, la preuve et les demandes d'autorisations spécifiés. Defines a dynamic assembly using the specified name, access mode, evidence, and permission requests.

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. Defines a dynamic assembly with the specified name, access mode, and custom attributes.

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é. Defines a dynamic assembly with the specified name, access mode, and custom attributes, and using the specified source for its security context.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, PermissionSet, PermissionSet, PermissionSet)

Définit un assembly dynamique avec le nom, le mode d'accès et les demandes d'autorisations spécifiés. Defines a dynamic assembly using the specified name, access mode, and permission requests.

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. Defines a dynamic assembly using the specified name, access mode, and storage directory.

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. Defines a dynamic assembly using the specified name, access mode, storage directory, and synchronization option.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence)

Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage et la preuve spécifiés. Defines a dynamic assembly using the specified name, access mode, storage directory, and evidence.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet)

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. Defines a dynamic assembly using the specified name, access mode, storage directory, evidence, and permission requests.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean)

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. Defines a dynamic assembly using the specified name, access mode, storage directory, evidence, permission requests, and synchronization option.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean, IEnumerable<CustomAttributeBuilder>)

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. Defines a dynamic assembly with the specified name, access mode, storage directory, evidence, permission requests, synchronization option, and custom attributes.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, PermissionSet, PermissionSet, PermissionSet)

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. Defines a dynamic assembly using the specified name, access mode, storage directory, and permission requests.

DoCallBack(CrossAppDomainDelegate)

Exécute le code dans un autre domaine d'application identifié par le délégué spécifié. Executes the code in another application domain that is identified by the specified delegate.

Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel. Determines whether the specified object is equal to the current object.

(Inherited from Object)
ExecuteAssembly(String)

Exécute l'assembly contenu dans le fichier spécifié. Executes the assembly contained in the specified file.

ExecuteAssembly(String, Evidence)

Exécute l'assembly contenu dans le fichier spécifié à l'aide de la preuve spécifiée. Executes the assembly contained in the specified file, using the specified evidence.

ExecuteAssembly(String, Evidence, String[])

Exécute l’assembly contenu dans le fichier spécifié à l’aide de la preuve et des arguments spécifiés. Executes the assembly contained in the specified file, using the specified evidence and arguments.

ExecuteAssembly(String, Evidence, String[], Byte[], AssemblyHashAlgorithm)

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. Executes the assembly contained in the specified file, using the specified evidence, arguments, hash value, and hash algorithm.

ExecuteAssembly(String, String[])

Exécute l’assembly contenu dans le fichier spécifié à l’aide des arguments spécifiés. Executes the assembly contained in the specified file, using the specified arguments.

ExecuteAssembly(String, String[], Byte[], AssemblyHashAlgorithm)

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. Executes the assembly contained in the specified file, using the specified arguments, hash value, and hash algorithm.

ExecuteAssemblyByName(AssemblyName, Evidence, String[])

Exécute l'assembly à partir d'un AssemblyName, à l'aide de la preuve et des arguments spécifiés. Executes the assembly given an AssemblyName, using the specified evidence and arguments.

ExecuteAssemblyByName(AssemblyName, String[])

Exécute l'assembly à partir d'un AssemblyName, à l'aide des arguments spécifiés. Executes the assembly given an AssemblyName, using the specified arguments.

ExecuteAssemblyByName(String)

Charge un assembly en fonction de son nom complet. Executes an assembly given its display name.

ExecuteAssemblyByName(String, Evidence)

Exécute un assembly en fonction de son nom complet, à l'aide de la preuve spécifiée. Executes an assembly given its display name, using the specified evidence.

ExecuteAssemblyByName(String, Evidence, String[])

Exécute l’assembly en fonction de son nom complet, à l’aide de la preuve et des arguments spécifiés. Executes the assembly given its display name, using the specified evidence and arguments.

ExecuteAssemblyByName(String, String[])

Exécute l’assembly en fonction de son nom complet, à l’aide des arguments spécifiés. Executes the assembly given its display name, using the specified arguments.

GetAssemblies()

Obtient les assemblys qui ont été chargés dans le contexte d'exécution de ce domaine d'application. Gets the assemblies that have been loaded into the execution context of this application domain.

GetCurrentThreadId()

Obtient l'identificateur du thread actuel. Gets the current thread identifier.

GetData(String)

Obtient la valeur stockée dans le domaine d'application actuel pour le nom spécifié. Gets the value stored in the current application domain for the specified name.

GetHashCode()

Fait office de fonction de hachage par défaut. Serves as the default hash function.

(Inherited from Object)
GetLifetimeService()

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. Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetType()

Obtient le type de l'instance actuelle. Gets the type of the current instance.

InitializeLifetimeService()

Donne à AppDomain une durée de vie infinie en empêchant toute création de bail. Gives the AppDomain an infinite lifetime by preventing a lease from being created.

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. Gets a nullable Boolean value that indicates whether any compatibility switches are set, and if so, whether the specified compatibility switch is set.

IsDefaultAppDomain()

Retourne une valeur qui indique si le domaine d'application est le domaine d'application par défaut du processus. Returns a value that indicates whether the application domain is the default application domain for the process.

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. Indicates whether this application domain is unloading, and the objects it contains are being finalized by the common language runtime.

Load(AssemblyName)

Charge Assembly en fonction de son AssemblyName. Loads an Assembly given its AssemblyName.

Load(AssemblyName, Evidence)

Charge Assembly en fonction de son AssemblyName. Loads an Assembly given its AssemblyName.

Load(Byte[])

Charge Assembly avec l'image au format COFF (Common Object File Format) contenant un Assembly émis. Loads the Assembly with a common object file format (COFF) based image containing an emitted Assembly.

Load(Byte[], Byte[])

Charge Assembly avec l'image au format COFF (Common Object File Format) contenant un Assembly émis. Loads the Assembly with a common object file format (COFF) based image containing an emitted Assembly. Les octets bruts représentant les symboles de Assembly sont également chargés. The raw bytes representing the symbols for the Assembly are also loaded.

Load(Byte[], Byte[], Evidence)

Charge Assembly avec l'image au format COFF (Common Object File Format) contenant un Assembly émis. Loads the Assembly with a common object file format (COFF) based image containing an emitted Assembly. Les octets bruts représentant les symboles de Assembly sont également chargés. The raw bytes representing the symbols for the Assembly are also loaded.

Load(String)

Charge Assembly en fonction de son nom complet. Loads an Assembly given its display name.

Load(String, Evidence)

Charge Assembly en fonction de son nom complet. Loads an Assembly given its display name.

MemberwiseClone()

Crée une copie superficielle du Object actuel. Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel. Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
ReflectionOnlyGetAssemblies()

Retourne les assemblys qui ont été chargés dans le contexte de réflexion uniquement du domaine d'application. Returns the assemblies that have been loaded into the reflection-only context of the application domain.

SetAppDomainPolicy(PolicyLevel)

Définit le niveau de stratégie de sécurité pour ce domaine d'application. Establishes the security policy level for this application domain.

SetCachePath(String)

Définit le chemin d’accès du répertoire spécifié comme emplacement pour les clichés instantanés des assemblys. Establishes the specified directory path as the location where assemblies are shadow copied.

SetData(String, Object)

Assigne la valeur spécifiée à la propriété du domaine d'application spécifié. Assigns the specified value to the specified application domain property.

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. Assigns the specified value to the specified application domain property, with a specified permission to demand of the caller when the property is retrieved.

SetDynamicBase(String)

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. Establishes the specified directory path as the base directory for subdirectories where dynamically generated files are stored and accessed.

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. Specifies how principal and identity objects should be attached to a thread if the thread attempts to bind to a principal while executing in this application domain.

SetShadowCopyFiles()

Active les clichés instantanés. Turns on shadow copying.

SetShadowCopyPath(String)

Définit le chemin d’accès du répertoire spécifié comme emplacement pour les clichés instantanés des assemblys. Establishes the specified directory path as the location of assemblies to be shadow copied.

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. Sets the default principal object to be attached to threads if they attempt to bind to a principal while executing in this application domain.

ToString()

Obtient une représentation sous forme de chaîne qui inclut le nom convivial du domaine d'application et les stratégies de contexte. Obtains a string representation that includes the friendly name of the application domain and any context policies.

Unload(AppDomain)

Décharge le domaine d'application spécifié. Unloads the specified application domain.

Événements

AssemblyLoad

Se produit quand un assembly est chargé. Occurs when an assembly is loaded.

AssemblyResolve

Se produit quand la résolution d'un assembly échoue. Occurs when the resolution of an assembly fails.

DomainUnload

Se produit quand AppDomain est sur le point d'être déchargé. Occurs when an AppDomain is about to be unloaded.

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. Occurs when an exception is thrown in managed code, before the runtime searches the call stack for an exception handler in the application domain.

ProcessExit

Se produit quand le processus parent du domaine d'application par défaut s'arrête. Occurs when the default application domain's parent process exits.

ReflectionOnlyAssemblyResolve

Se produit quand la résolution d’un assembly échoue dans le contexte de réflexion uniquement. Occurs when the resolution of an assembly fails in the reflection-only context.

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. Occurs when the resolution of a resource fails because the resource is not a valid linked or embedded resource in the assembly.

TypeResolve

Se produit quand la résolution d’un type échoue. Occurs when the resolution of a type fails.

UnhandledException

Se produit quand une exception n'est pas interceptée. Occurs when an exception is not caught.

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. Maps a set of names to a corresponding set of dispatch identifiers.

_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. Retrieves the type information for an object, which can then be used to get the type information for an interface.

_AppDomain.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). Retrieves the number of type information interfaces that an object provides (either 0 or 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. Provides access to properties and methods exposed by an object.

S’applique à