ModuleBuilder Classe

Référence

Définition

Espace de noms:: System.Reflection.Emit

Assembly:: System.Reflection.Emit.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Paquet:: System.Reflection.Emit v4.7.0

Source:: ModuleBuilder.cs

Source:: ModuleBuilder.cs

Source:: ModuleBuilder.cs

Important

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

Définit et représente un module dans un assembly dynamique.

public ref class ModuleBuilder : System::Reflection::Module

public ref class ModuleBuilder abstract : System::Reflection::Module

public ref class ModuleBuilder : System::Reflection::Module, System::Runtime::InteropServices::_ModuleBuilder

public class ModuleBuilder : System.Reflection.Module

public abstract class ModuleBuilder : System.Reflection.Module

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public class ModuleBuilder : System.Reflection.Module, System.Runtime.InteropServices._ModuleBuilder

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public class ModuleBuilder : System.Reflection.Module, System.Runtime.InteropServices._ModuleBuilder

type ModuleBuilder = class
    inherit Module

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type ModuleBuilder = class
    inherit Module
    interface _ModuleBuilder

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ModuleBuilder = class
    inherit Module
    interface _ModuleBuilder

Public Class ModuleBuilder
Inherits Module

Public MustInherit Class ModuleBuilder
Inherits Module

Public Class ModuleBuilder
Inherits Module
Implements _ModuleBuilder

Héritage: Object

Module
ModuleBuilder

Attributs: ClassInterfaceAttribute ComVisibleAttribute

Implémente: _ModuleBuilder

Exemples

L’exemple de code suivant illustre l’utilisation de ModuleBuilder pour créer un module dynamique. Notez que le ModuleBuilder est créé en appelant DefineDynamicModule dans AssemblyBuilder, plutôt qu’via un constructeur.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
public ref class CodeGenerator
{
private:
   AssemblyBuilder^ myAssemblyBuilder;

public:
   CodeGenerator()
   {
      // Get the current application domain for the current thread.
      AppDomain^ myCurrentDomain = AppDomain::CurrentDomain;
      AssemblyName^ myAssemblyName = gcnew AssemblyName;
      myAssemblyName->Name = "TempAssembly";

      // Define a dynamic assembly in the current application domain.
      myAssemblyBuilder = myCurrentDomain->DefineDynamicAssembly( myAssemblyName, AssemblyBuilderAccess::Run );

      // Define a dynamic module in this assembly.
      ModuleBuilder^ myModuleBuilder = myAssemblyBuilder->DefineDynamicModule( "TempModule" );

      // Define a runtime class with specified name and attributes.
      TypeBuilder^ myTypeBuilder = myModuleBuilder->DefineType( "TempClass", TypeAttributes::Public );

      // Add 'Greeting' field to the class, with the specified attribute and type.
      FieldBuilder^ greetingField = myTypeBuilder->DefineField( "Greeting", String::typeid, FieldAttributes::Public );
      array<Type^>^myMethodArgs = {String::typeid};

      // Add 'MyMethod' method to the class, with the specified attribute and signature.
      MethodBuilder^ myMethod = myTypeBuilder->DefineMethod( "MyMethod", MethodAttributes::Public, CallingConventions::Standard, nullptr, myMethodArgs );
      ILGenerator^ methodIL = myMethod->GetILGenerator();
      methodIL->EmitWriteLine( "In the method..." );
      methodIL->Emit( OpCodes::Ldarg_0 );
      methodIL->Emit( OpCodes::Ldarg_1 );
      methodIL->Emit( OpCodes::Stfld, greetingField );
      methodIL->Emit( OpCodes::Ret );
      myTypeBuilder->CreateType();
   }

   property AssemblyBuilder^ MyAssembly 
   {
      AssemblyBuilder^ get()
      {
         return this->myAssemblyBuilder;
      }
   }
};

