ModuleBuilder Classe

Definizione

Spazio dei nomi:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.dll

Origine:

ModuleBuilder.cs

Definisce e rappresenta un modulo in un assembly dinamico.

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

Ereditarietà

Object

Module

ModuleBuilder

Esempio

L'esempio di codice seguente illustra l'uso di ModuleBuilder per creare un modulo dinamico. Si noti che ModuleBuilder viene creato chiamando DefineDynamicModule in AssemblyBuilderanziché tramite un costruttore.

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

Commenti

Per ottenere un'istanza di ModuleBuilder, usare il metodo AssemblyBuilder.DefineDynamicModule.

Costruttori

ModuleBuilder()

Inizializza una nuova istanza della classe ModuleBuilder.

Proprietà

Assembly	Ottiene l'assembly dinamico che ha definito questa istanza di ModuleBuilder.
CustomAttributes	Ottiene una raccolta contenente gli attributi personalizzati di questo modulo. (Ereditato da Module)
FullyQualifiedName	Ottiene un String che rappresenta il nome completo e il percorso di questo modulo.
MDStreamVersion	Ottiene la versione del flusso di metadati.
MetadataToken	Ottiene un token che identifica il modulo dinamico corrente nei metadati.
ModuleHandle	Ottiene un handle per il modulo. (Ereditato da Module)
ModuleVersionId	Ottiene un identificatore univoco universale (UUID) che può essere usato per distinguere tra due versioni di un modulo.
Name	Stringa che indica che si tratta di un modulo in memoria.
ScopeName	Ottiene una stringa che rappresenta il nome del modulo dinamico.

Metodi

