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í ModuleBuilder k vytvoření dynamického modulu. Všimněte si, že ModuleBuilder je vytvořen voláním DefineDynamicModule v AssemblyBuilder, místo 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 ModuleBuilder, použijte metodu AssemblyBuilder.DefineDynamicModule.

Konstruktory

ModuleBuilder()

Inicializuje novou instanci ModuleBuilder třídy.

Vlastnosti

Assembly	Získá dynamické sestavení, které definoval tuto instanci ModuleBuilder.
CustomAttributes	Získá kolekci, která obsahuje vlastní atributy tohoto modulu. (Zděděno od Module)
FullyQualifiedName	Získá String 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á univerzá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í definice dat pro tento dynamický modul.
CreateGlobalFunctionsCore()	Při přepsání v odvozené třídě dokončí definice globální funkce a globální definice dat pro tento dynamický modul.
DefineEnum(String, TypeAttributes, Type)	Definuje typ výčtu, který je typ hodnoty s jedním nestatického 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ého 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 návratového typu, typy parametrů a vlastními 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, volání konvence, návratový typ, vlastní modifikátory návratového typu, 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 PInvoke metodu se zadaným názvem, názvem knihovny DLL, ve které je metoda definována, atributy metody, volání konvence metody, návratový typ metody, typy parametrů metody a PInvoke příznaky.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Definuje PInvoke metodu se zadaným názvem, názvem knihovny DLL, ve které je metoda definována, atributy metody, volání konvence 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 PInvoke metodu.
DefineType(String)	Vytvoří TypeBuilder pro privátní typ se zadaným názvem v tomto modulu.
DefineType(String, TypeAttributes)	Vytvoří TypeBuilder vzhledem k názvu typu a atributům typu.
DefineType(String, TypeAttributes, Type)	Vytvoří TypeBuilder zadaný název typu, jeho atributy a typ, který definovaný typ rozšiřuje.
DefineType(String, TypeAttributes, Type, Int32)	Vytvoří TypeBuilder vzhledem k názvu typu, atributům, typu, který definovaný typ rozšiřuje, a celkovou velikost typu.
DefineType(String, TypeAttributes, Type, PackingSize)	Vytvoří TypeBuilder vzhledem k názvu typu, atributům, typu, který definovaný typ rozšiřuje, a velikost balení typu.
DefineType(String, TypeAttributes, Type, PackingSize, Int32)	Vytvoří TypeBuilder vzhledem k názvu typu, atributům, typu, který definovaný typ rozšiřuje, velikost balení definovaného typu a celkovou velikost definovaného typu.
DefineType(String, TypeAttributes, Type, Type[])	Vytvoří TypeBuilder vzhledem k názvu typu, atributům, typu, který definovaný typ rozšiřuje, a rozhraní, která implementuje definovaný typ.
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á určuje, zda je tato instance rovna 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 v maticové třídě.
GetArrayMethodCore(Type, String, CallingConventions, Type, Type[])	Při přepsání v odvozené třídě vrátí pojmenovanou metodu u třídy pole.
GetCustomAttributes(Boolean)	Vrátí všechny vlastní atributy, které byly použity na aktuální ModuleBuilder.
GetCustomAttributes(Type, Boolean)	Vrátí všechny vlastní atributy, které byly použity na aktuální ModuleBuildera které jsou odvozeny od zadaného typu atributu.
GetCustomAttributesData()	Vrátí informace o atributech, které byly použity na aktuální ModuleBuilder, vyjádřeno 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 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í kód 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 parametrů a modifikátory. (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 vzhledem k modulu.
GetMethodMetadataToken(MethodInfo)	Při přepsání v odvozené třídě vrátí token metadat pro danou MethodInfo vzhledem k modulu.
GetMethods()	Vrátí globální metody definované v modulu. (Zděděno od Module)
GetMethods(BindingFlags)	Vrátí všechny metody definované na úrovni modulu pro aktuální ModuleBuildera odpovídají zadaným příznakům vazby.
GetObjectData(SerializationInfo, StreamingContext)	Zastaralé. Poskytuje ISerializable implementaci serializovaných objektů. (Zděděno od Module)
GetPEKind(PortableExecutableKinds, ImageFileMachine)	Získá dvojici hodnot označující 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 vzhledem k modulu.
GetSignerCertificate()	Vrátí objekt X509Certificate odpovídající certifikátu obsaženému v podpisu Authenticode sestavení, do kterého tento modul patří. Pokud sestavení nebylo podepsáno službou Authenticode, null se vrátí. (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()	Získá Type 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ě ignorování případu názvu typu.
GetType(String, Boolean, Boolean)	Získá pojmenovaný typ definovaný v modulu, volitelně ignorování případu názvu typu. Volitelně vyvolá výjimku, pokud typ nebyl nalezen.
GetTypeMetadataToken(Type)	Při přepsání v odvozené třídě vrátí token metadat pro danou Type vzhledem k modulu.
GetTypes()	Vrátí všechny třídy definované v rámci tohoto modulu.
IsDefined(Type, Boolean)	Vrátí hodnotu, která určuje, zda byl zadaný typ atributu použit v tomto modulu.
IsResource()	Získá hodnotu určující, zda objekt je prostředek.
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (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 identifikovaný zadaným tokenem 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 identifikovaný zadaným tokenem metadat v kontextu definovaném zadanými parametry obecného typu.
SetCustomAttribute(ConstructorInfo, Byte[])	Použije vlastní atribut pro tento modul pomocí zadaného binárního velkého objektu (BLOB), který představuje atribut.
SetCustomAttribute(CustomAttributeBuilder)	Použije vlastní atribut pro tento modul pomocí vlastního tvůrce atributů.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Při přepsání v odvozené třídě nastaví vlastní atribut pro toto 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ý se použije v zadaném modulu.
GetCustomAttribute<T>(Module)	Načte vlastní atribut zadaného typu, který se použije v zadaném modulu.
GetCustomAttributes(Module)	Načte kolekci vlastních atributů, které se použijí na zadaný modul.
GetCustomAttributes(Module, Type)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný modul.
GetCustomAttributes<T>(Module)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný modul.
IsDefined(Module, Type)	Určuje, zda se na zadaný modul použijí 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í.