int main()
{
   CodeGenerator^ myCodeGenerator = gcnew CodeGenerator;

   // Get the assembly builder for 'myCodeGenerator' object.
   AssemblyBuilder^ myAssemblyBuilder = myCodeGenerator->MyAssembly;

   // Get the module builder for the above assembly builder object .
   ModuleBuilder^ myModuleBuilder = myAssemblyBuilder->GetDynamicModule( "TempModule" );
   Console::WriteLine( "The fully qualified name and path to this module is :{0}", myModuleBuilder->FullyQualifiedName );
   Type^ myType = myModuleBuilder->GetType( "TempClass" );
   MethodInfo^ myMethodInfo = myType->GetMethod( "MyMethod" );

   // Get the token used to identify the method within this module.
   MethodToken myMethodToken = myModuleBuilder->GetMethodToken( myMethodInfo );
   Console::WriteLine( "Token used to identify the method of 'myType'"
   " within the module is {0:x}", myMethodToken.Token );
   array<Object^>^args = {"Hello."};
   Object^ myObject = Activator::CreateInstance( myType, nullptr, nullptr );
   myMethodInfo->Invoke( myObject, args );
}

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Security.Permissions;

public class CodeGenerator
{
   AssemblyBuilder myAssemblyBuilder;
   public CodeGenerator()
   {
      // Get the current application domain for the current thread.
      AppDomain myCurrentDomain = AppDomain.CurrentDomain;
      AssemblyName myAssemblyName = new AssemblyName();
      myAssemblyName.Name = "TempAssembly";

      // Define a dynamic assembly in the current application domain.
      myAssemblyBuilder = myCurrentDomain.DefineDynamicAssembly
                     (myAssemblyName, AssemblyBuilderAccess.Run);

      // Define a dynamic module in this assembly.
      ModuleBuilder myModuleBuilder = myAssemblyBuilder.
                                      DefineDynamicModule("TempModule");

      // Define a runtime class with specified name and attributes.
      TypeBuilder myTypeBuilder = myModuleBuilder.DefineType
                                       ("TempClass",TypeAttributes.Public);

      // Add 'Greeting' field to the class, with the specified attribute and type.
      FieldBuilder greetingField = myTypeBuilder.DefineField("Greeting",
                                                            typeof(String), FieldAttributes.Public);
      Type[] myMethodArgs = { typeof(String) };

      // Add 'MyMethod' method to the class, with the specified attribute and signature.
      MethodBuilder myMethod = myTypeBuilder.DefineMethod("MyMethod",
         MethodAttributes.Public, CallingConventions.Standard, null,myMethodArgs);

      ILGenerator methodIL = myMethod.GetILGenerator();
      methodIL.EmitWriteLine("In the method...");
      methodIL.Emit(OpCodes.Ldarg_0);
      methodIL.Emit(OpCodes.Ldarg_1);
      methodIL.Emit(OpCodes.Stfld, greetingField);
      methodIL.Emit(OpCodes.Ret);
      myTypeBuilder.CreateType();
   }
   public AssemblyBuilder MyAssembly
   {
      get
      {
         return this.myAssemblyBuilder;
      }
   }
}
public class TestClass
{
   public static void Main()
   {
      CodeGenerator myCodeGenerator = new CodeGenerator();
      // Get the assembly builder for 'myCodeGenerator' object.
      AssemblyBuilder myAssemblyBuilder = myCodeGenerator.MyAssembly;
      // Get the module builder for the above assembly builder object .
      ModuleBuilder myModuleBuilder = myAssemblyBuilder.
                                                           GetDynamicModule("TempModule");
      Console.WriteLine("The fully qualified name and path to this "
                               + "module is :" +myModuleBuilder.FullyQualifiedName);
      Type myType = myModuleBuilder.GetType("TempClass");
      MethodInfo myMethodInfo =
                                                myType.GetMethod("MyMethod");
       // Get the token used to identify the method within this module.
      MethodToken myMethodToken =
                        myModuleBuilder.GetMethodToken(myMethodInfo);
      Console.WriteLine("Token used to identify the method of 'myType'"
                    + " within the module is {0:x}",myMethodToken.Token);
     object[] args={"Hello."};
     object myObject = Activator.CreateInstance(myType,null,null);
     myMethodInfo.Invoke(myObject,args);
   }
}

Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Security.Permissions

