AppDomain.CreateInstanceAndUnwrap Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Crée une instance d’un type spécifié.

Surcharges

CreateInstanceAndUnwrap(String, String)	Crée une instance du type spécifié. Les paramètres spécifient l’assembly où le type est défini et le nom du type.
CreateInstanceAndUnwrap(String, String, Object[])	Crée une instance du type spécifié. Les paramètres spécifient l’assembly où le type est défini, le nom du type et un tableau d’attributs d’activation.
CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Crée une instance du type spécifié défini dans l’assembly spécifié, en spécifiant si le cas du nom de type est ignoré ; les attributs de liaison et le classeur utilisés pour sélectionner le type à créer ; arguments du constructeur ; la culture ; et les attributs d’activation.

CreateInstanceAndUnwrap(String, String)

Source:

AppDomain.cs

Crée une instance du type spécifié. Les paramètres spécifient l’assembly où le type est défini et le nom du type.

C#

public object? CreateInstanceAndUnwrap (string assemblyName, string typeName);

Paramètres

assemblyName

String

Nom complet de l’assembly. Voir FullName.

typeName

String

Nom complet du type demandé, y compris l’espace de noms, mais pas l’assembly, tel que retourné par la propriété FullName.

Retours

Object

Instance de l’objet spécifié par typeName.

Exceptions

ArgumentNullException

assemblyName ou typeName est null.

MissingMethodException

Aucun constructeur public correspondant n’a été trouvé.

TypeLoadException

typeName n’a pas été trouvé dans assemblyName.

FileNotFoundException

assemblyName n’a pas été trouvé.

MethodAccessException

L’appelant n’a pas l’autorisation d’appeler ce constructeur.

AppDomainUnloadedException

L’opération est tentée sur un domaine d’application déchargé.

BadImageFormatException

assemblyName n’est pas un assembly valide pour le runtime actuellement chargé.

FileLoadException

Un assembly ou un module a été chargé deux fois avec deux preuves différentes.

Exemples

L’exemple de code suivant montre la façon la plus simple d’exécuter du code dans un autre domaine d’application. L’exemple définit une classe nommée Worker qui hérite de MarshalByRefObject. La classe Worker définit une méthode qui affiche le nom du domaine d’application dans lequel elle s’exécute. L’exemple crée des instances de Worker dans le domaine d’application par défaut et dans un nouveau domaine d’application.

Note

L’assembly qui contient Worker doit être chargé dans les deux domaines d’application, mais il peut charger d’autres assemblys qui existent uniquement dans le nouveau domaine d’application.

C#

using System;
using System.Reflection;

public class CreateInstanceWorker : MarshalByRefObject
{
    public void PrintDomain()
    {
        Console.WriteLine("Object is executing in AppDomain \"{0}\"",
            AppDomain.CurrentDomain.FriendlyName);
    }
}

class CreateInstanceAndUnwrapSourceSnippet
{
    public static void Main()
    {
        // Create an ordinary instance in the current AppDomain
        CreateInstanceWorker localWorker = new CreateInstanceWorker();
        localWorker.PrintDomain();

        // Create a new application domain, create an instance
        // of Worker in the application domain, and execute code
        // there.
        AppDomain ad = AppDomain.CreateDomain("New domain");
        CreateInstanceWorker remoteWorker = (CreateInstanceWorker) ad.CreateInstanceAndUnwrap(
            typeof(CreateInstanceWorker).Assembly.FullName,
            "Worker");
        remoteWorker.PrintDomain();
    }
}

/* This code produces output similar to the following:

Object is executing in AppDomain "source.exe"
Object is executing in AppDomain "New domain"
 */

Remarques

Il s’agit d’une méthode pratique qui combine CreateInstance et ObjectHandle.Unwrap. Cette méthode appelle le constructeur sans paramètre pour typeName.

Consultez AssemblyName pour connaître le format de assemblyName. Consultez la propriété Type.FullName pour le format de typeName.

Note

