AppDomain AppDomain AppDomain 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.

public ref class AppDomain sealed : 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
type AppDomain = class
    inherit MarshalByRefObject
    interface _AppDomain
    interface IEvidenceFactory
Public NotInheritable Class AppDomain
Inherits MarshalByRefObject
Implements _AppDomain, IEvidenceFactory
Héritage
Attributs
Implémente

Exemples

Cet exemple montre comment créer un 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 AppDomain le provoquant le garbage collector de l’objet.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.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 les objets, permettent de 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.

  • Utilisez les domaines d’application pour isoler les tâches susceptibles d’entraîner un processus.Use application domains to isolate tasks that might bring down a process. Si l’état du AppDomain qui exécute une tâche devient instable 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. Cela est important lorsqu’un processus doit s’exécuter pendant de longues périodes sans redémarrage.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é 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é quand 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. Utilisez cette technique pour réduire la plage de travail des processus de longue durée qui utilisent occasionnellement des dll volumineuses.Use this technique to minimize the working set of long-running processes that occasionally use large DLLs.

Notes

Sur .net Core, l' AppDomain implémentation est limitée par la conception et ne fournit pas d’isolation, de déchargement ou de limites de sécurité.On .NET Core, the AppDomain implementation is limited by design and does not provide isolation, unloading, or security boundaries. Pour .NET Core, il existe exactement un AppDomain.For .NET Core, there is exactly one AppDomain. L’isolation et le déchargement sont AssemblyLoadContextfournis par le biais de.Isolation and unloading are provided through AssemblyLoadContext. Les limites de sécurité doivent être fournies par les limites de processus et les techniques de communication à distance appropriées.Security boundaries should be provided by process boundaries and appropriate remoting techniques.

Plusieurs domaines d’application peuvent s’exécuter dans un processus unique ; Toutefois, il n’existe pas de corrélation un-à-un entre les 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 lorsqu’un thread donné n’est pas limité à un seul domaine d’application, à un moment donné, un thread s’exécute dans un domaine d’application unique.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.

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

La AppDomain classe implémente un jeu 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.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 les MarshalByRefObjectinterfaces _AppDomain, et IEvidenceFactory .This class implements the MarshalByRefObject, _AppDomain, and IEvidenceFactory interfaces.

Vous ne devez jamais créer un wrapper accessible à distance AppDomain pour un objet.You should never create a remotable wrapper for an AppDomain object. Vous pouvez ainsi publier une référence distante AppDomainà celle-ci, en CreateInstance exposant des méthodes telles que l’accès à distance et en AppDomaindétruisant efficacement la sécurité d’accès du code.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. Les clients malveillants qui se connectent à distants AppDomain peuvent obtenir l’accès à toute AppDomain ressource à laquelle elle 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 MarshalByRefObject qui étend et qui implémente des méthodes qui pourraient être utilisées par des clients malveillants pour contourner 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 de AppDomainSetup.DisallowCodeDownload la propriété falseest.The default value for the AppDomainSetup.DisallowCodeDownload property is false. Ce paramètre n’est pas sécurisé pour les services.This setting is unsafe for services. Pour empêcher les services de télécharger du code partiellement fiable, affectez truela valeur à cette propriété.To prevent services from downloading partially trusted code, set this property to true.

Propriétés

ActivationContext ActivationContext ActivationContext ActivationContext

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

ApplicationIdentity ApplicationIdentity ApplicationIdentity ApplicationIdentity

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

ApplicationTrust ApplicationTrust ApplicationTrust 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 BaseDirectory BaseDirectory 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 CurrentDomain CurrentDomain CurrentDomain

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

DomainManager DomainManager DomainManager 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 DynamicDirectory DynamicDirectory 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 Evidence Evidence Evidence

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

FriendlyName FriendlyName FriendlyName FriendlyName

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

Id Id Id 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 IsFullyTrusted IsFullyTrusted 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 IsHomogenous IsHomogenous 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 MonitoringIsEnabled MonitoringIsEnabled 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 MonitoringSurvivedMemorySize MonitoringSurvivedMemorySize 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 MonitoringSurvivedProcessMemorySize MonitoringSurvivedProcessMemorySize 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 MonitoringTotalAllocatedMemorySize MonitoringTotalAllocatedMemorySize 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 MonitoringTotalProcessorTime MonitoringTotalProcessorTime 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 PermissionSet PermissionSet 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 RelativeSearchPath RelativeSearchPath 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 SetupInformation SetupInformation SetupInformation

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

