ModuleBuilder Klasse

Referenz

Definition

Namespace:: System.Reflection.Emit

Assembly:: System.Reflection.Emit.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Paket:: System.Reflection.Emit v4.7.0

Quelle:: ModuleBuilder.cs

Quelle:: ModuleBuilder.cs

Quelle:: ModuleBuilder.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Definiert und stellt ein Modul in einer dynamischen Assembly dar.

public ref class ModuleBuilder : System::Reflection::Module

public ref class ModuleBuilder abstract : System::Reflection::Module

public ref class ModuleBuilder : System::Reflection::Module, System::Runtime::InteropServices::_ModuleBuilder

public class ModuleBuilder : System.Reflection.Module

public abstract class ModuleBuilder : System.Reflection.Module

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public class ModuleBuilder : System.Reflection.Module, System.Runtime.InteropServices._ModuleBuilder

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public class ModuleBuilder : System.Reflection.Module, System.Runtime.InteropServices._ModuleBuilder

type ModuleBuilder = class
    inherit Module

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type ModuleBuilder = class
    inherit Module
    interface _ModuleBuilder

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ModuleBuilder = class
    inherit Module
    interface _ModuleBuilder

Public Class ModuleBuilder
Inherits Module

Public MustInherit Class ModuleBuilder
Inherits Module

Public Class ModuleBuilder
Inherits Module
Implements _ModuleBuilder

Vererbung: Object

Module
ModuleBuilder

Attribute: ClassInterfaceAttribute ComVisibleAttribute

Implementiert: _ModuleBuilder

Beispiele

Im folgenden Codebeispiel wird die Verwendung von ModuleBuilder zum Erstellen eines dynamischen Moduls veranschaulicht. Beachten Sie, dass das ModuleBuilder-Element durch Aufrufen von DefineDynamicModule in AssemblyBuilderund nicht über einen Konstruktor erstellt wird.

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

Hinweise

Verwenden Sie die AssemblyBuilder.DefineDynamicModule-Methode, um eine Instanz von ModuleBuilderabzurufen.

Konstruktoren

ModuleBuilder()

Initialisiert eine neue Instanz der ModuleBuilder Klasse.

Eigenschaften

Assembly	Ruft die dynamische Assembly ab, die diese Instanz von ModuleBuilderdefiniert hat.
Assembly	Ruft die entsprechende Assembly für diese Instanz von Moduleab. (Geerbt von Module)
CustomAttributes	Ruft eine Auflistung ab, die die benutzerdefinierten Attribute dieses Moduls enthält. (Geerbt von Module)
FullyQualifiedName	Ruft eine `String`, die den vollqualifizierten Namen und Pfad zu diesem Modul darstellt.
MDStreamVersion	Ruft die Metadatenstreamversion ab.
MDStreamVersion	Ruft die Metadatenstreamversion ab. (Geerbt von Module)
MetadataToken	Ruft ein Token ab, das das aktuelle dynamische Modul in Metadaten identifiziert.
MetadataToken	Ruft ein Token ab, das das Modul in Metadaten identifiziert. (Geerbt von Module)
ModuleHandle	Ruft ein Handle für das Modul ab. (Geerbt von Module)
ModuleVersionId	Ruft einen universal eindeutigen Bezeichner (UUID) ab, der verwendet werden kann, um zwischen zwei Versionen eines Moduls zu unterscheiden.
ModuleVersionId	Ruft einen universal eindeutigen Bezeichner (UUID) ab, der verwendet werden kann, um zwischen zwei Versionen eines Moduls zu unterscheiden. (Geerbt von Module)
Name	Eine Zeichenfolge, die angibt, dass es sich um ein Speichermodul handelt.
Name	Ruft eine `String` zurück, die den Namen des Moduls darstellt, wobei der Pfad entfernt wurde. (Geerbt von Module)
ScopeName	Ruft eine Zeichenfolge ab, die den Namen des dynamischen Moduls darstellt.
ScopeName	Ruft eine Zeichenfolge ab, die den Namen des Moduls darstellt. (Geerbt von Module)