Si vous effectuez un appel à liaison anticipée à une méthode M d’un objet de type T1 retourné par CreateInstanceAndUnwrap, et que cette méthode effectue un appel à liaison anticipée à une méthode d’un objet de type T2 dans un assembly C autre que l’assembly actuel ou l’assembly contenant T1, l’assembly C est chargé dans le domaine d’application actuel. Ce chargement se produit même si l’appel à liaison anticipée à T1.M() a été effectué dans le corps d’un DynamicMethod, ou dans d’autres codes générés dynamiquement. Si le domaine actuel est le domaine par défaut, l’assembly C ne peut pas être déchargé jusqu’à ce que le processus se termine. Si le domaine actuel tente ultérieurement de charger l’assembly C, la charge risque d’échouer.

Voir aussi

• CreateInstance(String, String)

CreateInstanceAndUnwrap(String, String, Object[])

Source:

AppDomain.cs

Crée une instance du type spécifié. Les paramètres spécifient l’assembly où le type est défini, le nom du type et un tableau d’attributs d’activation.

C#

public object? CreateInstanceAndUnwrap (string assemblyName, string typeName, object?[]? activationAttributes);

Paramètres

assemblyName

String

Nom complet de l’assembly. Voir FullName.

typeName

String

Nom complet du type demandé, y compris l’espace de noms, mais pas l’assembly, tel que retourné par la propriété FullName.

activationAttributes

Object[]

Tableau d’un ou plusieurs attributs pouvant participer à l’activation. En règle générale, un tableau qui contient un seul objet UrlAttribute qui spécifie l’URL requise pour activer un objet distant.

Ce paramètre est lié aux objets activés par le client. L’activation du client est une technologie héritée qui est conservée pour la compatibilité descendante, mais qui n’est pas recommandée pour le nouveau développement. Les applications distribuées doivent plutôt utiliser Windows Communication Foundation.

Retours

Object

Instance de l’objet spécifié par typeName.

Exceptions

ArgumentNullException

assemblyName ou typeName est null.

MissingMethodException

Aucun constructeur public correspondant n’a été trouvé.

TypeLoadException

typeName n’a pas été trouvé dans assemblyName.

FileNotFoundException

assemblyName n’a pas été trouvé.

MethodAccessException

L’appelant n’a pas l’autorisation d’appeler ce constructeur.

NotSupportedException

L’appelant ne peut pas fournir d’attributs d’activation pour un objet qui n’hérite pas de MarshalByRefObject.

AppDomainUnloadedException

L’opération est tentée sur un domaine d’application déchargé.

BadImageFormatException

assemblyName n’est pas un assembly valide pour le runtime actuellement chargé.

FileLoadException

Un assembly ou un module a été chargé deux fois avec deux preuves différentes.

Exemples

C#

using System;
using System.IO;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.Remoting;