CreateGlobalFunctions()	Completa le definizioni di funzione globali e le definizioni di dati globali per questo modulo dinamico.
CreateGlobalFunctionsCore()	Quando sottoposto a override in una classe derivata, completa le definizioni di funzione globali e le definizioni di dati globali per questo modulo dinamico.
DefineEnum(String, TypeAttributes, Type)	Definisce un tipo di enumerazione che è un tipo valore con un singolo campo non statico denominato value__ del tipo specificato.
DefineEnumCore(String, TypeAttributes, Type)	Quando sottoposto a override in una classe derivata, definisce un tipo di enumerazione che è un tipo valore con un singolo campo non statico denominato value__ del tipo specificato.
DefineGlobalMethod(String, MethodAttributes, CallingConventions, Type, Type[])	Definisce un metodo globale con il nome, gli attributi, la convenzione di chiamata, il tipo restituito e i tipi di parametro specificati.
DefineGlobalMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Definisce un metodo globale con il nome, gli attributi, la convenzione di chiamata, il tipo restituito, i modificatori personalizzati per il tipo restituito, i tipi di parametro e i modificatori personalizzati per i tipi di parametro.
DefineGlobalMethod(String, MethodAttributes, Type, Type[])	Definisce un metodo globale con il nome, gli attributi, il tipo restituito e i tipi di parametro specificati.
DefineGlobalMethodCore(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Quando sottoposto a override in una classe derivata, definisce un metodo globale con il nome, gli attributi, la convenzione di chiamata, il tipo restituito, i modificatori personalizzati per il tipo restituito, i tipi di parametro e i modificatori personalizzati per i tipi di parametro.
DefineInitializedData(String, Byte[], FieldAttributes)	Definisce un campo dati inizializzato nella sezione sdata del file eseguibile portabile (PE).
DefineInitializedDataCore(String, Byte[], FieldAttributes)	Quando sottoposto a override in una classe derivata, definisce un campo dati inizializzato nella sezione sdata del file eseguibile portabile (PE).
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Definisce un metodo PInvoke con il nome specificato, il nome della DLL in cui è definito il metodo, gli attributi del metodo, la convenzione di chiamata del metodo, il tipo restituito del metodo, i tipi dei parametri del metodo e i flag PInvoke.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Definisce un metodo PInvoke con il nome specificato, il nome della DLL in cui è definito il metodo, gli attributi del metodo, la convenzione di chiamata del metodo, il tipo restituito del metodo, i tipi dei parametri del metodo e i flag PInvoke.
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Quando sottoposto a override in una classe derivata, definisce un metodo PInvoke.
DefineType(String)	Costruisce un TypeBuilder per un tipo privato con il nome specificato in questo modulo.
DefineType(String, TypeAttributes)	Costruisce un TypeBuilder in base al nome del tipo e agli attributi del tipo.
DefineType(String, TypeAttributes, Type)	Costruisce un TypeBuilder nome di tipo specificato, i relativi attributi e il tipo esteso dal tipo definito.
DefineType(String, TypeAttributes, Type, Int32)	Costruisce un TypeBuilder in base al nome del tipo, agli attributi, al tipo esteso dal tipo definito e alla dimensione totale del tipo.
DefineType(String, TypeAttributes, Type, PackingSize)	Costruisce un TypeBuilder in base al nome del tipo, agli attributi, al tipo esteso dal tipo definito e alle dimensioni di compressione del tipo.
DefineType(String, TypeAttributes, Type, PackingSize, Int32)	Costruisce un TypeBuilder in base al nome del tipo, agli attributi, al tipo esteso dal tipo definito, alle dimensioni di compressione del tipo definito e alle dimensioni totali del tipo definito.
DefineType(String, TypeAttributes, Type, Type[])	Costruisce un TypeBuilder in base al nome del tipo, agli attributi, al tipo esteso dal tipo definito e alle interfacce implementate dal tipo definito.
DefineTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)	Quando sottoposto a override in una classe derivata, costruisce un TypeBuilder.
DefineUninitializedData(String, Int32, FieldAttributes)	Definisce un campo dati non inizializzato nella sezione sdata del file eseguibile portabile (PE).
DefineUninitializedDataCore(String, Int32, FieldAttributes)	Quando sottoposto a override in una classe derivata, definisce un campo dati non inizializzato nella sezione sdata del file eseguibile portabile (PE).
Equals(Object)	Restituisce un valore che indica se questa istanza è uguale all'oggetto specificato.
FindTypes(TypeFilter, Object)	Restituisce una matrice di classi accettate dal filtro e dai criteri di filtro specificati. (Ereditato da Module)
GetArrayMethod(Type, String, CallingConventions, Type, Type[])	Restituisce il metodo denominato in una classe di matrice.
GetArrayMethodCore(Type, String, CallingConventions, Type, Type[])	Quando sottoposto a override in una classe derivata, restituisce il metodo denominato in una classe di matrice.
GetCustomAttributes(Boolean)	Restituisce tutti gli attributi personalizzati applicati al ModuleBuildercorrente.
GetCustomAttributes(Type, Boolean)	Restituisce tutti gli attributi personalizzati applicati al ModuleBuildercorrente e che derivano da un tipo di attributo specificato.
GetCustomAttributesData()	Restituisce informazioni sugli attributi applicati alla ModuleBuildercorrente, espressa come oggetti CustomAttributeData.
GetField(String)	Restituisce un campo con il nome specificato. (Ereditato da Module)
GetField(String, BindingFlags)	Restituisce un campo a livello di modulo, definito nell'area con estensione sdata del file eseguibile portabile (PE), con il nome e gli attributi di associazione specificati.
GetFieldMetadataToken(FieldInfo)	Quando sottoposto a override in una classe derivata, restituisce il token di metadati per il FieldInfo specificato rispetto al modulo.
GetFields()	Restituisce i campi globali definiti nel modulo. (Ereditato da Module)
GetFields(BindingFlags)	Restituisce tutti i campi definiti nell'area con estensione sdata del file eseguibile portabile (PE) che corrispondono ai flag di associazione specificati.
GetHashCode()	Restituisce il codice hash per questa istanza.
GetMethod(String)	Restituisce un metodo con il nome specificato. (Ereditato da Module)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Restituisce un metodo con il nome, le informazioni di associazione, la convenzione di chiamata e i tipi di parametro e i modificatori specificati. (Ereditato da Module)
GetMethod(String, Type[])	Restituisce un metodo con il nome e i tipi di parametro specificati. (Ereditato da Module)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Restituisce il metodo a livello di modulo che corrisponde ai criteri specificati.
GetMethodMetadataToken(ConstructorInfo)	Quando sottoposto a override in una classe derivata, restituisce il token di metadati per il ConstructorInfo specificato rispetto al modulo.
GetMethodMetadataToken(MethodInfo)	Quando sottoposto a override in una classe derivata, restituisce il token di metadati per il MethodInfo specificato rispetto al modulo.
GetMethods()	Restituisce i metodi globali definiti nel modulo. (Ereditato da Module)
GetMethods(BindingFlags)	Restituisce tutti i metodi definiti a livello di modulo per il ModuleBuildercorrente e che corrispondono ai flag di associazione specificati.
GetObjectData(SerializationInfo, StreamingContext)	Obsoleti. Fornisce un'implementazione ISerializable per gli oggetti serializzati. (Ereditato da Module)
GetPEKind(PortableExecutableKinds, ImageFileMachine)	Ottiene una coppia di valori che indicano la natura del codice in un modulo e la piattaforma di destinazione del modulo.
GetSignatureMetadataToken(SignatureHelper)	Quando sottoposto a override in una classe derivata, restituisce il token di metadati per il SignatureHelper specificato rispetto al modulo.
GetSignerCertificate()	Restituisce un oggetto X509Certificate corrispondente al certificato incluso nella firma Authenticode dell'assembly a cui appartiene questo modulo. Se l'assembly non è stato firmato Authenticode, viene restituito null. (Ereditato da Module)
GetStringMetadataToken(String)	Quando sottoposto a override in una classe derivata, restituisce il token di metadati per la costante String specificata rispetto al modulo.
GetType()	Ottiene il Type dell'istanza corrente. (Ereditato da Object)
GetType(String)	Ottiene il tipo denominato definito nel modulo.
GetType(String, Boolean)	Ottiene il tipo denominato definito nel modulo, ignorando facoltativamente il caso del nome del tipo.
GetType(String, Boolean, Boolean)	Ottiene il tipo denominato definito nel modulo, ignorando facoltativamente il caso del nome del tipo. Facoltativamente, genera un'eccezione se il tipo non viene trovato.
GetTypeMetadataToken(Type)	Quando sottoposto a override in una classe derivata, restituisce il token di metadati per il Type specificato rispetto al modulo.
GetTypes()	Restituisce tutte le classi definite all'interno di questo modulo.
IsDefined(Type, Boolean)	Restituisce un valore che indica se il tipo di attributo specificato è stato applicato a questo modulo.
IsResource()	Ottiene un valore che indica se l'oggetto è una risorsa.
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
ResolveField(Int32)	Restituisce il campo identificato dal token di metadati specificato. (Ereditato da Module)
ResolveField(Int32, Type[], Type[])	Restituisce il campo identificato dal token di metadati specificato, nel contesto definito dai parametri di tipo generico specificati.
ResolveMember(Int32)	Restituisce il tipo o il membro identificato dal token di metadati specificato. (Ereditato da Module)
ResolveMember(Int32, Type[], Type[])	Restituisce il tipo o il membro identificato dal token di metadati specificato, nel contesto definito dai parametri di tipo generico specificati.
ResolveMethod(Int32)	Restituisce il metodo o il costruttore identificato dal token di metadati specificato. (Ereditato da Module)
ResolveMethod(Int32, Type[], Type[])	Restituisce il metodo o il costruttore identificato dal token di metadati specificato, nel contesto definito dai parametri di tipo generico specificati.
ResolveSignature(Int32)	Restituisce il BLOB di firma identificato da un token di metadati.
ResolveString(Int32)	Restituisce la stringa identificata dal token di metadati specificato.
ResolveType(Int32)	Restituisce il tipo identificato dal token di metadati specificato. (Ereditato da Module)
ResolveType(Int32, Type[], Type[])	Restituisce il tipo identificato dal token di metadati specificato, nel contesto definito dai parametri di tipo generico specificati.
SetCustomAttribute(ConstructorInfo, Byte[])	Applica un attributo personalizzato a questo modulo usando un oggetto BLOB (Binary Large Object) specificato che rappresenta l'attributo .
SetCustomAttribute(CustomAttributeBuilder)	Applica un attributo personalizzato a questo modulo usando un generatore di attributi personalizzato.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	In caso di override in una classe derivata, imposta un attributo personalizzato su questo assembly.
ToString()	Restituisce il nome del modulo. (Ereditato da Module)

Metodi di estensione

GetCustomAttribute(Module, Type)	Recupera un attributo personalizzato di un tipo specificato applicato a un modulo specificato.
GetCustomAttribute<T>(Module)	Recupera un attributo personalizzato di un tipo specificato applicato a un modulo specificato.
GetCustomAttributes(Module)	Recupera una raccolta di attributi personalizzati applicati a un modulo specificato.
GetCustomAttributes(Module, Type)	Recupera una raccolta di attributi personalizzati di un tipo specificato applicato a un modulo specificato.
GetCustomAttributes<T>(Module)	Recupera una raccolta di attributi personalizzati di un tipo specificato applicato a un modulo specificato.
IsDefined(Module, Type)	Indica se gli attributi personalizzati di un tipo specificato vengono applicati a un modulo specificato.
GetModuleVersionId(Module)	Definisce e rappresenta un modulo in un assembly dinamico.
HasModuleVersionId(Module)	Definisce e rappresenta un modulo in un assembly dinamico.