ModuleBuilder Clase

Definición

Espacio de nombres:

System.Reflection.Emit

Ensamblado:

System.Reflection.Emit.dll

Source:

ModuleBuilder.cs

Define y representa un módulo en un ensamblado dinámico.

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

Herencia

Object

Module

ModuleBuilder

Ejemplos

En el ejemplo de código siguiente se muestra el uso de ModuleBuilder para crear un módulo dinámico. Tenga en cuenta que ModuleBuilder se crea llamando a DefineDynamicModule en , en AssemblyBuilderlugar de a través de un constructor.

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

Comentarios

Para obtener una instancia de ModuleBuilder, use el AssemblyBuilder.DefineDynamicModule método .

Constructores

ModuleBuilder()

Inicializa una nueva instancia de la clase ModuleBuilder.

Propiedades

Assembly	Obtiene el ensamblado dinámico que definió esta instancia de ModuleBuilder.
CustomAttributes	Obtiene una colección que contiene los atributos personalizados de este módulo. (Heredado de Module)
FullyQualifiedName	Obtiene un valor de tipo String que representa el nombre completo de este módulo y su ruta de acceso.
MDStreamVersion	Obtiene la versión del flujo de metadatos.
MetadataToken	Obtiene un token que identifica el módulo dinámico actual en los metadatos.
ModuleHandle	Obtiene un identificador para el módulo. (Heredado de Module)
ModuleVersionId	Obtiene un identificador único universal (UUID) que puede utilizarse para distinguir entre dos versiones de un módulo.
Name	Cadena que indica que se trata de un módulo en memoria.
ScopeName	Obtiene una cadena que representa el nombre del módulo dinámico.

Métodos

