ModuleBuilder Classe

Definição

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.dll

Origem:

ModuleBuilder.cs

Define e representa um módulo em um assembly 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

Herança

Object

Module

ModuleBuilder

Exemplos

O exemplo de código a seguir demonstra o uso de ModuleBuilder para criar um módulo dinâmico. Observe que o ModuleBuilder é criado chamando DefineDynamicModule em AssemblyBuilder, em vez de por meio de um construtor.

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

Comentários

Para obter uma instância de ModuleBuilder, use o método AssemblyBuilder.DefineDynamicModule.

Construtores

ModuleBuilder()

Inicializa uma nova instância da classe ModuleBuilder.

Propriedades

Assembly	Obtém o assembly dinâmico que definiu essa instância de ModuleBuilder.
CustomAttributes	Obtém uma coleção que contém os atributos personalizados deste módulo. (Herdado de Module)
FullyQualifiedName	Obtém um String que representa o nome totalmente qualificado e o caminho para este módulo.
MDStreamVersion	Obtém a versão do fluxo de metadados.
MetadataToken	Obtém um token que identifica o módulo dinâmico atual em metadados.
ModuleHandle	Obtém um identificador para o módulo. (Herdado de Module)
ModuleVersionId	Obtém um UUID (identificador universal exclusivo) que pode ser usado para distinguir entre duas versões de um módulo.
Name	Uma cadeia de caracteres que indica que este é um módulo na memória.
ScopeName	Obtém uma cadeia de caracteres que representa o nome do módulo dinâmico.

Métodos

