ModuleBuilder Classe

Definizione

Spazio dei nomi:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.dll

Source:

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

Nell'esempio di codice seguente viene illustrato l'uso di ModuleBuilder per creare un modulo dinamico. Si noti che ModuleBuilder viene creato chiamando DefineDynamicModule in AssemblyBuilder, anziché 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 AssemblyBuilder.DefineDynamicModule metodo .

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 che contiene gli attributi personalizzati del modulo. (Ereditato da Module)
FullyQualifiedName	Ottiene un oggetto String che rappresenta il nome e il percorso completi del 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 nuovo UUID (Universally Unique Identifier) che può essere usato per la distinzione tra due versioni di un modulo.
Name	Stringa che indica che questo è un modulo in memoria.
ScopeName	Ottiene una stringa che rappresenta il nome del modulo dinamico.

Metodi

CreateGlobalFunctions()	Completa le definizioni delle funzioni globali e quelle dei dati globali per il modulo dinamico.
CreateGlobalFunctionsCore()	Quando sottoposto a override in una classe derivata, completa le definizioni di funzioni globali e le definizioni di dati globali per questo modulo dinamico.
DefineEnum(String, TypeAttributes, Type)	Definisce un tipo di enumerazione, ovvero un tipo di valore con un solo 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 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 parametri 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 parametri e i modificatori personalizzati per i tipi di parametri specificati.
DefineGlobalMethod(String, MethodAttributes, Type, Type[])	Definisce un metodo globale con il nome, gli attributi, il tipo restituito e i tipi di parametri 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 specificati, la convenzione chiamante, il tipo restituito, i modificatori personalizzati per il tipo restituito, i tipi di parametri e i modificatori personalizzati per i tipi di parametro.
DefineInitializedData(String, Byte[], FieldAttributes)	Definisce un campo di dati inizializzati nella sezione .sdata del file PE (Portable Executable).
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, il nome del file DLL nel quale viene definito il metodo, gli attributi, la convenzione di chiamata, il tipo restituito, i tipi di parametri e i flag PInvoke del metodo specificati.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Definisce un metodo PInvoke, con il nome, il nome del file DLL nel quale viene definito il metodo, gli attributi, la convenzione di chiamata, il tipo restituito, i tipi di parametri e i flag PInvoke del metodo specificati.
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Quando sottoposto a override in una classe derivata, definisce un PInvoke metodo.
DefineType(String)	Costruisce un oggetto TypeBuilder per un tipo privato con il nome specificato in questo modulo.
DefineType(String, TypeAttributes)	Costruisce un oggetto TypeBuilder, dati il nome e gli attributi del tipo.
DefineType(String, TypeAttributes, Type)	Costruisce un oggetto TypeBuilder, dati il nome del tipo, i relativi attributi e il tipo esteso dal tipo definito.
DefineType(String, TypeAttributes, Type, Int32)	Costruisce un oggetto TypeBuilder, dati il nome del tipo, gli attributi, il tipo esteso dal tipo definito e la dimensione totale del tipo.
DefineType(String, TypeAttributes, Type, PackingSize)	Costruisce un oggetto TypeBuilder, dati il nome del tipo, gli attributi, il tipo esteso dal tipo definito e la dimensione del tipo compresso.
DefineType(String, TypeAttributes, Type, PackingSize, Int32)	Costruisce un oggetto TypeBuilder, dati il nome del tipo, gli attributi, il tipo esteso dal tipo definito e la relativa dimensione compressa e totale.
DefineType(String, TypeAttributes, Type, Type[])	Costruisce un oggetto TypeBuilder, dati il nome del tipo, gli attributi, il tipo esteso dal tipo definito e le interfacce da esso implementate.
DefineTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)	Quando sottoposto a override in una classe derivata, costruisce un TypeBuilderoggetto .
DefineUninitializedData(String, Int32, FieldAttributes)	Definisce un campo di dati non inizializzati nella sezione .sdata del file PE (Portable Executable).
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 specificato e dai criteri di filtro. (Ereditato da Module)
GetArrayMethod(Type, String, CallingConventions, Type, Type[])	Restituisce il metodo denominato su una classe di matrici.
GetArrayMethodCore(Type, String, CallingConventions, Type, Type[])	Quando sottoposto a override in una classe derivata, restituisce il metodo denominato in una classe array.
GetCustomAttributes(Boolean)	Restituisce tutti gli attributi personalizzati applicati all'oggetto ModuleBuilder corrente.
GetCustomAttributes(Type, Boolean)	Restituisce tutti gli attributi personalizzati applicati all'oggetto ModuleBuilder corrente e che derivano da un tipo di attributo specificato.
GetCustomAttributesData()	Restituisce informazioni sugli attributi applicati all'oggetto ModuleBuilder corrente, espresse sotto forma di oggetti CustomAttributeData.
GetField(String)	Restituisce un campo con il nome specificato. (Ereditato da Module)
GetField(String, BindingFlags)	Restituisce un campo del livello di modulo, definito nell'area .sdata del file eseguibile di tipo PE che dispone del nome specificato e degli attributi di associazione.
GetFieldMetadataToken(FieldInfo)	Quando sottoposto a override in una classe derivata, restituisce il token di metadati per il valore specificato FieldInfo rispetto al modulo.
GetFields()	Restituisce i campi globali definiti nel modulo. (Ereditato da Module)
GetFields(BindingFlags)	Restituisce tutti i campi definiti nell'area .sdata del file eseguibile di tipo PE che corrispondono ai flag di associazione specificati.
GetHashCode()	Restituisce il codice hash per l'istanza.
GetMethod(String)	Restituisce un metodo con il nome specificato. (Ereditato da Module)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Restituisce un metodo con nome, informazioni di associazione, convenzione di chiamata, tipi di parametro e modificatori specificati. (Ereditato da Module)
GetMethod(String, Type[])	Restituisce un metodo che ha il nome e i tipi di parametro specificati. (Ereditato da Module)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Restituisce un 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 valore specificato ConstructorInfo rispetto al modulo.
GetMethodMetadataToken(MethodInfo)	Quando sottoposto a override in una classe derivata, restituisce il token di metadati per il valore specificato MethodInfo rispetto al modulo.
GetMethods()	Restituisce i metodi globali definiti nel modulo. (Ereditato da Module)
GetMethods(BindingFlags)	Restituisce tutti i metodi definiti al livello di modulo per l'oggetto ModuleBuilder corrente, e corrispondenti ai flag di associazione specificati.
GetObjectData(SerializationInfo, StreamingContext)	Obsoleti. Fornisce un'implementazione dell'oggetto ISerializable per gli oggetti serializzati. (Ereditato da Module)
GetPEKind(PortableExecutableKinds, ImageFileMachine)	Ottiene una coppia di valori che indica il tipo di 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 valore specificato SignatureHelper rispetto al modulo.
GetSignerCertificate()	Restituisce un oggetto X509Certificate corrispondente al certificato incluso nella firma Authenticode dell'assembly a cui appartiene il modulo. Se l'assembly non è stato firmato con 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 specificata String rispetto al modulo.
GetType()	Ottiene l'oggetto 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 la combinazione di maiuscole e minuscole del nome del tipo.
GetType(String, Boolean, Boolean)	Ottiene il tipo denominato definito nel modulo, ignorando facoltativamente la combinazione di maiuscole e minuscole del nome del tipo. Genera facoltativamente 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 valore specificato Type rispetto al modulo.
GetTypes()	Restituisce tutte le classi definite all'interno del 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 dell'oggetto Object corrente. (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 della 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 al modulo tramite un oggetto binario di grandi dimensioni (BLOB) specificato che rappresenta l'attributo.
SetCustomAttribute(CustomAttributeBuilder)	Applica un attributo personalizzato al modulo utilizzando un generatore di attributi personalizzati.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Quando sottoposto a 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 una attributo personalizzato di un tipo specificato che viene applicato a un modulo specificato.
GetCustomAttribute<T>(Module)	Recupera una attributo personalizzato di un tipo specificato che viene applicato a un modulo specificato.
GetCustomAttributes(Module)	Recupera una raccolta di attributi personalizzati che vengono applicati a un modulo specificato.
GetCustomAttributes(Module, Type)	Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un modulo specificato.
GetCustomAttributes<T>(Module)	Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un modulo specificato.
IsDefined(Module, Type)	Indica se vengono applicati attributi personalizzati del tipo specificato 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.