CreateGlobalFunctions()	Finaliza las definiciones de funciones globales y las definiciones de datos globales para este módulo dinámico.
CreateGlobalFunctionsCore()	Cuando se invalida en una clase derivada, completa las definiciones de funciones globales y las definiciones de datos globales para este módulo dinámico.
DefineEnum(String, TypeAttributes, Type)	Define un tipo de enumeración que consiste en un tipo de valor con un único campo no estático denominado value__ del tipo especificado.
DefineEnumCore(String, TypeAttributes, Type)	Cuando se reemplaza en una clase derivada, define un tipo de enumeración que es un tipo de valor con un único campo no estático denominado value__ del tipo especificado.
DefineGlobalMethod(String, MethodAttributes, CallingConventions, Type, Type[])	Define un método global con el nombre, los atributos, la convención de llamada, el tipo de valor devuelto y los tipos de parámetro especificados.
DefineGlobalMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Define un método global con el nombre, los atributos, la convención de llamada, el tipo de valor devuelto, los modificadores personalizados del tipo de valor devuelto, los tipos de parámetro y los modificadores personalizados de los tipos de parámetro que se hayan especificado.
DefineGlobalMethod(String, MethodAttributes, Type, Type[])	Define un método global con el nombre, los atributos, el tipo de valor devuelto y los tipos de parámetro especificados.
DefineGlobalMethodCore(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Cuando se reemplaza en una clase derivada, define un método global con el nombre, los atributos, la convención de llamada, el tipo de valor devuelto, los modificadores personalizados para el tipo de valor devuelto, los tipos de parámetro y los modificadores personalizados para los tipos de parámetro.
DefineInitializedData(String, Byte[], FieldAttributes)	Define un campo de datos inicializado en la sección .sdata del archivo portable ejecutable (PE).
DefineInitializedDataCore(String, Byte[], FieldAttributes)	Cuando se reemplaza en una clase derivada, define un campo de datos inicializado en la sección .sdata del archivo ejecutable portátil (PE).
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Define un método PInvoke con el nombre especificado, el nombre de la DLL en la que se define el método, los atributos del método, la convención de llamada del método, el tipo de valor devuelto del método, los tipos de los parámetros del método y las marcas de PInvoke.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Define un método PInvoke con el nombre especificado, el nombre de la DLL en la que se define el método, los atributos del método, la convención de llamada del método, el tipo de valor devuelto del método, los tipos de los parámetros del método y las marcas de PInvoke.
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Cuando se invalida en una clase derivada, define un PInvoke método .
DefineType(String)	Crea un TypeBuilder para un tipo privado con el nombre especificado en este módulo.
DefineType(String, TypeAttributes)	Construye un TypeBuilder a partir del nombre de tipo y los atributos de tipo especificados.
DefineType(String, TypeAttributes, Type)	Construye un TypeBuilder a partir del nombre de tipo, sus atributos y el tipo que extiende el tipo definido.
DefineType(String, TypeAttributes, Type, Int32)	Construye un TypeBuilder a partir del nombre de tipo, los atributos, el tipo que extiende el tipo definido y el tamaño total del tipo.
DefineType(String, TypeAttributes, Type, PackingSize)	Construye un TypeBuilder a partir del nombre de tipo, los atributos, el tipo que extiende el tipo definido y el tamaño de empaquetado del tipo.
DefineType(String, TypeAttributes, Type, PackingSize, Int32)	Construye un TypeBuilder a partir del nombre de tipo, los atributos, el tipo que extiende el tipo definido, el tamaño de empaquetado del tipo definido y el tamaño total del tipo definido.
DefineType(String, TypeAttributes, Type, Type[])	Construye un TypeBuilder a partir del nombre de tipo, los atributos, el tipo que extiende el tipo definido y las interfaces que implementa el tipo definido.
DefineTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)	Cuando se invalida en una clase derivada, construye un TypeBuilder.
DefineUninitializedData(String, Int32, FieldAttributes)	Define un campo de datos sin inicializar en la sección .sdata del archivo portable ejecutable (PE).
DefineUninitializedDataCore(String, Int32, FieldAttributes)	Cuando se reemplaza en una clase derivada, define un campo de datos sin inicializar en la sección .sdata del archivo ejecutable portátil (PE).
Equals(Object)	Devuelve un valor que indica si esta instancia es igual al objeto especificado.
FindTypes(TypeFilter, Object)	Devuelve una matriz de las clases aceptadas por el filtro y los criterios de filtro dados. (Heredado de Module)
GetArrayMethod(Type, String, CallingConventions, Type, Type[])	Devuelve el método con nombre en una clase de matriz.
GetArrayMethodCore(Type, String, CallingConventions, Type, Type[])	Cuando se invalida en una clase derivada, devuelve el método con nombre en una clase de matriz.
GetCustomAttributes(Boolean)	Devuelve todos los atributos personalizados que se aplicaron al ModuleBuilder actual.
GetCustomAttributes(Type, Boolean)	Devuelve todos los atributos personalizados que se aplicaron al ModuleBuilder actual y que derivan de un tipo de atributo especificado.
GetCustomAttributesData()	Devuelve información sobre los atributos que se han aplicado al ModuleBuilder actual, expresado como objetos CustomAttributeData.
GetField(String)	Devuelve un campo que tiene el nombre especificado. (Heredado de Module)
GetField(String, BindingFlags)	Devuelve un campo de nivel de módulo, definido en la región .sdata del archivo portable ejecutable (PE), que tiene el nombre y los atributos de enlace especificados.
GetFieldMetadataToken(FieldInfo)	Cuando se invalida en una clase derivada, devuelve el token de metadatos para el especificado FieldInfo en relación con el módulo.
GetFields()	Devuelve los campos globales definidos en el módulo. (Heredado de Module)
GetFields(BindingFlags)	Devuelve todos los campos definidos en la región .sdata del archivo portable ejecutable (PE) que coinciden con las marcas de enlace especificadas.
GetHashCode()	Devuelve el código hash de esta instancia.
GetMethod(String)	Devuelve un método que tiene el nombre especificado. (Heredado de Module)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Devuelve un método con el nombre especificado, información de enlace, convención de llamada y tipos de parámetros y modificadores. (Heredado de Module)
GetMethod(String, Type[])	Devuelve un método con los tipos de parámetro y nombre especificados. (Heredado de Module)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Devuelve el método de nivel de módulo que coincide con los criterios especificados.
GetMethodMetadataToken(ConstructorInfo)	Cuando se invalida en una clase derivada, devuelve el token de metadatos para el especificado ConstructorInfo en relación con el módulo.
GetMethodMetadataToken(MethodInfo)	Cuando se invalida en una clase derivada, devuelve el token de metadatos para el especificado MethodInfo en relación con el módulo.
GetMethods()	Devuelve los métodos globales definidos en el módulo. (Heredado de Module)
GetMethods(BindingFlags)	Devuelve todos los métodos definidos en el nivel de módulo para la clase ModuleBuilder actual y que coinciden con las marcas de enlace especificadas.
GetObjectData(SerializationInfo, StreamingContext)	Obsoletos. Proporciona una implementación de ISerializable para objetos serializados. (Heredado de Module)
GetPEKind(PortableExecutableKinds, ImageFileMachine)	Obtiene un par de valores que indican la naturaleza del código en un módulo y la plataforma de destino del módulo.
GetSignatureMetadataToken(SignatureHelper)	Cuando se invalida en una clase derivada, devuelve el token de metadatos para el especificado SignatureHelper en relación con el módulo.
GetSignerCertificate()	Devuelve un objeto X509Certificate que corresponde al certificado incluido en la firma Authenticode del ensamblado al que pertenece este módulo. Si el ensamblado no se ha firmado mediante Authenticode, se devuelve null. (Heredado de Module)
GetStringMetadataToken(String)	Cuando se reemplaza en una clase derivada, devuelve el token de metadatos de la constante especificada String en relación con el módulo.
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
GetType(String)	Obtiene el tipo con nombre definido en el módulo.
GetType(String, Boolean)	Obtiene el tipo con nombre definido en el módulo, con la opción de pasar por alto el uso de mayúsculas y minúsculas en el nombre de tipo.
GetType(String, Boolean, Boolean)	Obtiene el tipo con nombre definido en el módulo, con la opción de pasar por alto el uso de mayúsculas y minúsculas en el nombre de tipo. De manera opcional, se produce una excepción si no se encuentra el tipo.
GetTypeMetadataToken(Type)	Cuando se invalida en una clase derivada, devuelve el token de metadatos para el especificado Type en relación con el módulo.
GetTypes()	Devuelve todas las clases definidas en este módulo.
IsDefined(Type, Boolean)	Devuelve un valor que indica si el tipo de atributo especificado se ha aplicado a este módulo.
IsResource()	Obtiene un valor que indica si el objeto es un recurso.
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
ResolveField(Int32)	Devuelve el campo identificado por el token de metadatos especificado. (Heredado de Module)
ResolveField(Int32, Type[], Type[])	Devuelve el campo identificado por el token de metadatos especificado, en el contexto definido por los parámetros de tipo genérico especificados.
ResolveMember(Int32)	Devuelve el tipo o integrante identificado por el token de metadatos especificado. (Heredado de Module)
ResolveMember(Int32, Type[], Type[])	Devuelve el tipo o miembro identificado por el token de metadatos especificado, en el contexto definido por los parámetros de tipo genérico especificados.
ResolveMethod(Int32)	Devuelve el método o constructor identificado por el token de metadatos especificado. (Heredado de Module)
ResolveMethod(Int32, Type[], Type[])	Devuelve el método o constructor identificado por el token de metadatos especificado, en el contexto definido por los parámetros de tipo genérico especificados.
ResolveSignature(Int32)	Devuelve el objeto binario de firma identificado por un token de metadatos.
ResolveString(Int32)	Devuelve la cadena identificada por el token de metadatos especificado.
ResolveType(Int32)	Devuelve el tipo identificado por el token de metadatos especificado. (Heredado de Module)
ResolveType(Int32, Type[], Type[])	Devuelve el campo identificado por el token de metadatos especificado, en el contexto definido por los parámetros de tipo genérico especificados.
SetCustomAttribute(ConstructorInfo, Byte[])	Aplica un atributo personalizado a este módulo utilizando el objeto binario grande (BLOB) especificado que representa el atributo.
SetCustomAttribute(CustomAttributeBuilder)	Aplica un atributo personalizado a este módulo utilizando un generador de atributos personalizados.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Cuando se reemplaza en una clase derivada, establece un atributo personalizado en este ensamblado.
ToString()	Devuelve el nombre del módulo. (Heredado de Module)

Métodos de extensión

GetCustomAttribute(Module, Type)	Recupera un atributo personalizado de un tipo especificado que se aplica a un módulo concreto.
GetCustomAttribute<T>(Module)	Recupera un atributo personalizado de un tipo especificado que se aplica a un módulo concreto.
GetCustomAttributes(Module)	Recupera una colección de atributos personalizados que se aplican a un módulo especificado.
GetCustomAttributes(Module, Type)	Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un módulo concreto.
GetCustomAttributes<T>(Module)	Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un módulo concreto.
IsDefined(Module, Type)	Indica si se deben aplicar atributos personalizados de un tipo especificado a un módulo especificado.
GetModuleVersionId(Module)	Define y representa un módulo en un ensamblado dinámico.
HasModuleVersionId(Module)	Define y representa un módulo en un ensamblado dinámico.