CreateGlobalFunctions()	Conclui as definições de função global e as definições de dados globais para este módulo dinâmico.
CreateGlobalFunctionsCore()	Quando substituído em uma classe derivada, conclui as definições de função global e as definições de dados globais para este módulo dinâmico.
DefineEnum(String, TypeAttributes, Type)	Define um tipo de enumeração que é um tipo de valor com um único campo não estático chamado value__ do tipo especificado.
DefineEnumCore(String, TypeAttributes, Type)	Quando substituído em uma classe derivada, define um tipo de enumeração que é um tipo de valor com um único campo não estático chamado value__ do tipo especificado.
DefineGlobalMethod(String, MethodAttributes, CallingConventions, Type, Type[])	Define um método global com o nome, atributos, convenção de chamada, tipo de retorno e tipos de parâmetro especificados.
DefineGlobalMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Define um método global com o nome, atributos, convenção de chamada, tipo de retorno, modificadores personalizados para o tipo de retorno, tipos de parâmetro e modificadores personalizados para os tipos de parâmetro.
DefineGlobalMethod(String, MethodAttributes, Type, Type[])	Define um método global com o nome, atributos, tipo de retorno e tipos de parâmetro especificados.
DefineGlobalMethodCore(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Quando substituído em uma classe derivada, define um método global com o nome, atributos, convenção de chamada, tipo de retorno, modificadores personalizados para o tipo de retorno, tipos de parâmetro e modificadores personalizados para os tipos de parâmetro.
DefineInitializedData(String, Byte[], FieldAttributes)	Define um campo de dados inicializado na seção .sdata do arquivo PE (executável portátil).
DefineInitializedDataCore(String, Byte[], FieldAttributes)	Quando substituído em uma classe derivada, define um campo de dados inicializado na seção .sdata do arquivo PE (executável portátil).
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Define um método PInvoke com o nome especificado, o nome da DLL na qual o método é definido, os atributos do método, a convenção de chamada do método, o tipo de retorno do método, os tipos dos parâmetros do método e os sinalizadores de PInvoke.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Define um método PInvoke com o nome especificado, o nome da DLL na qual o método é definido, os atributos do método, a convenção de chamada do método, o tipo de retorno do método, os tipos dos parâmetros do método e os sinalizadores de PInvoke.
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Quando substituído em uma classe derivada, define um método PInvoke.
DefineType(String)	Constrói um TypeBuilder para um tipo privado com o nome especificado neste módulo.
DefineType(String, TypeAttributes)	Constrói um TypeBuilder dado o nome do tipo e os atributos de tipo.
DefineType(String, TypeAttributes, Type)	Constrói um TypeBuilder determinado nome de tipo, seus atributos e o tipo que o tipo definido estende.
DefineType(String, TypeAttributes, Type, Int32)	Constrói um TypeBuilder dado o nome do tipo, os atributos, o tipo que o tipo definido estende e o tamanho total do tipo.
DefineType(String, TypeAttributes, Type, PackingSize)	Constrói um TypeBuilder dado o nome do tipo, os atributos, o tipo que o tipo definido estende e o tamanho da embalagem do tipo.
DefineType(String, TypeAttributes, Type, PackingSize, Int32)	Constrói um TypeBuilder dado o nome do tipo, atributos, o tipo que o tipo definido estende, o tamanho de empacotamento do tipo definido e o tamanho total do tipo definido.
DefineType(String, TypeAttributes, Type, Type[])	Constrói um TypeBuilder dado o nome do tipo, atributos, o tipo que o tipo definido estende e as interfaces que o tipo definido implementa.
DefineTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)	Quando substituído em uma classe derivada, constrói um TypeBuilder.
DefineUninitializedData(String, Int32, FieldAttributes)	Define um campo de dados não inicializado na seção .sdata do arquivo PE (executável portátil).
DefineUninitializedDataCore(String, Int32, FieldAttributes)	Quando substituído em uma classe derivada, define um campo de dados não inicializado na seção .sdata do arquivo PE (executável portátil).
Equals(Object)	Retorna um valor que indica se essa instância é igual ao objeto especificado.
FindTypes(TypeFilter, Object)	Retorna uma matriz de classes aceitas pelos critérios de filtro e filtro especificados. (Herdado de Module)
GetArrayMethod(Type, String, CallingConventions, Type, Type[])	Retorna o método nomeado em uma classe de matriz.
GetArrayMethodCore(Type, String, CallingConventions, Type, Type[])	Quando substituído em uma classe derivada, retorna o método nomeado em uma classe de matriz.
GetCustomAttributes(Boolean)	Retorna todos os atributos personalizados que foram aplicados ao ModuleBuilderatual.
GetCustomAttributes(Type, Boolean)	Retorna todos os atributos personalizados que foram aplicados à ModuleBuilderatual e que derivam de um tipo de atributo especificado.
GetCustomAttributesData()	Retorna informações sobre os atributos que foram aplicados ao ModuleBuilderatual, expressos como objetos CustomAttributeData.
GetField(String)	Retorna um campo com o nome especificado. (Herdado de Module)
GetField(String, BindingFlags)	Retorna um campo no nível do módulo, definido na região .sdata do arquivo PE (executável portátil), que tem o nome e os atributos de associação especificados.
GetFieldMetadataToken(FieldInfo)	Quando substituído em uma classe derivada, retorna o token de metadados para o FieldInfo fornecido em relação ao Módulo.
GetFields()	Retorna os campos globais definidos no módulo. (Herdado de Module)
GetFields(BindingFlags)	Retorna todos os campos definidos na região .sdata do arquivo PE (executável portátil) que correspondem aos sinalizadores de associação especificados.
GetHashCode()	Retorna o código hash dessa instância.
GetMethod(String)	Retorna um método com o nome especificado. (Herdado de Module)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Retorna um método com o nome especificado, informações de associação, convenção de chamada e tipos de parâmetro e modificadores. (Herdado de Module)
GetMethod(String, Type[])	Retorna um método que tem o nome e os tipos de parâmetro especificados. (Herdado de Module)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Retorna o método de nível de módulo que corresponde aos critérios especificados.
GetMethodMetadataToken(ConstructorInfo)	Quando substituído em uma classe derivada, retorna o token de metadados para o ConstructorInfo fornecido em relação ao Módulo.
GetMethodMetadataToken(MethodInfo)	Quando substituído em uma classe derivada, retorna o token de metadados para o MethodInfo fornecido em relação ao Módulo.
GetMethods()	Retorna os métodos globais definidos no módulo. (Herdado de Module)
GetMethods(BindingFlags)	Retorna todos os métodos que foram definidos no nível do módulo para o ModuleBuilderatual e que correspondem aos sinalizadores de associação especificados.
GetObjectData(SerializationInfo, StreamingContext)	Obsoleto. Fornece uma implementação ISerializable para objetos serializados. (Herdado de Module)
GetPEKind(PortableExecutableKinds, ImageFileMachine)	Obtém um par de valores que indica a natureza do código em um módulo e a plataforma direcionada pelo módulo.
GetSignatureMetadataToken(SignatureHelper)	Quando substituído em uma classe derivada, retorna o token de metadados para o SignatureHelper fornecido em relação ao Módulo.
GetSignerCertificate()	Retorna um objeto X509Certificate correspondente ao certificado incluído na assinatura Authenticode do assembly ao qual este módulo pertence. Se o assembly não tiver sido assinado pelo Authenticode, null será retornado. (Herdado de Module)
GetStringMetadataToken(String)	Quando substituído em uma classe derivada, retorna o token de metadados para a constante String determinada relativa ao Módulo.
GetType()	Obtém o Type da instância atual. (Herdado de Object)
GetType(String)	Obtém o tipo nomeado definido no módulo.
GetType(String, Boolean)	Obtém o tipo nomeado definido no módulo, opcionalmente ignorando o caso do nome do tipo.
GetType(String, Boolean, Boolean)	Obtém o tipo nomeado definido no módulo, opcionalmente ignorando o caso do nome do tipo. Opcionalmente, gerará uma exceção se o tipo não for encontrado.
GetTypeMetadataToken(Type)	Quando substituído em uma classe derivada, retorna o token de metadados para o Type fornecido em relação ao Módulo.
GetTypes()	Retorna todas as classes definidas neste módulo.
IsDefined(Type, Boolean)	Retorna um valor que indica se o tipo de atributo especificado foi aplicado a este módulo.
IsResource()	Obtém um valor que indica se o objeto é um recurso.
MemberwiseClone()	Cria uma cópia superficial do Objectatual. (Herdado de Object)
ResolveField(Int32)	Retorna o campo identificado pelo token de metadados especificado. (Herdado de Module)
ResolveField(Int32, Type[], Type[])	Retorna o campo identificado pelo token de metadados especificado, no contexto definido pelos parâmetros de tipo genérico especificados.
ResolveMember(Int32)	Retorna o tipo ou membro identificado pelo token de metadados especificado. (Herdado de Module)
ResolveMember(Int32, Type[], Type[])	Retorna o tipo ou membro identificado pelo token de metadados especificado, no contexto definido pelos parâmetros de tipo genérico especificados.
ResolveMethod(Int32)	Retorna o método ou construtor identificado pelo token de metadados especificado. (Herdado de Module)
ResolveMethod(Int32, Type[], Type[])	Retorna o método ou construtor identificado pelo token de metadados especificado, no contexto definido pelos parâmetros de tipo genérico especificados.
ResolveSignature(Int32)	Retorna o blob de assinatura identificado por um token de metadados.
ResolveString(Int32)	Retorna a cadeia de caracteres identificada pelo token de metadados especificado.
ResolveType(Int32)	Retorna o tipo identificado pelo token de metadados especificado. (Herdado de Module)
ResolveType(Int32, Type[], Type[])	Retorna o tipo identificado pelo token de metadados especificado, no contexto definido pelos parâmetros de tipo genérico especificados.
SetCustomAttribute(ConstructorInfo, Byte[])	Aplica um atributo personalizado a este módulo usando um BLOB (objeto binário grande) que representa o atributo.
SetCustomAttribute(CustomAttributeBuilder)	Aplica um atributo personalizado a este módulo usando um construtor de atributos personalizado.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Quando substituído em uma classe derivada, define um atributo personalizado neste assembly.
ToString()	Retorna o nome do módulo. (Herdado de Module)

Métodos de Extensão

GetCustomAttribute(Module, Type)	Recupera um atributo personalizado de um tipo especificado que é aplicado a um módulo especificado.
GetCustomAttribute<T>(Module)	Recupera um atributo personalizado de um tipo especificado que é aplicado a um módulo especificado.
GetCustomAttributes(Module)	Recupera uma coleção de atributos personalizados que são aplicados a um módulo especificado.
GetCustomAttributes(Module, Type)	Recupera uma coleção de atributos personalizados de um tipo especificado que são aplicados a um módulo especificado.
GetCustomAttributes<T>(Module)	Recupera uma coleção de atributos personalizados de um tipo especificado que são aplicados a um módulo especificado.
IsDefined(Module, Type)	Indica se atributos personalizados de um tipo especificado são aplicados a um módulo especificado.
GetModuleVersionId(Module)	Define e representa um módulo em um assembly dinâmico.
HasModuleVersionId(Module)	Define e representa um módulo em um assembly dinâmico.