ShadowCopyFiles ShadowCopyFiles ShadowCopyFiles 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) AppendPrivatePath(String) AppendPrivatePath(String) 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) ApplyPolicy(String) ApplyPolicy(String) 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() ClearPrivatePath() ClearPrivatePath() 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() ClearShadowCopyPath() ClearShadowCopyPath() 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) CreateComInstanceFrom(String, String) CreateComInstanceFrom(String, 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) CreateComInstanceFrom(String, String, Byte[], AssemblyHashAlgorithm) CreateComInstanceFrom(String, String, Byte[], AssemblyHashAlgorithm) 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) CreateDomain(String) CreateDomain(String) 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) CreateDomain(String, Evidence) CreateDomain(String, Evidence) 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) CreateDomain(String, Evidence, AppDomainSetup) CreateDomain(String, Evidence, AppDomainSetup) 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[]) CreateDomain(String, Evidence, AppDomainSetup, PermissionSet, StrongName[]) CreateDomain(String, Evidence, AppDomainSetup, PermissionSet, StrongName[]) 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) CreateDomain(String, Evidence, String, String, Boolean) CreateDomain(String, Evidence, String, String, Boolean) 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[]) CreateDomain(String, Evidence, String, String, Boolean, AppDomainInitializer, String[]) CreateDomain(String, Evidence, String, String, Boolean, AppDomainInitializer, String[]) 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) CreateInstance(String, String) CreateInstance(String, String) 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[]) CreateInstance(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[]) CreateInstance(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[]) 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) CreateInstance(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence) CreateInstance(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence) 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[]) CreateInstance(String, String, Object[]) CreateInstance(String, String, Object[]) 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) CreateInstanceAndUnwrap(String, String) CreateInstanceAndUnwrap(String, String) 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[]) CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[]) CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[]) 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) CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence) CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence) 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[]) CreateInstanceAndUnwrap(String, String, Object[]) CreateInstanceAndUnwrap(String, String, Object[]) 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) CreateInstanceFrom(String, String) CreateInstanceFrom(String, String) 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[]) CreateInstanceFrom(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[]) CreateInstanceFrom(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[]) 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) CreateInstanceFrom(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence) CreateInstanceFrom(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence) 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[]) CreateInstanceFrom(String, String, Object[]) CreateInstanceFrom(String, String, Object[]) 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) CreateInstanceFromAndUnwrap(String, String) CreateInstanceFromAndUnwrap(String, String) 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[]) CreateInstanceFromAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[]) CreateInstanceFromAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[]) 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) CreateInstanceFromAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence) CreateInstanceFromAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence) 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[]) CreateInstanceFromAndUnwrap(String, String, Object[]) CreateInstanceFromAndUnwrap(String, String, Object[]) 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) CreateObjRef(Type) CreateObjRef(Type) 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) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess) 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) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence) 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) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence, PermissionSet, PermissionSet, PermissionSet) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence, PermissionSet, PermissionSet, PermissionSet) 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>) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>) 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) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>, SecurityContextSource) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>, SecurityContextSource) 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) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, PermissionSet, PermissionSet, PermissionSet) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, PermissionSet, PermissionSet, PermissionSet) 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) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String) 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>) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Boolean, IEnumerable<CustomAttributeBuilder>) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Boolean, IEnumerable<CustomAttributeBuilder>) 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) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence) 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) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet) 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) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean) 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>) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean, IEnumerable<CustomAttributeBuilder>) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean, IEnumerable<CustomAttributeBuilder>) 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) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, PermissionSet, PermissionSet, PermissionSet) DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, PermissionSet, PermissionSet, PermissionSet) 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) DoCallBack(CrossAppDomainDelegate) DoCallBack(CrossAppDomainDelegate) 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) Equals(Object) Equals(Object) 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) ExecuteAssembly(String) ExecuteAssembly(String) ExecuteAssembly(String)

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

