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 , em AssemblyBuildervez 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 do ModuleBuilder, use o AssemblyBuilder.DefineDynamicModule método .

Construtores

ModuleBuilder()

Inicializa uma nova instância da classe ModuleBuilder.

Propriedades

Assembly	Obtém o assembly dinâmico que definiu esta instância do ModuleBuilder.
CustomAttributes	Obtém uma coleção que contém os atributos personalizados deste módulo. (Herdado de Module)
FullyQualifiedName	Obtém uma String que representa o nome totalmente qualificado e o caminho para esse módulo.
MDStreamVersion	Obtém a versão de fluxo de metadados.
MetadataToken	Obtém um token que identifica o módulo dinâmico atual nos 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 a definições de função global e dados globais para esse 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, os atributos, a convenção de chamada, o tipo de retorno e os tipos de parâmetro especificados.
DefineGlobalMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Define um método global com os valores especificado de 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, os atributos, o tipo de retorno e os 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 especificados para o tipo de retorno, tipos de parâmetro e modificadores personalizados para os tipos de parâmetro.
DefineInitializedData(String, Byte[], FieldAttributes)	Define o 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 em que 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 PInvoke.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Define um método PInvoke com o nome especificado, o nome da DLL em que 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 PInvoke.
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Quando substituído em uma classe derivada, define um PInvoke método .
DefineType(String)	Constrói um TypeBuilder para um tipo particular com o nome especificado neste módulo.
DefineType(String, TypeAttributes)	Constrói um TypeBuilder considerando o nome do tipo e os atributos de tipo.
DefineType(String, TypeAttributes, Type)	Constrói um TypeBuilder dado o nome do 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 de empacotamento do tipo.
DefineType(String, TypeAttributes, Type, PackingSize, Int32)	Constrói um TypeBuilder dado o nome do tipo, os 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, os 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 o 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 esta instância é igual ao objeto especificado.
FindTypes(TypeFilter, Object)	Retorna uma matriz de classes aceitas pelo filtro e critérios de filtro determinados. (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 ModuleBuilder atual.
GetCustomAttributes(Type, Boolean)	Retorna todos os atributos personalizados que foram aplicados ao ModuleBuilder atual 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 que tem o nome especificado. (Herdado de Module)
GetField(String, BindingFlags)	Retorna um campo no nível de módulo, definido na região de .sdata o 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 fornecido FieldInfo 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 para a 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 contendo 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 com os tipos de parâmetro e nome especificados. (Herdado de Module)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Retorna o método no 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 fornecido ConstructorInfo em relação ao Módulo.
GetMethodMetadataToken(MethodInfo)	Quando substituído em uma classe derivada, retorna o token de metadados para o fornecido MethodInfo 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 de módulo para o ModuleBuilder atual e que corresponde 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 de destino do módulo.
GetSignatureMetadataToken(SignatureHelper)	Quando substituído em uma classe derivada, retorna o token de metadados para o fornecido SignatureHelper 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 por Authenticode, null será retornado. (Herdado de Module)
GetStringMetadataToken(String)	Quando substituído em uma classe derivada, retorna o token de metadados para a constante fornecida String em relação 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 maiúsculas e minúsculas do nome do tipo.
GetType(String, Boolean, Boolean)	Obtém o tipo nomeado definido no módulo, opcionalmente ignorando maiúsculas e minúsculas 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 fornecido Type 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 Object atual. (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 o membro identificado pelo token de metadados especificado. (Herdado de Module)
ResolveMember(Int32, Type[], Type[])	Retorna o tipo ou o 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 o construtor identificado pelo token de metadados especificado. (Herdado de Module)
ResolveMethod(Int32, Type[], Type[])	Retorna o método ou o 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 esse módulo usando um BLOB (objeto binário grande) especificado que representa o atributo.
SetCustomAttribute(CustomAttributeBuilder)	Aplica um atributo personalizado a esse módulo usando um construtor de atributo 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 aplicado a um módulo especificado.
GetCustomAttribute<T>(Module)	Recupera um atributo personalizado de um tipo especificado 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 os atributos personalizados de um tipo especificados 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.