Public Class CodeGenerator
   Private myAssemblyBuilder As AssemblyBuilder

   Public Sub New()
      ' Get the current application domain for the current thread.
      Dim myCurrentDomain As AppDomain = AppDomain.CurrentDomain
      Dim myAssemblyName As New AssemblyName()
      myAssemblyName.Name = "TempAssembly"

      ' Define a dynamic assembly in the current application domain.
      myAssemblyBuilder = _
               myCurrentDomain.DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess.Run)

      ' Define a dynamic module in this assembly.
      Dim myModuleBuilder As ModuleBuilder = myAssemblyBuilder.DefineDynamicModule("TempModule")

      ' Define a runtime class with specified name and attributes.
      Dim myTypeBuilder As TypeBuilder = _
               myModuleBuilder.DefineType("TempClass", TypeAttributes.Public)

      ' Add 'Greeting' field to the class, with the specified attribute and type.
      Dim greetingField As FieldBuilder = _
               myTypeBuilder.DefineField("Greeting", GetType(String), FieldAttributes.Public)
      Dim myMethodArgs As Type() = {GetType(String)}

      ' Add 'MyMethod' method to the class, with the specified attribute and signature.
      Dim myMethod As MethodBuilder = _
               myTypeBuilder.DefineMethod("MyMethod", MethodAttributes.Public, _
               CallingConventions.Standard, Nothing, myMethodArgs)

      Dim methodIL As ILGenerator = myMethod.GetILGenerator()
      methodIL.EmitWriteLine("In the method...")
      methodIL.Emit(OpCodes.Ldarg_0)
      methodIL.Emit(OpCodes.Ldarg_1)
      methodIL.Emit(OpCodes.Stfld, greetingField)
      methodIL.Emit(OpCodes.Ret)
      myTypeBuilder.CreateType()
   End Sub

   Public ReadOnly Property MyAssembly() As AssemblyBuilder
      Get
         Return Me.myAssemblyBuilder
      End Get
   End Property
End Class

Public Class TestClass
   <PermissionSetAttribute(SecurityAction.Demand, Name:="FullTrust")> _
   Public Shared Sub Main()
      Dim myCodeGenerator As New CodeGenerator()
      ' Get the assembly builder for 'myCodeGenerator' object.
      Dim myAssemblyBuilder As AssemblyBuilder = myCodeGenerator.MyAssembly
      ' Get the module builder for the above assembly builder object .
      Dim myModuleBuilder As ModuleBuilder = myAssemblyBuilder.GetDynamicModule("TempModule")
      Console.WriteLine("The fully qualified name and path to this " + _
                        "module is :" + myModuleBuilder.FullyQualifiedName)
      Dim myType As Type = myModuleBuilder.GetType("TempClass")
      Dim myMethodInfo As MethodInfo = myType.GetMethod("MyMethod")
      ' Get the token used to identify the method within this module.
      Dim myMethodToken As MethodToken = myModuleBuilder.GetMethodToken(myMethodInfo)
      Console.WriteLine("Token used to identify the method of 'myType'" + _
                        " within the module is {0:x}", myMethodToken.Token)
      Dim args As Object() = {"Hello."}
      Dim myObject As Object = Activator.CreateInstance(myType, Nothing, Nothing)
      myMethodInfo.Invoke(myObject, args)
   End Sub
End Class

Remarques

Pour obtenir une instance de ModuleBuilder, utilisez la méthode AssemblyBuilder.DefineDynamicModule.

Constructeurs

ModuleBuilder()

Initialise une nouvelle instance de la classe ModuleBuilder.

Propriétés