Methoden

CreateGlobalFunctions()	Schließt die globalen Funktionsdefinitionen und globalen Datendefinitionen für dieses dynamische Modul ab.
CreateGlobalFunctionsCore()	Wenn eine abgeleitete Klasse außer Kraft gesetzt wird, werden die globalen Funktionsdefinitionen und globalen Datendefinitionen für dieses dynamische Modul abgeschlossen.
DefineDocument(String, Guid)	Definiert ein Dokument für die Quelle.
DefineDocument(String, Guid, Guid, Guid)	Definiert ein Dokument für die Quelle.
DefineDocumentCore(String, Guid)	Wenn sie in einer abgeleiteten Klasse außer Kraft gesetzt wird, wird ein Dokument für die Quelle definiert.
DefineEnum(String, TypeAttributes, Type)	Definiert einen Enumerationstyp, bei dem es sich um einen Werttyp mit einem einzelnen nicht statischen Feld handelt, das `value__` des angegebenen Typs aufgerufen wird.
DefineEnumCore(String, TypeAttributes, Type)	Wenn eine abgeleitete Klasse außer Kraft gesetzt wird, definiert sie einen Enumerationstyp, der einen Werttyp mit einem einzelnen nicht statischen Feld namens value__ des angegebenen Typs darstellt.
DefineGlobalMethod(String, MethodAttributes, CallingConventions, Type, Type[])	Definiert eine globale Methode mit dem angegebenen Namen, Attributen, aufrufenden Konventionen, Rückgabetyp und Parametertypen.
DefineGlobalMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Definiert eine globale Methode mit dem angegebenen Namen, Attributen, aufrufenden Konventionen, Rückgabetyp, benutzerdefinierte Modifizierern für den Rückgabetyp, Parametertypen und benutzerdefinierte Modifizierer für die Parametertypen.
DefineGlobalMethod(String, MethodAttributes, Type, Type[])	Definiert eine globale Methode mit dem angegebenen Namen, Attributen, Rückgabetyp und Parametertypen.
DefineGlobalMethodCore(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Wenn eine abgeleitete Klasse überschrieben wird, definiert eine globale Methode mit dem angegebenen Namen, Attributen, aufrufenden Konventionen, Rückgabetyp, benutzerdefinierte Modifizierern für den Rückgabetyp, Parametertypen und benutzerdefinierte Modifizierer für die Parametertypen.
DefineInitializedData(String, Byte[], FieldAttributes)	Definiert ein initialisiertes Datenfeld im Sdata-Abschnitt der portablen ausführbaren Datei (PORTABLE Ausführbare Datei, PE).
DefineInitializedDataCore(String, Byte[], FieldAttributes)	Wenn eine abgeleitete Klasse überschrieben wird, wird ein initialisiertes Datenfeld im SDATA-Abschnitt der PORTABLE ausführbaren Datei (PE) definiert.
DefineManifestResource(String, Stream, ResourceAttributes)	Definiert ein binäres großes Objekt (BLOB), das eine Manifestressource darstellt, die in die dynamische Assembly eingebettet werden soll.
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Definiert eine `PInvoke` Methode mit dem angegebenen Namen, den Namen der DLL, in der die Methode definiert ist, die Attribute der Methode, die aufrufende Konvention der Methode, den Rückgabetyp der Methode, die Typen der Parameter der Methode und die `PInvoke` Flags.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Definiert eine `PInvoke` Methode mit dem angegebenen Namen, den Namen der DLL, in der die Methode definiert ist, die Attribute der Methode, die aufrufende Konvention der Methode, den Rückgabetyp der Methode, die Typen der Parameter der Methode und die `PInvoke` Flags.
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Wenn eine abgeleitete Klasse außer Kraft gesetzt wird, wird eine `PInvoke` Methode definiert.
DefineResource(String, String)	Definiert die benannte verwaltete eingebettete Ressource, die in diesem Modul gespeichert werden soll.
DefineResource(String, String, ResourceAttributes)	Definiert die benannte verwaltete eingebettete Ressource mit den angegebenen Attributen, die in diesem Modul gespeichert werden sollen.
DefineType(String)	Erstellt eine `TypeBuilder` für einen privaten Typ mit dem angegebenen Namen in diesem Modul.
DefineType(String, TypeAttributes)	Erstellt eine `TypeBuilder` mit dem Typnamen und den Typattributen.
DefineType(String, TypeAttributes, Type)	Erstellt einen `TypeBuilder` angegebenen Typnamen, seine Attribute und den Typ, den der definierte Typ erweitert.
DefineType(String, TypeAttributes, Type, Int32)	Erstellt eine `TypeBuilder` mit dem Typnamen, den Attributen, dem Typ, den der definierte Typ erweitert wird, und die Gesamtgröße des Typs.
DefineType(String, TypeAttributes, Type, PackingSize)	Erstellt eine `TypeBuilder` mit dem Typnamen, den Attributen, dem Typ, den der definierte Typ erweitert wird, und die Verpackungsgröße des Typs.
DefineType(String, TypeAttributes, Type, PackingSize, Int32)	Erstellt eine `TypeBuilder` mit dem Typnamen, Attributen, dem Typ, den der definierte Typ erweitert, die Verpackungsgröße des definierten Typs und die Gesamtgröße des definierten Typs.
DefineType(String, TypeAttributes, Type, Type[])	Erstellt eine `TypeBuilder` mit dem Typnamen, Attributen, dem Typ, den der definierte Typ erweitert wird, und die Schnittstellen, die der definierte Typ implementiert.
DefineTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird ein TypeBuildererstellt.
DefineUninitializedData(String, Int32, FieldAttributes)	Definiert ein nicht initialisiertes Datenfeld im SDATA-Abschnitt der PORTABLE ausführbaren Datei (PE).
DefineUninitializedDataCore(String, Int32, FieldAttributes)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird ein nicht initialisiertes Datenfeld im SDATA-Abschnitt der PORTABLE ausführbaren Datei (PORTABLE Ausführbare Datei, PE) definiert.
DefineUnmanagedResource(Byte[])	Definiert eine nicht verwaltete eingebettete Ressource mit einem undurchsichtigen binären großen Objekt (BLOB) von Bytes.
DefineUnmanagedResource(String)	Definiert eine nicht verwaltete Ressource mit dem Namen der Win32-Ressourcendatei.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz dem angegebenen Objekt entspricht.
Equals(Object)	Bestimmt, ob dieses Modul und das angegebene Objekt gleich sind. (Geerbt von Module)
FindTypes(TypeFilter, Object)	Gibt ein Array von Klassen zurück, die von den angegebenen Filter- und Filterkriterien akzeptiert werden. (Geerbt von Module)
GetArrayMethod(Type, String, CallingConventions, Type, Type[])	Gibt die benannte Methode für eine Arrayklasse zurück.
GetArrayMethodCore(Type, String, CallingConventions, Type, Type[])	Wenn eine abgeleitete Klasse überschrieben wird, wird die benannte Methode für eine Arrayklasse zurückgegeben.
GetArrayMethodToken(Type, String, CallingConventions, Type, Type[])	Gibt das Token für die benannte Methode für eine Arrayklasse zurück.
GetConstructorToken(ConstructorInfo)	Gibt das Token zurück, das zum Identifizieren des angegebenen Konstruktors innerhalb dieses Moduls verwendet wird.
GetConstructorToken(ConstructorInfo, IEnumerable<Type>)	Gibt das Token zurück, das verwendet wird, um den Konstruktor zu identifizieren, der über die angegebenen Attribute und Parametertypen in diesem Modul verfügt.
GetCustomAttributes(Boolean)	Gibt alle benutzerdefinierten Attribute zurück, die auf die aktuelle ModuleBuilderangewendet wurden.
GetCustomAttributes(Boolean)	Gibt alle benutzerdefinierten Attribute zurück. (Geerbt von Module)
GetCustomAttributes(Type, Boolean)	Gibt alle benutzerdefinierten Attribute zurück, die auf die aktuelle ModuleBuilderangewendet wurden und von einem angegebenen Attributtyp abgeleitet sind.
GetCustomAttributes(Type, Boolean)	Ruft benutzerdefinierte Attribute des angegebenen Typs ab. (Geerbt von Module)
GetCustomAttributesData()	Gibt Informationen zu den Attributen zurück, die auf das aktuelle ModuleBuilderangewendet wurden , ausgedrückt als CustomAttributeData -Objekte.
GetCustomAttributesData()	Gibt eine Liste der CustomAttributeData Objekte für das aktuelle Modul zurück, die im reinen Spiegelungskontext verwendet werden kann. (Geerbt von Module)
GetField(String)	Gibt ein Feld mit dem angegebenen Namen zurück. (Geerbt von Module)
GetField(String, BindingFlags)	Gibt ein Feld auf Modulebene zurück, das in der .sdata-Region der portablen ausführbaren Datei (PORTABLE ausführbare Datei, PE) definiert ist, die den angegebenen Namen und Bindungsattribute enthält.
GetField(String, BindingFlags)	Gibt ein Feld mit den angegebenen Namen- und Bindungsattributen zurück. (Geerbt von Module)
GetFieldMetadataToken(FieldInfo)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird das Metadatentoken für das angegebene FieldInfo relativ zum Modul zurückgegeben.
GetFields()	Gibt die globalen Felder zurück, die für das Modul definiert sind. (Geerbt von Module)
GetFields(BindingFlags)	Gibt alle Felder zurück, die in der SDATA-Region der portablen ausführbaren Datei (PORTABLE Ausführbare Datei, PE) definiert sind, die den angegebenen Bindungskennzeichnungen entsprechen.
GetFields(BindingFlags)	Gibt die globalen Felder zurück, die für das Modul definiert sind, die den angegebenen Bindungskennzeichnungen entsprechen. (Geerbt von Module)
GetFieldToken(FieldInfo)	Gibt das Token zurück, das zum Identifizieren des angegebenen Felds innerhalb dieses Moduls verwendet wird.
GetHashCode()	Gibt den Hashcode für diese Instanz zurück.
GetHashCode()	Gibt den Hashcode für diese Instanz zurück. (Geerbt von Module)
GetMethod(String)	Gibt eine Methode mit dem angegebenen Namen zurück. (Geerbt von Module)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Gibt eine Methode mit dem angegebenen Namen, Bindungsinformationen, aufrufenden Konventionen und Parametertypen und Modifizierern zurück. (Geerbt von Module)
GetMethod(String, Type[])	Gibt eine Methode mit den angegebenen Namen- und Parametertypen zurück. (Geerbt von Module)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Gibt die Methode auf Modulebene zurück, die den angegebenen Kriterien entspricht.
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Gibt die Methodenimplementierung gemäß den angegebenen Kriterien zurück. (Geerbt von Module)
GetMethodMetadataToken(ConstructorInfo)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird das Metadatentoken für das angegebene ConstructorInfo relativ zum Modul zurückgegeben.
GetMethodMetadataToken(MethodInfo)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird das Metadatentoken für das angegebene MethodInfo relativ zum Modul zurückgegeben.
GetMethods()	Gibt die globalen Methoden zurück, die für das Modul definiert sind. (Geerbt von Module)
GetMethods(BindingFlags)	Gibt alle Methoden zurück, die auf Modulebene für die aktuelle ModuleBuilderdefiniert wurden und mit den angegebenen Bindungskennzeichnungen übereinstimmen.
GetMethods(BindingFlags)	Gibt die globalen Methoden zurück, die für das Modul definiert sind, die den angegebenen Bindungskennzeichnungen entsprechen. (Geerbt von Module)
GetMethodToken(MethodInfo)	Gibt das Token zurück, das zum Identifizieren der angegebenen Methode innerhalb dieses Moduls verwendet wird.
GetMethodToken(MethodInfo, IEnumerable<Type>)	Gibt das Token zurück, das verwendet wird, um die Methode mit den angegebenen Attributen und Parametertypen in diesem Modul zu identifizieren.
GetObjectData(SerializationInfo, StreamingContext)	Veraltet. Stellt eine ISerializable Implementierung für serialisierte Objekte bereit. (Geerbt von Module)
GetPEKind(PortableExecutableKinds, ImageFileMachine)	Ruft ein Wertepaar ab, das die Art des Codes in einem Modul und die Plattform angibt, auf die das Modul ausgerichtet ist.
GetPEKind(PortableExecutableKinds, ImageFileMachine)	Ruft ein Wertepaar ab, das die Art des Codes in einem Modul und die Plattform angibt, auf die das Modul ausgerichtet ist. (Geerbt von Module)
GetSignatureMetadataToken(SignatureHelper)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird das Metadatentoken für das angegebene SignatureHelper relativ zum Modul zurückgegeben.
GetSignatureToken(Byte[], Int32)	Definiert ein Token für die Signatur mit der angegebenen Zeichenarray- und Signaturlänge.
GetSignatureToken(SignatureHelper)	Definiert ein Token für die Signatur, die durch die angegebene SignatureHelperdefiniert wird.
GetSignerCertificate()	Gibt ein X509Certificate -Objekt zurück, das dem Zertifikat entspricht, das in der Authenticode-Signatur der Assembly enthalten ist, zu der dieses Modul gehört. Wenn die Assembly nicht authenticode signiert wurde, wird `null` zurückgegeben.
GetSignerCertificate()	Gibt ein `X509Certificate` -Objekt zurück, das dem Zertifikat entspricht, das in der Authenticode-Signatur der Assembly enthalten ist, zu der dieses Modul gehört. Wenn die Assembly nicht authenticode signiert wurde, wird `null` zurückgegeben. (Geerbt von Module)
GetStringConstant(String)	Gibt das Token der angegebenen Zeichenfolge im Konstantenpool des Moduls zurück.
GetStringMetadataToken(String)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird das Metadatentoken für die angegebene String Konstante relativ zum Modul zurückgegeben.
GetSymWriter()	Gibt den Symbolschreiber zurück, der diesem dynamischen Modul zugeordnet ist.
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
GetType(String)	Ruft den benannten Typ ab, der im Modul definiert ist.
GetType(String)	Gibt den angegebenen Typ zurück, bei dem bei der Suche nach Groß-/Kleinschreibung unterschieden wird. (Geerbt von Module)
GetType(String, Boolean)	Ruft den im Modul definierten benannten Typ ab, optional wird die Groß-/Kleinschreibung des Typnamens ignoriert.
GetType(String, Boolean)	Gibt den angegebenen Typ zurück und durchsucht das Modul mit der angegebenen Groß-/Kleinschreibung. (Geerbt von Module)
GetType(String, Boolean, Boolean)	Ruft den im Modul definierten benannten Typ ab, optional wird die Groß-/Kleinschreibung des Typnamens ignoriert. Gibt optional eine Ausnahme aus, wenn der Typ nicht gefunden wird.
GetType(String, Boolean, Boolean)	Gibt den angegebenen Typ zurück, der angibt, ob die Groß-/Kleinschreibung des Moduls durchsucht werden soll und ob eine Ausnahme ausgelöst werden soll, wenn der Typ nicht gefunden werden kann. (Geerbt von Module)
GetTypeMetadataToken(Type)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird das Metadatentoken für das angegebene Type relativ zum Modul zurückgegeben.
GetTypes()	Gibt alle klassen zurück, die in diesem Modul definiert sind.
GetTypes()	Gibt alle in diesem Modul definierten Typen zurück. (Geerbt von Module)
GetTypeToken(String)	Gibt das Token zurück, das zum Identifizieren des Typs mit dem angegebenen Namen verwendet wird.
GetTypeToken(Type)	Gibt das Token zurück, das zum Identifizieren des angegebenen Typs in diesem Modul verwendet wird.
IsDefined(Type, Boolean)	Gibt einen Wert zurück, der angibt, ob der angegebene Attributtyp auf dieses Modul angewendet wurde.
IsDefined(Type, Boolean)	Gibt einen Wert zurück, der angibt, ob der angegebene Attributtyp auf dieses Modul angewendet wurde. (Geerbt von Module)
IsResource()	Ruft einen Wert ab, der angibt, ob das Objekt eine Ressource ist.
IsResource()	Ruft einen Wert ab, der angibt, ob das Objekt eine Ressource ist. (Geerbt von Module)
IsTransient()	Gibt einen Wert zurück, der angibt, ob dieses dynamische Modul vorübergehend ist.
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
ResolveField(Int32)	Gibt das vom angegebenen Metadatentoken identifizierte Feld zurück. (Geerbt von Module)
ResolveField(Int32, Type[], Type[])	Gibt das vom angegebenen Metadatentoken identifizierte Feld im Kontext zurück, der durch die angegebenen generischen Typparameter definiert wird.
ResolveField(Int32, Type[], Type[])	Gibt das vom angegebenen Metadatentoken identifizierte Feld im Kontext zurück, der durch die angegebenen generischen Typparameter definiert wird. (Geerbt von Module)
ResolveMember(Int32)	Gibt den vom angegebenen Metadatentoken identifizierten Typ oder Member zurück. (Geerbt von Module)
ResolveMember(Int32, Type[], Type[])	Gibt den vom angegebenen Metadatentoken identifizierten Typ oder Member im Kontext zurück, der durch die angegebenen generischen Typparameter definiert wurde.
ResolveMember(Int32, Type[], Type[])	Gibt den vom angegebenen Metadatentoken identifizierten Typ oder Member im Kontext zurück, der durch die angegebenen generischen Typparameter definiert wurde. (Geerbt von Module)
ResolveMethod(Int32)	Gibt die vom angegebenen Metadatentoken identifizierte Methode oder den Konstruktor zurück. (Geerbt von Module)
ResolveMethod(Int32, Type[], Type[])	Gibt die vom angegebenen Metadatentoken identifizierte Methode oder den Konstruktor im Kontext zurück, der durch die angegebenen generischen Typparameter definiert wird.
ResolveMethod(Int32, Type[], Type[])	Gibt die vom angegebenen Metadatentoken identifizierte Methode oder den Konstruktor im Kontext zurück, der durch die angegebenen generischen Typparameter definiert wird. (Geerbt von Module)
ResolveSignature(Int32)	Gibt das signatur-BLOB zurück, das durch ein Metadatentoken identifiziert wird.
ResolveSignature(Int32)	Gibt das signatur-BLOB zurück, das durch ein Metadatentoken identifiziert wird. (Geerbt von Module)
ResolveString(Int32)	Gibt die vom angegebenen Metadatentoken identifizierte Zeichenfolge zurück.
ResolveString(Int32)	Gibt die vom angegebenen Metadatentoken identifizierte Zeichenfolge zurück. (Geerbt von Module)
ResolveType(Int32)	Gibt den vom angegebenen Metadatentoken identifizierten Typ zurück. (Geerbt von Module)
ResolveType(Int32, Type[], Type[])	Gibt den vom angegebenen Metadatentoken identifizierten Typ im Kontext zurück, der durch die angegebenen generischen Typparameter definiert ist.
ResolveType(Int32, Type[], Type[])	Gibt den vom angegebenen Metadatentoken identifizierten Typ im Kontext zurück, der durch die angegebenen generischen Typparameter definiert ist. (Geerbt von Module)
SetCustomAttribute(ConstructorInfo, Byte[])	Wendet ein benutzerdefiniertes Attribut auf dieses Modul mithilfe eines angegebenen binären großen Objekts (BLOB) an, das das Attribut darstellt.
SetCustomAttribute(CustomAttributeBuilder)	Wendet ein benutzerdefiniertes Attribut auf dieses Modul mithilfe eines benutzerdefinierten Attribut-Generators an.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird ein benutzerdefiniertes Attribut für diese Assembly festgelegt.
SetSymCustomAttribute(String, Byte[])	Diese Methode führt nichts aus.
SetUserEntryPoint(MethodInfo)	Legt den Einstiegspunkt des Benutzers fest.
ToString()	Gibt den Namen des Moduls zurück. (Geerbt von Module)

Explizite Schnittstellenimplementierungen

_Module.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Ordnet einen Satz von Namen einem entsprechenden Satz von Verteiler-IDs zu. (Geerbt von Module)
_Module.GetTypeInfo(UInt32, UInt32, IntPtr)	Ruft die Typinformationen für ein Objekt ab, die dann verwendet werden können, um die Typinformationen für eine Schnittstelle abzurufen. (Geerbt von Module)
_Module.GetTypeInfoCount(UInt32)	Ruft die Anzahl der Typinformationsschnittstellen ab, die ein Objekt bereitstellt (entweder 0 oder 1). (Geerbt von Module)
_Module.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Bietet Zugriff auf Eigenschaften und Methoden, die von einem Objekt verfügbar gemacht werden. (Geerbt von Module)
_ModuleBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Eine Beschreibung dieses Mitglieds finden Sie unter GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr).
_ModuleBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)	Eine Beschreibung dieses Mitglieds finden Sie unter GetTypeInfo(UInt32, UInt32, IntPtr).
_ModuleBuilder.GetTypeInfoCount(UInt32)	Eine Beschreibung dieses Mitglieds finden Sie unter GetTypeInfoCount(UInt32).
_ModuleBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Eine Beschreibung dieses Mitglieds finden Sie unter Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr).
ICustomAttributeProvider.GetCustomAttributes(Boolean)	Gibt ein Array aller benutzerdefinierten Attribute zurück, die für dieses Element definiert sind, ohne benannte Attribute oder ein leeres Array, wenn keine benutzerdefinierten Attribute vorhanden sind. (Geerbt von Module)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)	Gibt ein Array von benutzerdefinierten Attributen zurück, die für dieses Element definiert sind, identifiziert nach Typ oder ein leeres Array, wenn keine benutzerdefinierten Attribute dieses Typs vorhanden sind. (Geerbt von Module)
ICustomAttributeProvider.IsDefined(Type, Boolean)	Gibt an, ob eine oder mehrere Instanzen von `attributeType` für dieses Element definiert sind. (Geerbt von Module)

Erweiterungsmethoden

GetCustomAttribute(Module, Type)	Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, das auf ein angegebenes Modul angewendet wird.
GetCustomAttribute<T>(Module)	Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, das auf ein angegebenes Modul angewendet wird.
GetCustomAttributes(Module)	Ruft eine Auflistung von benutzerdefinierten Attributen ab, die auf ein angegebenes Modul angewendet werden.
GetCustomAttributes(Module, Type)	Ruft eine Auflistung von benutzerdefinierten Attributen eines angegebenen Typs ab, die auf ein angegebenes Modul angewendet werden.
GetCustomAttributes<T>(Module)	Ruft eine Auflistung von benutzerdefinierten Attributen eines angegebenen Typs ab, die auf ein angegebenes Modul angewendet werden.
IsDefined(Module, Type)	Gibt an, ob benutzerdefinierte Attribute eines angegebenen Typs auf ein angegebenes Modul angewendet werden.
GetModuleVersionId(Module)	Definiert und stellt ein Modul in einer dynamischen Assembly dar.
HasModuleVersionId(Module)	Definiert und stellt ein Modul in einer dynamischen Assembly dar.

Gilt für:

Freigeben über