class ADDyno
{
   public static Type CreateADynamicAssembly(ref AppDomain myNewDomain,
                         string executableNameNoExe)
   {
    string executableName = executableNameNoExe + ".exe";

    AssemblyName myAsmName = new AssemblyName();
    myAsmName.Name = executableNameNoExe;
    myAsmName.CodeBase = Environment.CurrentDirectory;

    AssemblyBuilder myAsmBuilder = myNewDomain.DefineDynamicAssembly(myAsmName,
                        AssemblyBuilderAccess.RunAndSave);
    Console.WriteLine("-- Dynamic Assembly instantiated.");

    ModuleBuilder myModBuilder = myAsmBuilder.DefineDynamicModule(executableNameNoExe,
                                      executableName);

    TypeBuilder myTypeBuilder = myModBuilder.DefineType(executableNameNoExe,
                        TypeAttributes.Public,
                        typeof(MarshalByRefObject));

    MethodBuilder myFCMethod = myTypeBuilder.DefineMethod("CountLocalFiles",
                        MethodAttributes.Public |
                        MethodAttributes.Static,
                        null,
                        new Type[] {  });

    MethodInfo currentDirGetMI = typeof(Environment).GetProperty("CurrentDirectory").GetGetMethod();
    MethodInfo writeLine0objMI = typeof(Console).GetMethod("WriteLine",
                     new Type[] { typeof(string) });
    MethodInfo writeLine2objMI = typeof(Console).GetMethod("WriteLine",
                     new Type[] { typeof(string), typeof(object), typeof(object) });
    MethodInfo getFilesMI = typeof(Directory).GetMethod("GetFiles",
                new Type[] { typeof(string) });

    myFCMethod.InitLocals = true;

    ILGenerator myFCIL = myFCMethod.GetILGenerator();

    Console.WriteLine("-- Generating MSIL method body...");
    LocalBuilder v0 = myFCIL.DeclareLocal(typeof(string));
    LocalBuilder v1 = myFCIL.DeclareLocal(typeof(int));
    LocalBuilder v2 = myFCIL.DeclareLocal(typeof(string));
    LocalBuilder v3 = myFCIL.DeclareLocal(typeof(string[]));

    Label evalForEachLabel = myFCIL.DefineLabel();
    Label topOfForEachLabel = myFCIL.DefineLabel();

    // Build the method body.

    myFCIL.EmitCall(OpCodes.Call, currentDirGetMI, null);
    myFCIL.Emit(OpCodes.Stloc_S, v0);
    myFCIL.Emit(OpCodes.Ldc_I4_0);
    myFCIL.Emit(OpCodes.Stloc_S, v1);
    myFCIL.Emit(OpCodes.Ldstr, "---");
    myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, null);
    myFCIL.Emit(OpCodes.Ldloc_S, v0);
    myFCIL.EmitCall(OpCodes.Call, getFilesMI, null);
    myFCIL.Emit(OpCodes.Stloc_S, v3);

    myFCIL.Emit(OpCodes.Br_S, evalForEachLabel);

    // foreach loop starts here.
    myFCIL.MarkLabel(topOfForEachLabel);
    
        // Load array of strings and index, store value at index for output.
    myFCIL.Emit(OpCodes.Ldloc_S, v3);
    myFCIL.Emit(OpCodes.Ldloc_S, v1);
    myFCIL.Emit(OpCodes.Ldelem_Ref);
    myFCIL.Emit(OpCodes.Stloc_S, v2);