Assembly	Obtient l’assembly dynamique qui a défini cette instance de ModuleBuilder.
Assembly	Obtient la Assembly appropriée pour cette instance de Module. (Hérité de Module)
CustomAttributes	Obtient une collection qui contient les attributs personnalisés de ce module. (Hérité de Module)
FullyQualifiedName	Obtient une `String` représentant le nom complet et le chemin d’accès à ce module.
MDStreamVersion	Obtient la version du flux de métadonnées.
MDStreamVersion	Obtient la version du flux de métadonnées. (Hérité de Module)
MetadataToken	Obtient un jeton qui identifie le module dynamique actuel dans les métadonnées.
MetadataToken	Obtient un jeton qui identifie le module dans les métadonnées. (Hérité de Module)
ModuleHandle	Obtient un handle pour le module. (Hérité de Module)
ModuleVersionId	Obtient un identificateur unique universel (UUID) qui peut être utilisé pour faire la distinction entre deux versions d’un module.
ModuleVersionId	Obtient un identificateur unique universel (UUID) qui peut être utilisé pour faire la distinction entre deux versions d’un module. (Hérité de Module)
Name	Chaîne qui indique qu’il s’agit d’un module en mémoire.
Name	Obtient une `String` représentant le nom du module avec le chemin d’accès supprimé. (Hérité de Module)
ScopeName	Obtient une chaîne qui représente le nom du module dynamique.
ScopeName	Obtient une chaîne représentant le nom du module. (Hérité de Module)

Méthodes

