ModuleBuilder Třída

Reference

Definice

Obor názvů:: System.Reflection.Emit

Sestavení:: System.Reflection.Emit.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Balíček:: System.Reflection.Emit v4.7.0

Zdroj:: ModuleBuilder.cs

Zdroj:: ModuleBuilder.cs

Zdroj:: ModuleBuilder.cs

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

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

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

Dědičnost: Object

Module
ModuleBuilder

Atributy: ClassInterfaceAttribute ComVisibleAttribute

Implementuje: _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.
Assembly	Získá odpovídající Assembly pro tuto instanci Module. (Zděděno od Module)
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.
MDStreamVersion	Získá verzi streamu metadat. (Zděděno od Module)
MetadataToken	Získá token, který identifikuje aktuální dynamický modul v metadatech.
MetadataToken	Získá token, který identifikuje modul v metadatech. (Zděděno od Module)
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.
ModuleVersionId	Získá univerzální jedinečný identifikátor (UUID), který lze použít k rozlišení mezi dvěma verzemi modulu. (Zděděno od Module)
Name	Řetězec, který označuje, že se jedná o modul v paměti.
Name	Získá `String` představující název modulu s odebranou cestou. (Zděděno od Module)
ScopeName	Získá řetězec, který představuje název dynamického modulu.
ScopeName	Získá řetězec představující název modulu. (Zděděno od Module)

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.
DefineDocument(String, Guid)	Definuje dokument pro zdroj.
DefineDocument(String, Guid, Guid, Guid)	Definuje dokument pro zdroj.
DefineDocumentCore(String, Guid)	Při přepsání v odvozené třídě definuje dokument pro zdroj.
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).
DefineManifestResource(String, Stream, ResourceAttributes)	Definuje binární rozsáhlý objekt (BLOB), který představuje prostředek manifestu, který se má vložit do dynamického sestavení.
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.
DefineResource(String, String)	Definuje pojmenovaný spravovaný vložený prostředek, který se má v tomto modulu uložit.
DefineResource(String, String, ResourceAttributes)	Definuje pojmenovaný spravovaný vložený prostředek s danými atributy, které mají být uloženy v tomto modulu.
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).
DefineUnmanagedResource(Byte[])	Definuje nespravovaný vložený prostředek vzhledem k neprůkazným binárnímu rozsáhlému objektu (BLOB) bajtů.
DefineUnmanagedResource(String)	Definuje nespravovaný prostředek s názvem souboru prostředků Win32.
Equals(Object)	Vrátí hodnotu, která určuje, zda je tato instance rovna zadanému objektu.
Equals(Object)	Určuje, zda je tento modul a zadaný objekt stejné. (Zděděno od Module)
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.
GetArrayMethodToken(Type, String, CallingConventions, Type, Type[])	Vrátí token pojmenované metody v maticové třídě.
GetConstructorToken(ConstructorInfo)	Vrátí token použitý k identifikaci zadaného konstruktoru v rámci tohoto modulu.
GetConstructorToken(ConstructorInfo, IEnumerable<Type>)	Vrátí token použitý k identifikaci konstruktoru, který má zadané atributy a typy parametrů v rámci tohoto modulu.
GetCustomAttributes(Boolean)	Vrátí všechny vlastní atributy, které byly použity na aktuální ModuleBuilder.
GetCustomAttributes(Boolean)	Vrátí všechny vlastní atributy. (Zděděno od Module)
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.
GetCustomAttributes(Type, Boolean)	Získá vlastní atributy zadaného typu. (Zděděno od Module)
GetCustomAttributesData()	Vrátí informace o atributech, které byly použity na aktuální ModuleBuilder, vyjádřeno jako CustomAttributeData objekty.
GetCustomAttributesData()	Vrátí seznam CustomAttributeData objektů pro aktuální modul, který lze použít pouze v kontextu reflexe. (Zděděno od Module)
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.
GetField(String, BindingFlags)	Vrátí pole se zadaným názvem a atributy vazby. (Zděděno od Module)
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.
GetFields(BindingFlags)	Vrátí globální pole definovaná v modulu, která odpovídají zadaným příznakům vazby. (Zděděno od Module)
GetFieldToken(FieldInfo)	Vrátí token použitý k identifikaci zadaného pole v rámci tohoto modulu.
GetHashCode()	Vrátí kód hash pro tuto instanci.
GetHashCode()	Vrátí kód hash pro tuto instanci. (Zděděno od Module)
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.
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Vrátí implementaci metody v souladu se zadanými kritérii. (Zděděno od Module)
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.
GetMethods(BindingFlags)	Vrátí globální metody definované v modulu, které odpovídají zadaným příznakům vazby. (Zděděno od Module)
GetMethodToken(MethodInfo)	Vrátí token použitý k identifikaci zadané metody v rámci tohoto modulu.
GetMethodToken(MethodInfo, IEnumerable<Type>)	Vrátí token použitý k identifikaci metody, která má zadané atributy a typy parametrů v tomto modulu.
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í.
GetPEKind(PortableExecutableKinds, ImageFileMachine)	Získá dvojici hodnot označující povahu kódu v modulu a platformu, na kterou modul cílí. (Zděděno od Module)
GetSignatureMetadataToken(SignatureHelper)	Při přepsání v odvozené třídě vrátí token metadat pro danou SignatureHelper vzhledem k modulu.
GetSignatureToken(Byte[], Int32)	Definuje token pro podpis, který má zadanou matici znaků a délku podpisu.
GetSignatureToken(SignatureHelper)	Definuje token pro podpis definovaný zadaným SignatureHelper.
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í.
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)
GetStringConstant(String)	Vrátí token daného řetězce ve fondu konstant modulu.
GetStringMetadataToken(String)	Při přepsání v odvozené třídě vrátí token metadat pro danou String konstantu vzhledem k modulu.
GetSymWriter()	Vrátí zapisovač symbolů přidružený k tomuto dynamickému modulu.
GetType()	Získá Type aktuální instance. (Zděděno od Object)
GetType(String)	Získá pojmenovaný typ definovaný v modulu.
GetType(String)	Vrátí zadaný typ, který provádí vyhledávání s rozlišováním velkých a malých písmen. (Zděděno od Module)
GetType(String, Boolean)	Získá pojmenovaný typ definovaný v modulu, volitelně ignorování případu názvu typu.
GetType(String, Boolean)	Vrátí zadaný typ a prohledá modul se zadanou citlivostí malých a malých písmen. (Zděděno od Module)
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.
GetType(String, Boolean, Boolean)	Vrátí zadaný typ, který určuje, zda se má modul vyhledat s rozlišováním malých a malých písmen a zda se má vyvolat výjimka, pokud typ nebyl nalezen. (Zděděno od Module)
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.
GetTypes()	Vrátí všechny typy definované v rámci tohoto modulu. (Zděděno od Module)
GetTypeToken(String)	Vrátí token použitý k identifikaci typu se zadaným názvem.
GetTypeToken(Type)	Vrátí token použitý k identifikaci zadaného typu v rámci tohoto modulu.
IsDefined(Type, Boolean)	Vrátí hodnotu, která určuje, zda byl zadaný typ atributu použit v tomto modulu.
IsDefined(Type, Boolean)	Vrátí hodnotu, která určuje, zda byl zadaný typ atributu použit v tomto modulu. (Zděděno od Module)
IsResource()	Získá hodnotu určující, zda objekt je prostředek.
IsResource()	Získá hodnotu určující, zda objekt je prostředek. (Zděděno od Module)
IsTransient()	Vrátí hodnotu, která určuje, jestli je tento dynamický modul přechodný.
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.
ResolveField(Int32, Type[], Type[])	Vrátí pole identifikované zadaným tokenem metadat v kontextu definovaném zadanými parametry obecného typu. (Zděděno od Module)
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.
ResolveMember(Int32, Type[], Type[])	Vrátí typ nebo člen identifikovaný zadaným tokenem metadat v kontextu definovaném zadanými parametry obecného typu. (Zděděno od Module)
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.
ResolveMethod(Int32, Type[], Type[])	Vrátí metodu nebo konstruktor identifikovaný zadaným tokenem metadat v kontextu definovaném zadanými parametry obecného typu. (Zděděno od Module)
ResolveSignature(Int32)	Vrátí objekt blob podpisu identifikovaný tokenem metadat.
ResolveSignature(Int32)	Vrátí objekt blob podpisu identifikovaný tokenem metadat. (Zděděno od Module)
ResolveString(Int32)	Vrátí řetězec identifikovaný zadaným tokenem metadat.
ResolveString(Int32)	Vrátí řetězec identifikovaný zadaným tokenem metadat. (Zděděno od Module)
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.
ResolveType(Int32, Type[], Type[])	Vrátí typ identifikovaný zadaným tokenem metadat v kontextu definovaném zadanými parametry obecného typu. (Zděděno od Module)
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í.
SetSymCustomAttribute(String, Byte[])	Tato metoda nic nedělá.
SetUserEntryPoint(MethodInfo)	Nastaví vstupní bod uživatele.
ToString()	Vrátí název modulu. (Zděděno od Module)