    myFCIL.Emit(OpCodes.Ldloc_S, v2);
    myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, null);

    // Increment counter by one.
    myFCIL.Emit(OpCodes.Ldloc_S, v1);
    myFCIL.Emit(OpCodes.Ldc_I4_1);
    myFCIL.Emit(OpCodes.Add);
    myFCIL.Emit(OpCodes.Stloc_S, v1);

    // Determine if end of file list array has been reached.
    myFCIL.MarkLabel(evalForEachLabel);
    myFCIL.Emit(OpCodes.Ldloc_S, v1);
    myFCIL.Emit(OpCodes.Ldloc_S, v3);
    myFCIL.Emit(OpCodes.Ldlen);
    myFCIL.Emit(OpCodes.Conv_I4);
    myFCIL.Emit(OpCodes.Blt_S, topOfForEachLabel);
    //foreach loop end here.

    myFCIL.Emit(OpCodes.Ldstr, "---");
    myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, null);
    myFCIL.Emit(OpCodes.Ldstr, "There are {0} files in {1}.");
    myFCIL.Emit(OpCodes.Ldloc_S, v1);
    myFCIL.Emit(OpCodes.Box, typeof(int));
    myFCIL.Emit(OpCodes.Ldloc_S, v0);
    myFCIL.EmitCall(OpCodes.Call, writeLine2objMI, null);

    myFCIL.Emit(OpCodes.Ret);

    Type myType = myTypeBuilder.CreateType();

    myAsmBuilder.SetEntryPoint(myFCMethod);
    myAsmBuilder.Save(executableName);		
    Console.WriteLine("-- Method generated, type completed, and assembly saved to disk.");

    return myType;
   }

   public static void Main()
   {

    string domainDir, executableName = null;
    
    Console.Write("Enter a name for the file counting assembly: ");
    string executableNameNoExe = Console.ReadLine();
    executableName = executableNameNoExe + ".exe";
    Console.WriteLine("---");

    domainDir = Environment.CurrentDirectory;

    AppDomain curDomain = Thread.GetDomain();	

    // Create a new AppDomain, with the current directory as the base.

    Console.WriteLine("Current Directory: {0}", Environment.CurrentDirectory);
    AppDomainSetup mySetupInfo = new AppDomainSetup();
    mySetupInfo.ApplicationBase = domainDir;
    mySetupInfo.ApplicationName = executableNameNoExe;
    mySetupInfo.LoaderOptimization = LoaderOptimization.SingleDomain;

    AppDomain myDomain = AppDomain.CreateDomain(executableNameNoExe,
                    null, mySetupInfo);

    Console.WriteLine("Creating a new AppDomain '{0}'...",
                    executableNameNoExe);

    Console.WriteLine("-- Base Directory = '{0}'", myDomain.BaseDirectory);
    Console.WriteLine("-- Shadow Copy? = '{0}'", myDomain.ShadowCopyFiles);

    Console.WriteLine("---");
    Type myFCType = CreateADynamicAssembly(ref curDomain,
                     executableNameNoExe);

    Console.WriteLine("Loading '{0}' from '{1}'...", executableName,
              myDomain.BaseDirectory.ToString());

    BindingFlags bFlags = (BindingFlags.Public | BindingFlags.CreateInstance |
                   BindingFlags.Instance);

    Object myObjInstance = myDomain.CreateInstanceAndUnwrap(executableNameNoExe,
                executableNameNoExe, false, bFlags,
                null, null, null, null, null);

    Console.WriteLine("Executing method 'CountLocalFiles' in {0}...",
               myObjInstance.ToString());

    myFCType.InvokeMember("CountLocalFiles", BindingFlags.InvokeMethod, null,
                myObjInstance, new object[] { });
   }
}

Remarques

Il s’agit d’une méthode pratique qui combine CreateInstance et ObjectHandle.Unwrap. Cette méthode appelle le constructeur sans paramètre pour typeName.

Consultez AssemblyName pour connaître le format de assemblyName. Consultez la propriété Type.FullName pour le format de typeName.

Note

Si vous effectuez un appel à liaison anticipée à une méthode M d’un objet de type T1 retourné par CreateInstanceAndUnwrap, et que cette méthode effectue un appel à liaison anticipée à une méthode d’un objet de type T2 dans un assembly C autre que l’assembly actuel ou l’assembly contenant T1, l’assembly C est chargé dans le domaine d’application actuel. Ce chargement se produit même si l’appel à liaison anticipée à T1.M() a été effectué dans le corps d’un DynamicMethod, ou dans d’autres codes générés dynamiquement. Si le domaine actuel est le domaine par défaut, l’assembly C ne peut pas être déchargé jusqu’à ce que le processus se termine. Si le domaine actuel tente ultérieurement de charger l’assembly C, la charge risque d’échouer.

Voir aussi

• CreateInstance(String, String)

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

Source:

AppDomain.cs

Crée une instance du type spécifié défini dans l’assembly spécifié, en spécifiant si le cas du nom de type est ignoré ; les attributs de liaison et le classeur utilisés pour sélectionner le type à créer ; arguments du constructeur ; la culture ; et les attributs d’activation.

C#

public object? CreateInstanceAndUnwrap (string assemblyName, string typeName, bool ignoreCase, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder? binder, object?[]? args, System.Globalization.CultureInfo? culture, object?[]? activationAttributes);

Paramètres

assemblyName

String

Nom complet de l’assembly. Voir FullName.

typeName

String

Nom complet du type demandé, y compris l’espace de noms, mais pas l’assembly, tel que retourné par la propriété FullName.

ignoreCase

Boolean

Valeur booléenne spécifiant s’il faut effectuer une recherche sensible à la casse ou non.

bindingAttr

BindingFlags