CreateGlobalFunctions()	Termine les définitions de fonction globale et les définitions de données globales pour ce module dynamique.
CreateGlobalFunctionsCore()	En cas de substitution dans une classe dérivée, termine les définitions de fonction globale et les définitions de données globales pour ce module dynamique.
DefineDocument(String, Guid)	Définit un document pour la source.
DefineDocument(String, Guid, Guid, Guid)	Définit un document pour la source.
DefineDocumentCore(String, Guid)	En cas de substitution dans une classe dérivée, définit un document pour la source.
DefineEnum(String, TypeAttributes, Type)	Définit un type d’énumération qui est un type valeur avec un seul champ non statique appelé `value__` du type spécifié.
DefineEnumCore(String, TypeAttributes, Type)	En cas de substitution dans une classe dérivée, définit un type d’énumération qui est un type valeur avec un seul champ non statique appelé value__ du type spécifié.
DefineGlobalMethod(String, MethodAttributes, CallingConventions, Type, Type[])	Définit une méthode globale avec le nom, les attributs, la convention d’appel, le type de retour et les types de paramètres spécifiés.
DefineGlobalMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Définit une méthode globale avec le nom, les attributs, la convention d’appel, le type de retour, les modificateurs personnalisés pour le type de retour, les types de paramètres et les modificateurs personnalisés pour les types de paramètres.
DefineGlobalMethod(String, MethodAttributes, Type, Type[])	Définit une méthode globale avec le nom, les attributs, le type de retour et les types de paramètres spécifiés.
DefineGlobalMethodCore(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	En cas de substitution dans une classe dérivée, définit une méthode globale portant le nom, les attributs, la convention d’appel, le type de retour, les modificateurs personnalisés pour le type de retour, les types de paramètres et les modificateurs personnalisés pour les types de paramètres.
DefineInitializedData(String, Byte[], FieldAttributes)	Définit un champ de données initialisé dans la section .sdata du fichier exécutable portable (PE).
DefineInitializedDataCore(String, Byte[], FieldAttributes)	En cas de substitution dans une classe dérivée, définit un champ de données initialisé dans la section .sdata du fichier exécutable portable (PE).
DefineManifestResource(String, Stream, ResourceAttributes)	Définit un objet blob (Binary Large Object) qui représente une ressource de manifeste à incorporer dans l’assembly dynamique.
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Définit une méthode `PInvoke` portant le nom spécifié, le nom de la DLL dans laquelle la méthode est définie, les attributs de la méthode, la convention d’appel de la méthode, le type de retour de la méthode, les types des paramètres de la méthode et les indicateurs de `PInvoke`.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Définit une méthode `PInvoke` portant le nom spécifié, le nom de la DLL dans laquelle la méthode est définie, les attributs de la méthode, la convention d’appel de la méthode, le type de retour de la méthode, les types des paramètres de la méthode et les indicateurs de `PInvoke`.
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	En cas de substitution dans une classe dérivée, définit une méthode `PInvoke`.
DefineResource(String, String)	Définit la ressource incorporée managée nommée à stocker dans ce module.
DefineResource(String, String, ResourceAttributes)	Définit la ressource incorporée managée nommée avec les attributs donnés à stocker dans ce module.
DefineType(String)	Construit une `TypeBuilder` pour un type privé portant le nom spécifié dans ce module.
DefineType(String, TypeAttributes)	Construit un `TypeBuilder` en fonction du nom de type et des attributs de type.
DefineType(String, TypeAttributes, Type)	Construit un `TypeBuilder` nom de type donné, ses attributs et le type étendu par le type défini.
DefineType(String, TypeAttributes, Type, Int32)	Construit un `TypeBuilder` en fonction du nom de type, des attributs, du type étendu par le type défini et de la taille totale du type.
DefineType(String, TypeAttributes, Type, PackingSize)	Construit un `TypeBuilder` en fonction du nom de type, des attributs, du type étendu par le type défini et de la taille d’emballage du type.
DefineType(String, TypeAttributes, Type, PackingSize, Int32)	Construit une `TypeBuilder` en fonction du nom de type, des attributs, du type étendu par le type défini, de la taille d’emballage du type défini et de la taille totale du type défini.
DefineType(String, TypeAttributes, Type, Type[])	Construit un `TypeBuilder` en fonction du nom de type, des attributs, du type étendu par le type défini et des interfaces que le type défini implémente.
DefineTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)	En cas de substitution dans une classe dérivée, construit un TypeBuilder.
DefineUninitializedData(String, Int32, FieldAttributes)	Définit un champ de données non initialisé dans la section .sdata du fichier exécutable portable (PE).
DefineUninitializedDataCore(String, Int32, FieldAttributes)	En cas de substitution dans une classe dérivée, définit un champ de données non initialisé dans la section .sdata du fichier exécutable portable (PE).
DefineUnmanagedResource(Byte[])	Définit une ressource incorporée non managée en fonction d’un objet blob (binary large object) opaque d’octets.
DefineUnmanagedResource(String)	Définit une ressource non managée en fonction du nom du fichier de ressources Win32.
Equals(Object)	Retourne une valeur qui indique si cette instance est égale à l’objet spécifié.
Equals(Object)	Détermine si ce module et l’objet spécifié sont égaux. (Hérité de Module)
FindTypes(TypeFilter, Object)	Retourne un tableau de classes acceptées par le filtre et les critères de filtre donnés. (Hérité de Module)
GetArrayMethod(Type, String, CallingConventions, Type, Type[])	Retourne la méthode nommée sur une classe de tableau.
GetArrayMethodCore(Type, String, CallingConventions, Type, Type[])	En cas de substitution dans une classe dérivée, retourne la méthode nommée sur une classe de tableau.
GetArrayMethodToken(Type, String, CallingConventions, Type, Type[])	Retourne le jeton de la méthode nommée sur une classe de tableau.
GetConstructorToken(ConstructorInfo)	Retourne le jeton utilisé pour identifier le constructeur spécifié dans ce module.
GetConstructorToken(ConstructorInfo, IEnumerable<Type>)	Retourne le jeton utilisé pour identifier le constructeur qui a les attributs et les types de paramètres spécifiés dans ce module.
GetCustomAttributes(Boolean)	Retourne tous les attributs personnalisés qui ont été appliqués au ModuleBuilderactuel .
GetCustomAttributes(Boolean)	Retourne tous les attributs personnalisés. (Hérité de Module)
GetCustomAttributes(Type, Boolean)	Retourne tous les attributs personnalisés qui ont été appliqués au ModuleBuilderactuel et qui dérivent d’un type d’attribut spécifié.
GetCustomAttributes(Type, Boolean)	Obtient des attributs personnalisés du type spécifié. (Hérité de Module)
GetCustomAttributesData()	Retourne des informations sur les attributs qui ont été appliqués au ModuleBuilderactuel, exprimées sous forme d’objets CustomAttributeData.
GetCustomAttributesData()	Retourne une liste d’objets CustomAttributeData pour le module actuel, qui peuvent être utilisés dans le contexte de réflexion uniquement. (Hérité de Module)
GetField(String)	Retourne un champ portant le nom spécifié. (Hérité de Module)
GetField(String, BindingFlags)	Retourne un champ au niveau du module, défini dans la région .sdata du fichier exécutable portable (PE), qui a le nom et les attributs de liaison spécifiés.
GetField(String, BindingFlags)	Retourne un champ dont le nom et les attributs de liaison spécifiés sont spécifiés. (Hérité de Module)
GetFieldMetadataToken(FieldInfo)	En cas de substitution dans une classe dérivée, retourne le jeton de métadonnées pour la FieldInfo donnée par rapport au module.
GetFields()	Retourne les champs globaux définis sur le module. (Hérité de Module)
GetFields(BindingFlags)	Retourne tous les champs définis dans la région .sdata du fichier exécutable portable (PE) qui correspondent aux indicateurs de liaison spécifiés.
GetFields(BindingFlags)	Retourne les champs globaux définis sur le module qui correspondent aux indicateurs de liaison spécifiés. (Hérité de Module)
GetFieldToken(FieldInfo)	Retourne le jeton utilisé pour identifier le champ spécifié dans ce module.
GetHashCode()	Retourne le code de hachage pour cette instance.
GetHashCode()	Retourne le code de hachage pour cette instance. (Hérité de Module)
GetMethod(String)	Retourne une méthode portant le nom spécifié. (Hérité de Module)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Retourne une méthode portant le nom spécifié, les informations de liaison, la convention d’appel et les types de paramètres et les modificateurs. (Hérité de Module)
GetMethod(String, Type[])	Retourne une méthode ayant le nom et les types de paramètres spécifiés. (Hérité de Module)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Retourne la méthode au niveau du module qui correspond aux critères spécifiés.
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Retourne l’implémentation de la méthode conformément aux critères spécifiés. (Hérité de Module)
GetMethodMetadataToken(ConstructorInfo)	En cas de substitution dans une classe dérivée, retourne le jeton de métadonnées pour la ConstructorInfo donnée par rapport au module.
GetMethodMetadataToken(MethodInfo)	En cas de substitution dans une classe dérivée, retourne le jeton de métadonnées pour la MethodInfo donnée par rapport au module.
GetMethods()	Retourne les méthodes globales définies sur le module. (Hérité de Module)
GetMethods(BindingFlags)	Retourne toutes les méthodes qui ont été définies au niveau du module pour le ModuleBuilderactuel et qui correspondent aux indicateurs de liaison spécifiés.
GetMethods(BindingFlags)	Retourne les méthodes globales définies sur le module qui correspondent aux indicateurs de liaison spécifiés. (Hérité de Module)
GetMethodToken(MethodInfo)	Retourne le jeton utilisé pour identifier la méthode spécifiée dans ce module.
GetMethodToken(MethodInfo, IEnumerable<Type>)	Retourne le jeton utilisé pour identifier la méthode qui a les attributs et les types de paramètres spécifiés dans ce module.
GetObjectData(SerializationInfo, StreamingContext)	Obsolète. Fournit une implémentation ISerializable pour les objets sérialisés. (Hérité de Module)
GetPEKind(PortableExecutableKinds, ImageFileMachine)	Obtient une paire de valeurs indiquant la nature du code dans un module et la plateforme ciblée par le module.
GetPEKind(PortableExecutableKinds, ImageFileMachine)	Obtient une paire de valeurs indiquant la nature du code dans un module et la plateforme ciblée par le module. (Hérité de Module)
GetSignatureMetadataToken(SignatureHelper)	En cas de substitution dans une classe dérivée, retourne le jeton de métadonnées pour la SignatureHelper donnée par rapport au module.
GetSignatureToken(Byte[], Int32)	Définit un jeton pour la signature qui a le tableau de caractères et la longueur de signature spécifiés.
GetSignatureToken(SignatureHelper)	Définit un jeton pour la signature définie par le SignatureHelperspécifié.
GetSignerCertificate()	Retourne un objet X509Certificate correspondant au certificat inclus dans la signature Authenticode de l’assembly auquel appartient ce module. Si l’assembly n’a pas été signé Authenticode, `null` est retourné.
GetSignerCertificate()	Retourne un objet `X509Certificate` correspondant au certificat inclus dans la signature Authenticode de l’assembly auquel appartient ce module. Si l’assembly n’a pas été signé Authenticode, `null` est retourné. (Hérité de Module)
GetStringConstant(String)	Retourne le jeton de la chaîne donnée dans le pool de constantes du module.
GetStringMetadataToken(String)	En cas de substitution dans une classe dérivée, retourne le jeton de métadonnées pour la constante String donnée par rapport au module.
GetSymWriter()	Retourne l’enregistreur de symboles associé à ce module dynamique.
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
GetType(String)	Obtient le type nommé défini dans le module.
GetType(String)	Retourne le type spécifié, effectuant une recherche sensible à la casse. (Hérité de Module)
GetType(String, Boolean)	Obtient le type nommé défini dans le module, en ignorant éventuellement le cas du nom du type.
GetType(String, Boolean)	Retourne le type spécifié, en recherchant le module avec la sensibilité de casse spécifiée. (Hérité de Module)
GetType(String, Boolean, Boolean)	Obtient le type nommé défini dans le module, en ignorant éventuellement le cas du nom du type. Lève éventuellement une exception si le type est introuvable.
GetType(String, Boolean, Boolean)	Retourne le type spécifié, en spécifiant s’il faut effectuer une recherche sensible à la casse du module et s’il faut lever une exception si le type est introuvable. (Hérité de Module)
GetTypeMetadataToken(Type)	En cas de substitution dans une classe dérivée, retourne le jeton de métadonnées pour la Type donnée par rapport au module.
GetTypes()	Retourne toutes les classes définies dans ce module.
GetTypes()	Retourne tous les types définis dans ce module. (Hérité de Module)
GetTypeToken(String)	Retourne le jeton utilisé pour identifier le type avec le nom spécifié.
GetTypeToken(Type)	Retourne le jeton utilisé pour identifier le type spécifié dans ce module.
IsDefined(Type, Boolean)	Retourne une valeur qui indique si le type d’attribut spécifié a été appliqué à ce module.
IsDefined(Type, Boolean)	Retourne une valeur qui indique si le type d’attribut spécifié a été appliqué à ce module. (Hérité de Module)
IsResource()	Obtient une valeur indiquant si l’objet est une ressource.
IsResource()	Obtient une valeur indiquant si l’objet est une ressource. (Hérité de Module)
IsTransient()	Retourne une valeur qui indique si ce module dynamique est temporaire.
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
ResolveField(Int32)	Retourne le champ identifié par le jeton de métadonnées spécifié. (Hérité de Module)
ResolveField(Int32, Type[], Type[])	Retourne le champ identifié par le jeton de métadonnées spécifié, dans le contexte défini par les paramètres de type générique spécifiés.
ResolveField(Int32, Type[], Type[])	Retourne le champ identifié par le jeton de métadonnées spécifié, dans le contexte défini par les paramètres de type générique spécifiés. (Hérité de Module)
ResolveMember(Int32)	Retourne le type ou le membre identifié par le jeton de métadonnées spécifié. (Hérité de Module)
ResolveMember(Int32, Type[], Type[])	Retourne le type ou le membre identifié par le jeton de métadonnées spécifié, dans le contexte défini par les paramètres de type générique spécifiés.
ResolveMember(Int32, Type[], Type[])	Retourne le type ou le membre identifié par le jeton de métadonnées spécifié, dans le contexte défini par les paramètres de type générique spécifiés. (Hérité de Module)
ResolveMethod(Int32)	Retourne la méthode ou le constructeur identifié par le jeton de métadonnées spécifié. (Hérité de Module)
ResolveMethod(Int32, Type[], Type[])	Retourne la méthode ou le constructeur identifié par le jeton de métadonnées spécifié, dans le contexte défini par les paramètres de type générique spécifiés.
ResolveMethod(Int32, Type[], Type[])	Retourne la méthode ou le constructeur identifié par le jeton de métadonnées spécifié, dans le contexte défini par les paramètres de type générique spécifiés. (Hérité de Module)
ResolveSignature(Int32)	Retourne l’objet blob de signature identifié par un jeton de métadonnées.
ResolveSignature(Int32)	Retourne l’objet blob de signature identifié par un jeton de métadonnées. (Hérité de Module)
ResolveString(Int32)	Retourne la chaîne identifiée par le jeton de métadonnées spécifié.
ResolveString(Int32)	Retourne la chaîne identifiée par le jeton de métadonnées spécifié. (Hérité de Module)
ResolveType(Int32)	Retourne le type identifié par le jeton de métadonnées spécifié. (Hérité de Module)
ResolveType(Int32, Type[], Type[])	Retourne le type identifié par le jeton de métadonnées spécifié, dans le contexte défini par les paramètres de type générique spécifiés.
ResolveType(Int32, Type[], Type[])	Retourne le type identifié par le jeton de métadonnées spécifié, dans le contexte défini par les paramètres de type générique spécifiés. (Hérité de Module)
SetCustomAttribute(ConstructorInfo, Byte[])	Applique un attribut personnalisé à ce module à l’aide d’un objet blob (Binary Large Object) spécifié qui représente l’attribut.
SetCustomAttribute(CustomAttributeBuilder)	Applique un attribut personnalisé à ce module à l’aide d’un générateur d’attributs personnalisé.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	En cas de substitution dans une classe dérivée, définit un attribut personnalisé sur cet assembly.
SetSymCustomAttribute(String, Byte[])	Cette méthode ne fait rien.
SetUserEntryPoint(MethodInfo)	Définit le point d’entrée utilisateur.
ToString()	Retourne le nom du module. (Hérité de Module)