ExecuteAssembly(String, Evidence) ExecuteAssembly(String, Evidence) ExecuteAssembly(String, Evidence) 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[]) ExecuteAssembly(String, Evidence, String[]) ExecuteAssembly(String, Evidence, String[]) 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) ExecuteAssembly(String, Evidence, String[], Byte[], AssemblyHashAlgorithm) ExecuteAssembly(String, Evidence, String[], Byte[], AssemblyHashAlgorithm) 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[]) ExecuteAssembly(String, String[]) ExecuteAssembly(String, String[]) 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) ExecuteAssembly(String, String[], Byte[], AssemblyHashAlgorithm) ExecuteAssembly(String, String[], Byte[], AssemblyHashAlgorithm) 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[]) ExecuteAssemblyByName(AssemblyName, Evidence, String[]) ExecuteAssemblyByName(AssemblyName, Evidence, String[]) 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[]) ExecuteAssemblyByName(AssemblyName, String[]) ExecuteAssemblyByName(AssemblyName, String[]) 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) ExecuteAssemblyByName(String) ExecuteAssemblyByName(String) ExecuteAssemblyByName(String)

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

ExecuteAssemblyByName(String, Evidence) ExecuteAssemblyByName(String, Evidence) ExecuteAssemblyByName(String, Evidence) 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[]) ExecuteAssemblyByName(String, Evidence, String[]) ExecuteAssemblyByName(String, Evidence, String[]) 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[]) ExecuteAssemblyByName(String, String[]) ExecuteAssemblyByName(String, String[]) 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() GetAssemblies() GetAssemblies() 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() GetCurrentThreadId() GetCurrentThreadId() GetCurrentThreadId()

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

GetData(String) GetData(String) GetData(String) 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() GetHashCode() GetHashCode() GetHashCode()

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

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() 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() GetType() GetType() GetType()

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

InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() 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) IsCompatibilitySwitchSet(String) IsCompatibilitySwitchSet(String) 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() IsDefaultAppDomain() IsDefaultAppDomain() 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() IsFinalizingForUnload() IsFinalizingForUnload() 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) Load(AssemblyName) Load(AssemblyName) Load(AssemblyName)

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

Load(AssemblyName, Evidence) Load(AssemblyName, Evidence) Load(AssemblyName, Evidence) Load(AssemblyName, Evidence)

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

Load(Byte[]) Load(Byte[]) Load(Byte[]) 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[]) Load(Byte[], Byte[]) Load(Byte[], Byte[]) 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) Load(Byte[], Byte[], Evidence) Load(Byte[], Byte[], Evidence) 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) Load(String) Load(String) Load(String)

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

Load(String, Evidence) Load(String, Evidence) Load(String, Evidence) Load(String, Evidence)

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

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

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

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) 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() ReflectionOnlyGetAssemblies() ReflectionOnlyGetAssemblies() 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) SetAppDomainPolicy(PolicyLevel) SetAppDomainPolicy(PolicyLevel) 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) SetCachePath(String) SetCachePath(String) 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) SetData(String, Object) SetData(String, Object) 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) SetData(String, Object, IPermission) SetData(String, Object, IPermission) 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) SetDynamicBase(String) SetDynamicBase(String) 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) SetPrincipalPolicy(PrincipalPolicy) SetPrincipalPolicy(PrincipalPolicy) 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() SetShadowCopyFiles() SetShadowCopyFiles() SetShadowCopyFiles()

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

SetShadowCopyPath(String) SetShadowCopyPath(String) SetShadowCopyPath(String) 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) SetThreadPrincipal(IPrincipal) SetThreadPrincipal(IPrincipal) 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() ToString() ToString() 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) Unload(AppDomain) Unload(AppDomain) Unload(AppDomain)

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

Événements

AssemblyLoad AssemblyLoad AssemblyLoad AssemblyLoad

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

AssemblyResolve AssemblyResolve AssemblyResolve AssemblyResolve

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

DomainUnload DomainUnload DomainUnload DomainUnload

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

FirstChanceException FirstChanceException FirstChanceException 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 ProcessExit ProcessExit 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 ReflectionOnlyAssemblyResolve ReflectionOnlyAssemblyResolve 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 ResourceResolve ResourceResolve 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 TypeResolve TypeResolve TypeResolve

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

UnhandledException UnhandledException UnhandledException 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) _AppDomain.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _AppDomain.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _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) _AppDomain.GetTypeInfo(UInt32, UInt32, IntPtr) _AppDomain.GetTypeInfo(UInt32, UInt32, IntPtr) _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) _AppDomain.GetTypeInfoCount(UInt32) _AppDomain.GetTypeInfoCount(UInt32) _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) _AppDomain.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _AppDomain.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _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 à

Voir aussi