Combinaison d’indicateurs de bits zéro ou plus qui affectent la recherche du constructeur typeName. Si bindingAttr est égal à zéro, une recherche sensible à la casse pour les constructeurs publics est effectuée.

binder

Binder

Objet qui permet la liaison, la contrainte des types d’arguments, l’appel de membres et la récupération d’objets MemberInfo à l’aide de la réflexion. Si binder a la valeur Null, le classeur par défaut est utilisé.

args

Object[]

Arguments à passer au constructeur. Ce tableau d’arguments doit correspondre au nombre, à l’ordre et au type des paramètres du constructeur à appeler. Si le constructeur sans paramètre est préféré, args doit être un tableau vide ou null.

culture

CultureInfo

Objet propre à la culture utilisé pour régir la contrainte des types. Si culture est null, le CultureInfo du thread actuel est utilisé.

activationAttributes

Object[]

Tableau d’un ou plusieurs attributs pouvant participer à l’activation. En règle générale, un tableau qui contient un seul objet UrlAttribute. qui spécifie l’URL requise pour activer un objet distant.

Ce paramètre est lié aux objets activés par le client. L’activation du client est une technologie héritée qui est conservée pour la compatibilité descendante, mais qui n’est pas recommandée pour le nouveau développement. Les applications distribuées doivent plutôt utiliser Windows Communication Foundation.

Retours

Object

Instance de l’objet spécifié par typeName.

Exceptions

ArgumentNullException

assemblyName ou typeName est null.

MissingMethodException

Aucun constructeur correspondant n’a été trouvé.

TypeLoadException

typeName n’a pas été trouvé dans assemblyName.

FileNotFoundException

assemblyName n’a pas été trouvé.

MethodAccessException

L’appelant n’a pas l’autorisation d’appeler ce constructeur.

NotSupportedException

L’appelant ne peut pas fournir d’attributs d’activation pour un objet qui n’hérite pas de MarshalByRefObject.

AppDomainUnloadedException

L’opération est tentée sur un domaine d’application déchargé.

BadImageFormatException

assemblyName n’est pas un assembly valide pour le runtime actuellement chargé.

FileLoadException

Un assembly ou un module a été chargé deux fois avec deux preuves différentes.

Exemples

L’exemple suivant illustre l’utilisation du paramètre ignoreCase.

C#

using System;
using System.Reflection;

class IgnoreCaseSnippet {

   static void Main() {
      InstantiateINT32(false);     // Failed!
      InstantiateINT32(true);      // OK!
   }

   static void InstantiateINT32(bool ignoreCase) {
      try {
         AppDomain currentDomain = AppDomain.CurrentDomain;
         object instance = currentDomain.CreateInstanceAndUnwrap(
            "mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
            "SYSTEM.INT32",
            ignoreCase,
            BindingFlags.Default,
            null,
            null,
            null,
            null,
            null
         );
         Console.WriteLine(instance.GetType());
      } catch (TypeLoadException e) {
         Console.WriteLine(e.Message);
      }
   }
}

Remarques

Il s’agit d’une méthode pratique qui combine CreateInstance et ObjectHandle.Unwrap.

Consultez AssemblyName pour connaître le format de assemblyName. Consultez la propriété Type.FullName pour le format de typeName.

Note

Si vous effectuez un appel à liaison anticipée à une méthode M d’un objet de type T1 retourné par CreateInstanceAndUnwrap, et que cette méthode effectue un appel à liaison anticipée à une méthode d’un objet de type T2 dans un assembly C autre que l’assembly actuel ou l’assembly contenant T1, l’assembly C est chargé dans le domaine d’application actuel. Ce chargement se produit même si l’appel à liaison anticipée à T1.M() a été effectué dans le corps d’un DynamicMethod, ou dans d’autres codes générés dynamiquement. Si le domaine actuel est le domaine par défaut, l’assembly C ne peut pas être déchargé jusqu’à ce que le processus se termine. Si le domaine actuel tente ultérieurement de charger l’assembly C, la charge risque d’échouer.

Voir aussi

• CreateInstance(String, String)