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 AssemblyBuilder, en lugar 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 método AssemblyBuilder.DefineDynamicModule.

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 String que representa el nombre completo y la ruta de acceso a este módulo.
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 se puede usar 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()	Completa las definiciones de funciones globales y las definiciones de datos globales de 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 de este módulo dinámico.
DefineEnum(String, TypeAttributes, Type)	Define un tipo de enumeración que es 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 para el tipo de valor devuelto, los tipos de parámetro y los modificadores personalizados para los tipos de parámetro.
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 ejecutable portátil (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 portable (PE).
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Define un método PInvoke con el nombre especificado, el nombre del archivo DLL en el que se define el método, los atributos del método, la convención de llamada del método, el tipo devuelto del método, los tipos de los parámetros del método y las marcas PInvoke.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Define un método PInvoke con el nombre especificado, el nombre del archivo DLL en el que se define el método, los atributos del método, la convención de llamada del método, el tipo devuelto del método, los tipos de los parámetros del método y las marcas PInvoke.
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Cuando se reemplaza en una clase derivada, define un método PInvoke.
DefineType(String)	Construye un TypeBuilder para un tipo privado con el nombre especificado en este módulo.
DefineType(String, TypeAttributes)	Construye un TypeBuilder dado el nombre de tipo y los atributos de tipo.
DefineType(String, TypeAttributes, Type)	Construye un TypeBuilder nombre de tipo determinado, sus atributos y el tipo que extiende el tipo definido.
DefineType(String, TypeAttributes, Type, Int32)	Construye un TypeBuilder dado el 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 dado el 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 dado el 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 dado el 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 reemplaza 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 ejecutable portátil (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 clases aceptadas por los criterios de filtro y filtro especificados. (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 reemplaza en una clase derivada, devuelve el método con nombre en una clase de matriz.
GetCustomAttributes(Boolean)	Devuelve todos los atributos personalizados que se han aplicado al ModuleBuilderactual.
GetCustomAttributes(Type, Boolean)	Devuelve todos los atributos personalizados que se han aplicado al ModuleBuilderactual y que derivan de un tipo de atributo especificado.
GetCustomAttributesData()	Devuelve información sobre los atributos que se han aplicado al ModuleBuilderactual, expresados 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 ejecutable portátil (PE), que tiene el nombre y los atributos de enlace especificados.
GetFieldMetadataToken(FieldInfo)	Cuando se reemplaza en una clase derivada, devuelve el token de metadatos del FieldInfo especificado 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 ejecutable portable (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 que tiene el nombre especificado, la información de enlace, la convención de llamada y los tipos y modificadores de parámetros especificados. (Heredado de Module)
GetMethod(String, Type[])	Devuelve un método que tiene el nombre y los tipos de parámetro 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 reemplaza en una clase derivada, devuelve el token de metadatos del ConstructorInfo especificado en relación con el módulo.
GetMethodMetadataToken(MethodInfo)	Cuando se reemplaza en una clase derivada, devuelve el token de metadatos del MethodInfo especificado 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 el ModuleBuilderactual 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 dirigida por el módulo.
GetSignatureMetadataToken(SignatureHelper)	Cuando se reemplaza en una clase derivada, devuelve el token de metadatos del SignatureHelper especificado en relación con el módulo.
GetSignerCertificate()	Devuelve un objeto X509Certificate correspondiente al certificado incluido en la firma Authenticode del ensamblado al que pertenece este módulo. Si el ensamblado no se ha firmado Authenticode, se devuelve null. (Heredado de Module)
GetStringMetadataToken(String)	Cuando se reemplaza en una clase derivada, devuelve el token de metadatos del String constante especificado 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; opcionalmente, omite el caso del nombre del tipo.
GetType(String, Boolean, Boolean)	Obtiene el tipo con nombre definido en el módulo; opcionalmente, omite el caso del nombre del tipo. Opcionalmente, produce una excepción si no se encuentra el tipo.
GetTypeMetadataToken(Type)	Cuando se reemplaza en una clase derivada, devuelve el token de metadatos del Type especificado 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 Objectactual. (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 miembro 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 blob 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 tipo 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 mediante un objeto binario grande (BLOB) especificado que representa el atributo .
SetCustomAttribute(CustomAttributeBuilder)	Aplica un atributo personalizado a este módulo mediante un generador de atributos personalizado.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Cuando se invalida 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 especificado.
GetCustomAttribute<T>(Module)	Recupera un atributo personalizado de un tipo especificado que se aplica a un módulo especificado.
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 aplica a un módulo especificado.
GetCustomAttributes<T>(Module)	Recupera una colección de atributos personalizados de un tipo especificado que se aplica a un módulo especificado.
IsDefined(Module, Type)	Indica si los atributos personalizados de un tipo especificado se aplican 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.