Implémentations d’interfaces explicites

_Module.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappe un ensemble de noms à un ensemble correspondant d’identificateurs de répartition. (Hérité de Module)
_Module.GetTypeInfo(UInt32, UInt32, IntPtr)	Récupère les informations de type d’un objet, qui peuvent ensuite être utilisées pour obtenir les informations de type d’une interface. (Hérité de Module)
_Module.GetTypeInfoCount(UInt32)	Récupère le nombre d’interfaces d’informations de type fournies par un objet (0 ou 1). (Hérité de Module)
_Module.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Fournit l’accès aux propriétés et méthodes exposées par un objet. (Hérité de Module)
_ModuleBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Pour obtenir une description de ce membre, consultez GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr).
_ModuleBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)	Pour obtenir une description de ce membre, consultez GetTypeInfo(UInt32, UInt32, IntPtr).
_ModuleBuilder.GetTypeInfoCount(UInt32)	Pour obtenir une description de ce membre, consultez GetTypeInfoCount(UInt32).
_ModuleBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Pour obtenir une description de ce membre, consultez Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr).
ICustomAttributeProvider.GetCustomAttributes(Boolean)	Retourne un tableau de tous les attributs personnalisés définis sur ce membre, à l’exclusion des attributs nommés ou d’un tableau vide s’il n’existe aucun attribut personnalisé. (Hérité de Module)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)	Retourne un tableau d’attributs personnalisés définis sur ce membre, identifiés par type ou un tableau vide s’il n’existe aucun attribut personnalisé de ce type. (Hérité de Module)
ICustomAttributeProvider.IsDefined(Type, Boolean)	Indique si une ou plusieurs instances de `attributeType` sont définies sur ce membre. (Hérité de Module)

Méthodes d’extension

GetCustomAttribute(Module, Type)	Récupère un attribut personnalisé d’un type spécifié appliqué à un module spécifié.
GetCustomAttribute<T>(Module)	Récupère un attribut personnalisé d’un type spécifié appliqué à un module spécifié.
GetCustomAttributes(Module)	Récupère une collection d’attributs personnalisés appliqués à un module spécifié.
GetCustomAttributes(Module, Type)	Récupère une collection d’attributs personnalisés d’un type spécifié qui sont appliqués à un module spécifié.
GetCustomAttributes<T>(Module)	Récupère une collection d’attributs personnalisés d’un type spécifié qui sont appliqués à un module spécifié.
IsDefined(Module, Type)	Indique si les attributs personnalisés d’un type spécifié sont appliqués à un module spécifié.
GetModuleVersionId(Module)	Définit et représente un module dans un assembly dynamique.
HasModuleVersionId(Module)	Définit et représente un module dans un assembly dynamique.

S’applique à

Partager via