ModuleBuilder Klasse

Definition

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.dll

Quelle:

ModuleBuilder.cs

Definiert und stellt ein Modul in einer dynamischen Assembly dar.

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

Vererbung

Object

Module

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.
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.
MetadataToken	Ruft ein Token ab, das das aktuelle dynamische Modul in Metadaten identifiziert.
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.
Name	Eine Zeichenfolge, die angibt, dass es sich um ein Speichermodul handelt.
ScopeName	Ruft eine Zeichenfolge ab, die den Namen des dynamischen Moduls darstellt.

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.
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.
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.
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.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz dem angegebenen Objekt entspricht.
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.
GetCustomAttributes(Boolean)	Gibt alle benutzerdefinierten Attribute zurück, die auf die aktuelle ModuleBuilderangewendet wurden.
GetCustomAttributes(Type, Boolean)	Gibt alle benutzerdefinierten Attribute zurück, die auf die aktuelle ModuleBuilderangewendet wurden und von einem angegebenen Attributtyp abgeleitet sind.
GetCustomAttributesData()	Gibt Informationen zu den Attributen zurück, die auf das aktuelle ModuleBuilderangewendet wurden , ausgedrückt als CustomAttributeData -Objekte.
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.
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.
GetHashCode()	Gibt den Hashcode für diese Instanz zurück.
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.
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.
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.
GetSignatureMetadataToken(SignatureHelper)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird das Metadatentoken für das angegebene SignatureHelper relativ zum Modul 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)
GetStringMetadataToken(String)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird das Metadatentoken für die angegebene String Konstante relativ zum Modul zurückgegeben.
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, Boolean)	Ruft den im Modul definierten benannten Typ ab, optional wird die Groß-/Kleinschreibung des Typnamens ignoriert.
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.
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.
IsDefined(Type, Boolean)	Gibt einen Wert zurück, der angibt, ob der angegebene Attributtyp auf dieses Modul angewendet wurde.
IsResource()	Ruft einen Wert ab, der angibt, ob das Objekt eine Ressource 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.
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.
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.
ResolveSignature(Int32)	Gibt das signatur-BLOB zurück, das durch ein Metadatentoken identifiziert wird.
ResolveString(Int32)	Gibt die vom angegebenen Metadatentoken identifizierte Zeichenfolge zurück.
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.
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.
ToString()	Gibt den Namen des Moduls zurück. (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.