ModuleBuilder Classe

Définition

Espace de noms:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.dll

Source:

ModuleBuilder.cs

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

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

public abstract class ModuleBuilder : System.Reflection.Module

type ModuleBuilder = class
    inherit Module

Public MustInherit Class ModuleBuilder
Inherits Module

Héritage

Object

Module

ModuleBuilder

Exemples

L’exemple de code suivant illustre l’utilisation de ModuleBuilder pour créer un module dynamique. Notez que ModuleBuilder est créé en appelant DefineDynamicModule dans AssemblyBuilder, plutôt que par le biais d’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 AssemblyBuilder.DefineDynamicModule méthode .

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.
CustomAttributes	Obtient une collection qui contient les attributs personnalisés de ce module. (Hérité de Module)
FullyQualifiedName	Obtient un String représentant le nom et le chemin d'accès complets de ce module.
MDStreamVersion	Obtient la version de flux des métadonnées.
MetadataToken	Obtient un jeton qui identifie le module dynamique actuel dans les métadonnées.
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.
Name	Chaîne qui indique qu'il s'agit d'un module en mémoire.
ScopeName	Obtient une chaîne qui représente le nom du module dynamique.

Méthodes

CreateGlobalFunctions()	Complète 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.
DefineEnum(String, TypeAttributes, Type)	Définit un type d'énumération qui est un type valeur avec un champ non statique unique 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 à l'aide du nom, des attributs, de la convention d'appel, du type de retour et des types de paramètres spécifiés.
DefineGlobalMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Définit une méthode globale à l'aide du nom, des attributs, de la convention d'appel, du type de retour, des modificateurs personnalisés pour le type de retour, des types de paramètres et des modificateurs personnalisés pour les types de paramètres spécifiés.
DefineGlobalMethod(String, MethodAttributes, Type, Type[])	Définit une méthode globale à l'aide du nom, des attributs, du type de retour et des 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 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.
DefineInitializedData(String, Byte[], FieldAttributes)	Définit un champ de données initialisé dans la section .sdata du fichier exécutable portable.
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).
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Définit une méthode PInvoke à l'aide du nom, du nom de la DLL dans laquelle la méthode a été définie, des attributs de la méthode, de la convention d'appel, du type de retour, des types de paramètres et des indicateurs PInvoke spécifiés.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Définit une méthode PInvoke à l'aide du nom, du nom de la DLL dans laquelle la méthode a été définie, des attributs de la méthode, de la convention d'appel, du type de retour, des types de paramètres et des indicateurs PInvoke spécifiés.
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	En cas de substitution dans une classe dérivée, définit une PInvoke méthode.
DefineType(String)	Construit un TypeBuilder pour un type privé portant le nom spécifié dans ce module.
DefineType(String, TypeAttributes)	Construit un TypeBuilder en fonction du nom et des attributs du type.
DefineType(String, TypeAttributes, Type)	Construit un TypeBuilder en fonction du nom et des attributs du type, ainsi que du type que le type défini étend.
DefineType(String, TypeAttributes, Type, Int32)	Construit un TypeBuilder en fonction du nom et des attributs du type, 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 et des attributs du type, du type étendu par le type défini et de la taille de compactage du type.
DefineType(String, TypeAttributes, Type, PackingSize, Int32)	Construit un TypeBuilder en fonction du nom et des attributs du type, du type étendu par le type défini, de la taille de compactage et de la taille totale du type défini.
DefineType(String, TypeAttributes, Type, Type[])	Construit un TypeBuilder en fonction du nom et des attributs du type, du type étendu par le type défini et de l'interface implémentée par le type défini.
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, Portable Executable).
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).
Equals(Object)	Retourne une valeur qui indique si cette instance est égale à l’objet spécifié.
FindTypes(TypeFilter, Object)	Retourne un tableau de classes acceptées par le filtre donné et les critères de filtre. (Hérité de Module)
GetArrayMethod(Type, String, CallingConventions, Type, Type[])	Retourne la méthode nommée sur une classe Array.
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.
GetCustomAttributes(Boolean)	Retourne tous les attributs personnalisés qui ont été appliqués au ModuleBuilder actuel.
GetCustomAttributes(Type, Boolean)	Retourne tous les attributs personnalisés qui ont été appliqués à l’élément ModuleBuilder actuel et qui dérivent d’un type d’attribut spécifié.
GetCustomAttributesData()	Retourne des informations sur les attributs appliqués au ModuleBuilder actuel, en tant qu'objets CustomAttributeData.
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, Portable Executable) ayant le nom et les attributs de liaison spécifiés.
GetFieldMetadataToken(FieldInfo)	En cas de substitution dans une classe dérivée, retourne le jeton de métadonnées pour le donné FieldInfo 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 liaisons spécifiés.
GetHashCode()	Retourne le code de hachage de cette instance.
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 avec le nom, les informations de liaison, la convention d’appel ainsi que les types et modificateurs de paramètres spécifiés. (Hérité de Module)
GetMethod(String, Type[])	Retourne une méthode avec les types de paramètre et de nom 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.
GetMethodMetadataToken(ConstructorInfo)	En cas de substitution dans une classe dérivée, retourne le jeton de métadonnées pour le donné ConstructorInfo par rapport au module.
GetMethodMetadataToken(MethodInfo)	En cas de substitution dans une classe dérivée, retourne le jeton de métadonnées pour le donné MethodInfo 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 définies au niveau du module pour le ModuleBuilder actuel et qui correspondent aux indicateurs de liaisons spécifiés.
GetObjectData(SerializationInfo, StreamingContext)	Obsolète. Fournit une implémentation de 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.
GetSignatureMetadataToken(SignatureHelper)	En cas de substitution dans une classe dérivée, retourne le jeton de métadonnées pour le donné SignatureHelper par rapport au module.
GetSignerCertificate()	Retourne un objet X509Certificate correspondant au certificat inclus dans la signature Authenticode de l'assembly auquel appartient ce module. Si l'assembly n'est pas signé avec Authenticode, null est retournée. (Hérité de Module)
GetStringMetadataToken(String)	En cas de substitution dans une classe dérivée, retourne le jeton de métadonnées pour la constante donnée String par rapport au module.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
GetType(String)	Obtient le type nommé défini dans le module.
GetType(String, Boolean)	Obtient le type nommé défini dans le module en ignorant éventuellement la casse du nom de type.
GetType(String, Boolean, Boolean)	Obtient le type nommé défini dans le module en ignorant éventuellement la casse du nom de type. Peut lever une exception, si le type est introuvable.
GetTypeMetadataToken(Type)	En cas de substitution dans une classe dérivée, retourne le jeton de métadonnées pour le donné Type par rapport au module.
GetTypes()	Retourne toutes les classes définies dans ce module.
IsDefined(Type, Boolean)	Retourne une valeur qui indique si le type d'attribut spécifié a été appliqué à ce module.
IsResource()	Obtient une valeur indiquant si l'objet est une ressource.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (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.
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.
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.
ResolveSignature(Int32)	Retourne le blob de signature identifié par un jeton de métadonnées.
ResolveString(Int32)	Retourne la chaîne identifiée par le jeton de métadonnées spécifié.
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.
SetCustomAttribute(ConstructorInfo, Byte[])	Applique un attribut personnalisé à ce module à l'aide d'un objet BLOB 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és.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	En cas de substitution dans une classe dérivée, définit un attribut personnalisé sur cet assembly.
ToString()	Retourne le nom du module. (Hérité de Module)

Méthodes d’extension

GetCustomAttribute(Module, Type)	Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un module spécifié.
GetCustomAttribute<T>(Module)	Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un module spécifié.
GetCustomAttributes(Module)	Récupère une collection d'attributs personnalisés qui sont 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 des 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.