ModuleBuilder Třída

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

System.Reflection.Emit.dll

Zdroj:

ModuleBuilder.cs

Definuje a představuje modul v dynamickém sestavení.

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

Dědičnost

Object

Module

ModuleBuilder

Příklady

Následující ukázka kódu ukazuje použití k vytvoření dynamického ModuleBuilder modulu. Všimněte si, že ModuleBuilder je vytvořen voláním DefineDynamicModule v AssemblyBuilder, nikoli prostřednictvím konstruktoru.

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

Poznámky

Pokud chcete získat instanci ModuleBuildernástroje , použijte metodu AssemblyBuilder.DefineDynamicModule .

Konstruktory

ModuleBuilder()

Inicializuje novou instanci ModuleBuilder třídy .

Vlastnosti

Assembly	Získá dynamické sestavení, které definovalo tuto instanci .ModuleBuilder
CustomAttributes	Získá kolekci, která obsahuje vlastní atributy tohoto modulu. (Zděděno od Module)
FullyQualifiedName	String Získá představující plně kvalifikovaný název a cestu k tomuto modulu.
MDStreamVersion	Získá verzi streamu metadat.
MetadataToken	Získá token, který identifikuje aktuální dynamický modul v metadatech.
ModuleHandle	Získá popisovač modulu. (Zděděno od Module)
ModuleVersionId	Získá universálně jedinečný identifikátor (UUID), který lze použít k rozlišení mezi dvěma verzemi modulu.
Name	Řetězec, který označuje, že se jedná o modul v paměti.
ScopeName	Získá řetězec, který představuje název dynamického modulu.

Metody