Explicitní implementace rozhraní

_Module.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mapuje sadu názvů na odpovídající sadu identifikátorů odeslání. (Zděděno od Module)
_Module.GetTypeInfo(UInt32, UInt32, IntPtr)	Načte informace o typu objektu, který lze použít k získání informací o typu rozhraní. (Zděděno od Module)
_Module.GetTypeInfoCount(UInt32)	Načte počet rozhraní informací o typu, která objekt poskytuje (buď 0, nebo 1). (Zděděno od Module)
_Module.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Poskytuje přístup k vlastnostem a metodám vystaveným objektem. (Zděděno od Module)
_ModuleBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Popis tohoto člena najdete v tématu GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr).
_ModuleBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)	Popis tohoto člena najdete v tématu GetTypeInfo(UInt32, UInt32, IntPtr).
_ModuleBuilder.GetTypeInfoCount(UInt32)	Popis tohoto člena najdete v tématu GetTypeInfoCount(UInt32).
_ModuleBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Popis tohoto člena najdete v tématu Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr).
ICustomAttributeProvider.GetCustomAttributes(Boolean)	Vrátí pole všech vlastních atributů definovaných pro tohoto člena, s výjimkou pojmenovaných atributů, nebo prázdné pole, pokud neexistují žádné vlastní atributy. (Zděděno od Module)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)	Vrátí pole vlastních atributů definovaných pro tento člen, identifikovaný podle typu nebo prázdné pole, pokud neexistují žádné vlastní atributy tohoto typu. (Zděděno od Module)
ICustomAttributeProvider.IsDefined(Type, Boolean)	Určuje, zda je u tohoto člena definována jedna nebo více instancí `attributeType`. (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í.

Platí pro

Sdílet prostřednictvím