CreateGlobalFunctions()	Dokončí definice globálních funkcí a globálních dat pro tento dynamický modul.
CreateGlobalFunctionsCore()	Při přepsání v odvozené třídě dokončí definice globálních funkcí a definice globálních dat pro tento dynamický modul.
DefineEnum(String, TypeAttributes, Type)	Definuje typ výčtu, který je typ hodnoty s jedním nestatické pole s názvem value__ zadaného typu.
DefineEnumCore(String, TypeAttributes, Type)	Při přepsání v odvozené třídě definuje typ výčtu, který je typ hodnoty s jedním nestatické pole s názvem value__ zadaného typu.
DefineGlobalMethod(String, MethodAttributes, CallingConventions, Type, Type[])	Definuje globální metodu se zadaným názvem, atributy, konvencí volání, návratovým typem a typy parametrů.
DefineGlobalMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Definuje globální metodu se zadaným názvem, atributy, konvencí volání, návratovým typem, vlastními modifikátory pro návratový typ, typy parametrů a vlastní modifikátory pro typy parametrů.
DefineGlobalMethod(String, MethodAttributes, Type, Type[])	Definuje globální metodu se zadaným názvem, atributy, návratovým typem a typy parametrů.
DefineGlobalMethodCore(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Při přepsání v odvozené třídě definuje globální metodu se zadaným názvem, atributy, konvencí volání, návratovým typem, vlastními modifikátory pro návratový typ, typy parametrů a vlastní modifikátory pro typy parametrů.
DefineInitializedData(String, Byte[], FieldAttributes)	Definuje inicializované datové pole v oddílu .sdata přenosného spustitelného souboru (PE).
DefineInitializedDataCore(String, Byte[], FieldAttributes)	Při přepsání v odvozené třídě definuje inicializované datové pole v oddílu .sdata přenosného spustitelného souboru (PE).
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Definuje metodu PInvoke se zadaným názvem, názvem knihovny DLL, ve které je metoda definována, atributy metody, konvence volání metody, návratový typ metody, typy parametrů metody a PInvoke příznaky.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Definuje metodu PInvoke se zadaným názvem, názvem knihovny DLL, ve které je metoda definována, atributy metody, konvence volání metody, návratový typ metody, typy parametrů metody a PInvoke příznaky.
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Při přepsání v odvozené třídě definuje metodu PInvoke .
DefineType(String)	TypeBuilder Vytvoří pro privátní typ se zadaným názvem v tomto modulu.
DefineType(String, TypeAttributes)	TypeBuilder Vytvoří daný název typu a atributy typu.
DefineType(String, TypeAttributes, Type)	TypeBuilder Vytvoří daný název typu, jeho atributy a typ, který definovaný typ rozšiřuje.
DefineType(String, TypeAttributes, Type, Int32)	TypeBuilder Vytvoří daný název typu, atributy, typ, který definovaný typ rozšiřuje, a celkovou velikost typu.
DefineType(String, TypeAttributes, Type, PackingSize)	TypeBuilder Vytvoří daný název typu, atributy, typ, který definovaný typ rozšiřuje, a velikost balení typu.
DefineType(String, TypeAttributes, Type, PackingSize, Int32)	TypeBuilder Vytvoří daný název typu, atributy, typ, který definovaný typ rozšiřuje, velikost balení definovaného typu a celkovou velikost definovaného typu.
DefineType(String, TypeAttributes, Type, Type[])	TypeBuilder Vytvoří daný název typu, atributy, typ, který definovaný typ rozšiřuje, a rozhraní, která definovaný typ implementuje.
DefineTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)	Při přepsání v odvozené třídě vytvoří TypeBuilder.
DefineUninitializedData(String, Int32, FieldAttributes)	Definuje neinicializované datové pole v oddílu .sdata přenosného spustitelného souboru (PE).
DefineUninitializedDataCore(String, Int32, FieldAttributes)	Při přepsání v odvozené třídě definuje neinicializované datové pole v oddílu .sdata přenosného spustitelného souboru (PE).
Equals(Object)	Vrátí hodnotu, která označuje, zda se tato instance rovná zadanému objektu.
FindTypes(TypeFilter, Object)	Vrátí pole tříd přijatých daným filtrem a kritérii filtru. (Zděděno od Module)
GetArrayMethod(Type, String, CallingConventions, Type, Type[])	Vrátí pojmenovanou metodu třídy pole.
GetArrayMethodCore(Type, String, CallingConventions, Type, Type[])	Při přepsání v odvozené třídě vrátí pojmenovanou metodu v třídě pole.
GetCustomAttributes(Boolean)	Vrátí všechny vlastní atributy, které byly použity pro aktuální ModuleBuilder.
GetCustomAttributes(Type, Boolean)	Vrátí všechny vlastní atributy, které byly použity pro aktuální ModuleBuildera které jsou odvozeny ze zadaného typu atributu.
GetCustomAttributesData()	Vrátí informace o atributech, které byly použity na aktuální ModuleBuilder, vyjádřené jako CustomAttributeData objekty.
GetField(String)	Vrátí pole se zadaným názvem. (Zděděno od Module)
GetField(String, BindingFlags)	Vrátí pole na úrovni modulu definované v oblasti .sdata přenosného spustitelného souboru (PE), které má zadaný název a atributy vazby.
GetFieldMetadataToken(FieldInfo)	Při přepsání v odvozené třídě vrátí token metadat pro danou FieldInfo třídu vzhledem k modulu.
GetFields()	Vrátí globální pole definovaná v modulu. (Zděděno od Module)
GetFields(BindingFlags)	Vrátí všechna pole definovaná v oblasti .sdata přenosného spustitelného souboru (PE), která odpovídají zadaným příznakům vazby.
GetHashCode()	Vrátí hodnotu hash pro tuto instanci.
GetMethod(String)	Vrátí metodu se zadaným názvem. (Zděděno od Module)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Vrátí metodu se zadaným názvem, informacemi o vazbě, konvencí volání a typy a modifikátory parametrů. (Zděděno od Module)
GetMethod(String, Type[])	Vrátí metodu se zadaným názvem a typy parametrů. (Zděděno od Module)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Vrátí metodu na úrovni modulu, která odpovídá zadaným kritériím.
GetMethodMetadataToken(ConstructorInfo)	Při přepsání v odvozené třídě vrátí token metadat pro danou ConstructorInfo třídu vzhledem k modulu.
GetMethodMetadataToken(MethodInfo)	Při přepsání v odvozené třídě vrátí token metadat pro danou MethodInfo třídu vzhledem k modulu.
GetMethods()	Vrátí globální metody definované v modulu. (Zděděno od Module)
GetMethods(BindingFlags)	Vrátí všechny metody, které byly definovány na úrovni modulu pro aktuální ModuleBuildera které odpovídají zadaným příznakům vazby.
GetObjectData(SerializationInfo, StreamingContext)	Zastaralé. Poskytuje implementaci ISerializable pro serializované objekty. (Zděděno od Module)
GetPEKind(PortableExecutableKinds, ImageFileMachine)	Získá dvojici hodnot označujících povahu kódu v modulu a platformu, na kterou modul cílí.
GetSignatureMetadataToken(SignatureHelper)	Při přepsání v odvozené třídě vrátí token metadat pro danou SignatureHelper třídu vzhledem k modulu.
GetSignerCertificate()	X509Certificate Vrátí objekt odpovídající certifikátu, který je součástí podpisu Authenticode sestavení, do kterého tento modul patří. Pokud sestavení nebylo podepsáno authenticode, null vrátí se. (Zděděno od Module)
GetStringMetadataToken(String)	Při přepsání v odvozené třídě vrátí token metadat pro danou String konstantu vzhledem k modulu.
GetType()	Type Získá z aktuální instance. (Zděděno od Object)
GetType(String)	Získá pojmenovaný typ definovaný v modulu.
GetType(String, Boolean)	Získá pojmenovaný typ definovaný v modulu, volitelně ignoruje velikost písmen názvu typu.
GetType(String, Boolean, Boolean)	Získá pojmenovaný typ definovaný v modulu, volitelně ignoruje velikost písmen názvu typu. Volitelně vyvolá výjimku, pokud se typ nenajde.
GetTypeMetadataToken(Type)	Při přepsání v odvozené třídě vrátí token metadat pro danou Type třídu vzhledem k modulu.
GetTypes()	Vrátí všechny třídy definované v tomto modulu.
IsDefined(Type, Boolean)	Vrátí hodnotu, která označuje, zda byl zadaný typ atributu použit v tomto modulu.
IsResource()	Získá hodnotu označující, zda objekt je prostředek.
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object)
ResolveField(Int32)	Vrátí pole identifikované zadaným tokenem metadat. (Zděděno od Module)
ResolveField(Int32, Type[], Type[])	Vrátí pole identifikované zadaným tokenem metadat v kontextu definovaném zadanými parametry obecného typu.
ResolveMember(Int32)	Vrátí typ nebo člen identifikovaný zadaným tokenem metadat. (Zděděno od Module)
ResolveMember(Int32, Type[], Type[])	Vrátí typ nebo člen identifikovaný zadaným tokenem metadat v kontextu definovaném zadanými parametry obecného typu.
ResolveMethod(Int32)	Vrátí metodu nebo konstruktor identifikovaný zadaným tokenem metadat. (Zděděno od Module)
ResolveMethod(Int32, Type[], Type[])	Vrátí metodu nebo konstruktor určený token metadat v kontextu definovaném zadanými parametry obecného typu.
ResolveSignature(Int32)	Vrátí objekt blob podpisu identifikovaný tokenem metadat.
ResolveString(Int32)	Vrátí řetězec identifikovaný zadaným tokenem metadat.
ResolveType(Int32)	Vrátí typ identifikovaný zadaným tokenem metadat. (Zděděno od Module)
ResolveType(Int32, Type[], Type[])	Vrátí typ určený token metadat v kontextu definovaném zadanými parametry obecného typu.
SetCustomAttribute(ConstructorInfo, Byte[])	Použije vlastní atribut na tento modul pomocí zadaného binárního velkého objektu (BLOB), který představuje atribut .
SetCustomAttribute(CustomAttributeBuilder)	Použije vlastní atribut na tento modul pomocí vlastního tvůrce atributů.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Při přepsání v odvozené třídě nastaví vlastní atribut v tomto sestavení.
ToString()	Vrátí název modulu. (Zděděno od Module)

Metody rozšíření

GetCustomAttribute(Module, Type)	Načte vlastní atribut zadaného typu, který je použit na zadaný modul.
GetCustomAttribute<T>(Module)	Načte vlastní atribut zadaného typu, který je použit na zadaný modul.
GetCustomAttributes(Module)	Načte kolekci vlastních atributů, které jsou použity na zadaný modul.
GetCustomAttributes(Module, Type)	Načte kolekci vlastních atributů zadaného typu, které jsou použity na zadaný modul.
GetCustomAttributes<T>(Module)	Načte kolekci vlastních atributů zadaného typu, které jsou použity na zadaný modul.
IsDefined(Module, Type)	Určuje, zda jsou na zadaný modul použity vlastní atributy zadaného typu.
GetModuleVersionId(Module)	Definuje a představuje modul v dynamickém sestavení.
HasModuleVersionId(Module)	Definuje a představuje modul v dynamickém sestavení.