ModuleBuilder Třída

Definice

Definuje a představuje modul v dynamickém sestavení.Defines and represents a module in a dynamic assembly.

public ref 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
    interface _ModuleBuilder
Public Class ModuleBuilder
Inherits Module
Implements _ModuleBuilder
Dědičnost
ModuleBuilder
Atributy
Implementuje

Příklady

Následující příklad kódu ukazuje použití ModuleBuilder nástroje k vytvoření dynamického modulu.The following code sample demonstrates the use of ModuleBuilder to create a dynamic module. Všimněte si, že modul ModuleBuilder je vytvořena DefineDynamicModule voláním AssemblyBuilderv, nikoli prostřednictvím konstruktoru.Note that the ModuleBuilder is created by calling DefineDynamicModule in AssemblyBuilder, rather than through a constructor.

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
{
   [PermissionSetAttribute(SecurityAction.Demand, Name="FullTrust")]
   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

Chcete-li získat instanci ModuleBuilder, AssemblyBuilder.DefineDynamicModule použijte metodu.To get an instance of ModuleBuilder, use the AssemblyBuilder.DefineDynamicModule method.

Konstruktory

ModuleBuilder()

Vlastnosti

Assembly

Získá dynamické sestavení, které definuje tuto instanci ModuleBuilder.Gets the dynamic assembly that defined this instance of ModuleBuilder.

CustomAttributes

Získá kolekci, která obsahuje vlastní atributy tohoto modulu.Gets a collection that contains this module's custom attributes.

(Zděděno od Module)
FullyQualifiedName

String Získá představující plně kvalifikovaný název a cestu k tomuto modulu.Gets a String representing the fully qualified name and path to this module.

MDStreamVersion

Získá verzi streamu metadat.Gets the metadata stream version.

MetadataToken

Získá token, který identifikuje aktuální dynamický modul v metadatech.Gets a token that identifies the current dynamic module in metadata.

ModuleHandle

Získá popisovač pro modul.Gets a handle for the module.

(Zděděno od Module)
ModuleVersionId

Získá univerzálně jedinečný identifikátor (UUID), který se dá použít k rozlišení dvou verzí modulu.Gets a universally unique identifier (UUID) that can be used to distinguish between two versions of a module.

Name

Řetězec, který označuje, že se jedná o modul v paměti.A string that indicates that this is an in-memory module.

ScopeName

Načte řetězec, který představuje název dynamického modulu.Gets a string that represents the name of the dynamic module.

Metody

CreateGlobalFunctions()

Dokončí definice globálních funkcí a globální definice dat pro tento dynamický modul.Completes the global function definitions and global data definitions for this dynamic module.

DefineDocument(String, Guid, Guid, Guid)

Definuje dokument pro zdroj.Defines a document for source.

DefineEnum(String, TypeAttributes, Type)

Definuje typ výčtu, který je hodnotový typ s jedním nestatickým polem, které value__ se zavolalo z určeného typu.Defines an enumeration type that is a value type with a single non-static field called value__ of the specified type.

DefineGlobalMethod(String, MethodAttributes, CallingConventions, Type, Type[])

Definuje globální metodu se zadaným názvem, atributy, konvencí volání, návratový typ a typy parametrů.Defines a global method with the specified name, attributes, calling convention, return type, and parameter types.

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ý typ, vlastní modifikátory pro návratový typ, typy parametrů a vlastní modifikátory pro typy parametrů.Defines a global method with the specified name, attributes, calling convention, return type, custom modifiers for the return type, parameter types, and custom modifiers for the parameter types.

DefineGlobalMethod(String, MethodAttributes, Type, Type[])

Definuje globální metodu se zadaným názvem, atributy, návratovým typem a typy parametrů.Defines a global method with the specified name, attributes, return type, and parameter types.

DefineInitializedData(String, Byte[], FieldAttributes)

Definuje inicializovaná datová pole v oddílu. sdata souboru přenositelného spustitelného souboru (PE).Defines an initialized data field in the .sdata section of the portable executable (PE) file.

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í.Defines a binary large object (BLOB) that represents a manifest resource to be embedded in the dynamic assembly.

DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)

PInvoke Definuje metodu se zadaným názvem, název knihovny DLL, ve které je metoda definována, atributy metody, konvence volání metody, návratový typ metody, typy parametrů metody a PInvoke..příznaky.Defines a PInvoke method with the specified name, the name of the DLL in which the method is defined, the attributes of the method, the calling convention of the method, the return type of the method, the types of the parameters of the method, and the PInvoke flags.

DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)

PInvoke Definuje metodu se zadaným názvem, název knihovny DLL, ve které je metoda definována, atributy metody, konvence volání metody, návratový typ metody, typy parametrů metody a PInvoke..příznaky.Defines a PInvoke method with the specified name, the name of the DLL in which the method is defined, the attributes of the method, the calling convention of the method, the return type of the method, the types of the parameters of the method, and the PInvoke flags.

DefineResource(String, String)

Definuje pojmenovaný spravovaný prostředek, který se uloží v tomto modulu.Defines the named managed embedded resource to be stored in this module.

DefineResource(String, String, ResourceAttributes)

Definuje pojmenovaný spravovaný prostředek se zadaným atributem, který se má uložit v tomto modulu.Defines the named managed embedded resource with the given attributes that is to be stored in this module.

DefineType(String)

TypeBuilder Vytvoří pro privátní typ se zadaným názvem v tomto modulu.Constructs a TypeBuilder for a private type with the specified name in this module.

DefineType(String, TypeAttributes)

TypeBuilder Vytvoří daný název typu a atributy typu.Constructs a TypeBuilder given the type name and the type attributes.

DefineType(String, TypeAttributes, Type)

TypeBuilder Vytvoří daný název typu, jeho atributy a typ, který rozšiřuje definovaný typ.Constructs a TypeBuilder given type name, its attributes, and the type that the defined type extends.

DefineType(String, TypeAttributes, Type, Int32)

Sestaví TypeBuilder daný název typu, atributy, typ, který definovaný typ rozšiřuje, a celkovou velikost typu.Constructs a TypeBuilder given the type name, the attributes, the type that the defined type extends, and the total size of the type.

DefineType(String, TypeAttributes, Type, PackingSize)

Sestaví TypeBuilder daný název typu, atributy, typ, který definovaný typ rozšiřuje, a velikost balení typu.Constructs a TypeBuilder given the type name, the attributes, the type that the defined type extends, and the packing size of the type.

DefineType(String, TypeAttributes, Type, PackingSize, Int32)

Sestaví TypeBuilder daný typ název, atributy, typ, který definuje definovaný typ, velikost balení definovaného typu a celkovou velikost definovaného typu.Constructs a TypeBuilder given the type name, attributes, the type that the defined type extends, the packing size of the defined type, and the total size of the defined type.

DefineType(String, TypeAttributes, Type, Type[])

Sestaví TypeBuilder daný typ název, atributy, typ, který definuje definovaný typ, a rozhraní, které definovaný typ implementuje.Constructs a TypeBuilder given the type name, attributes, the type that the defined type extends, and the interfaces that the defined type implements.

DefineUninitializedData(String, Int32, FieldAttributes)

Definuje neinicializované datové pole v oddílu. sdata přenosného spustitelného souboru (PE).Defines an uninitialized data field in the .sdata section of the portable executable (PE) file.

DefineUnmanagedResource(Byte[])

Definuje nespravovaný vložený prostředek, který má přiřazený neprůhledný binární rozsáhlý objekt (BLOB) bajtů.Defines an unmanaged embedded resource given an opaque binary large object (BLOB) of bytes.

DefineUnmanagedResource(String)

Definuje nespravovaný prostředek s názvem souboru prostředků Win32.Defines an unmanaged resource given the name of Win32 resource file.

Equals(Object)

Vrátí hodnotu, která označuje, zda je tato instance rovna zadanému objektu.Returns a value that indicates whether this instance is equal to the specified object.

FindTypes(TypeFilter, Object)

Vrátí pole tříd přijaté danými kritérii filtru a filtru.Returns an array of classes accepted by the given filter and filter criteria.

(Zděděno od Module)
GetArrayMethod(Type, String, CallingConventions, Type, Type[])

Vrátí pojmenovanou metodu třídy Array.Returns the named method on an array class.

GetArrayMethodToken(Type, String, CallingConventions, Type, Type[])

Vrátí token pro pojmenovanou metodu pro třídu Array.Returns the token for the named method on an array class.

GetConstructorToken(ConstructorInfo)

Vrátí token použitý k identifikaci zadaného konstruktoru v rámci tohoto modulu.Returns the token used to identify the specified constructor within this module.

GetConstructorToken(ConstructorInfo, IEnumerable<Type>)

Vrátí token použitý k identifikaci konstruktoru, který má zadané atributy a typy parametrů v rámci tohoto modulu.Returns the token used to identify the constructor that has the specified attributes and parameter types within this module.

GetCustomAttributes(Boolean)

Vrátí všechny vlastní atributy, které byly aplikovány na aktuální ModuleBuilder.Returns all the custom attributes that have been applied to the current ModuleBuilder.

GetCustomAttributes(Type, Boolean)

Vrátí všechny vlastní atributy, které byly aplikovány na aktuální ModuleBuildera které jsou odvozeny ze zadaného typu atributu.Returns all the custom attributes that have been applied to the current ModuleBuilder, and that derive from a specified attribute type.

GetCustomAttributesData()

Vrátí informace o atributech, které byly aplikovány na aktuální ModuleBuilder, vyjádřené CustomAttributeData jako objekty.Returns information about the attributes that have been applied to the current ModuleBuilder, expressed as CustomAttributeData objects.

GetField(String)

Vrátí pole se zadaným názvem.Returns a field having the specified name.

(Zděděno od Module)
GetField(String, BindingFlags)

Vrátí pole na úrovni modulu definované v oblasti. sdata souboru přenositelného spustitelného souboru (PE), který má zadaný název a atributy vazby.Returns a module-level field, defined in the .sdata region of the portable executable (PE) file, that has the specified name and binding attributes.

GetFields()

Vrátí globální pole definovaná v modulu.Returns the global fields defined on the module.

(Zděděno od Module)
GetFields(BindingFlags)

Vrátí všechna pole definovaná v oblasti. sdata souboru přenositelného spustitelného souboru (PE), která odpovídá zadaným příznakům vazby.Returns all fields defined in the .sdata region of the portable executable (PE) file that match the specified binding flags.

GetFieldToken(FieldInfo)

Vrátí token použitý k identifikaci zadaného pole v rámci tohoto modulu.Returns the token used to identify the specified field within this module.

GetHashCode()

Vrátí kód hash této instance.Returns the hash code for this instance.

GetMethod(String)

Vrátí metodu se zadaným názvem.Returns a method having the specified name.

(Zděděno od Module)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Vrátí metodu, která má zadaný název, informace o vazbě, konvenci volání a typy parametrů a modifikátory.Returns a method having the specified name, binding information, calling convention, and parameter types and modifiers.

(Zděděno od Module)
GetMethod(String, Type[])

Vrátí metodu se zadaným názvem a typy parametrů.Returns a method having the specified name and parameter types.

(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.Returns the module-level method that matches the specified criteria.

GetMethods()

Vrátí globální metody definované v modulu.Returns the global methods defined on the module.

(Zděděno od Module)
GetMethods(BindingFlags)

Vrátí všechny metody, které byly definovány na úrovni modulu pro aktuální ModuleBuildera které odpovídají zadaným příznakům vazby.Returns all the methods that have been defined at the module level for the current ModuleBuilder, and that match the specified binding flags.

GetMethodToken(MethodInfo)

Vrátí token použitý k identifikaci zadané metody v rámci tohoto modulu.Returns the token used to identify the specified method within this module.

GetMethodToken(MethodInfo, IEnumerable<Type>)

Vrátí token použitý k identifikaci metody, která má zadané atributy a typy parametrů v rámci tohoto modulu.Returns the token used to identify the method that has the specified attributes and parameter types within this module.

GetObjectData(SerializationInfo, StreamingContext)

Poskytuje ISerializable implementaci pro Serializované objekty.Provides an ISerializable implementation for serialized objects.

(Zděděno od Module)
GetPEKind(PortableExecutableKinds, ImageFileMachine)

Načte dvojici hodnot, které označují povahu kódu v modulu, a platformu, na kterou cílí modul.Gets a pair of values indicating the nature of the code in a module and the platform targeted by the module.

GetSignatureToken(Byte[], Int32)

Definuje token pro podpis, který má zadané pole znaků a délku podpisu.Defines a token for the signature that has the specified character array and signature length.

GetSignatureToken(SignatureHelper)

Definuje token pro podpis, který je definován zadaným SignatureHelper.Defines a token for the signature that is defined by the specified SignatureHelper.

GetSignerCertificate()

X509Certificate Vrátí objekt odpovídající certifikátu obsaženému v podpisu Authenticode sestavení, do kterého tento modul patří.Returns an X509Certificate object corresponding to the certificate included in the Authenticode signature of the assembly which this module belongs to. Pokud sestavení nebylo podepsáno technologií Authenticode, null je vráceno.If the assembly has not been Authenticode signed, null is returned.

GetStringConstant(String)

Vrátí token daného řetězce v konstantním fondu modulu.Returns the token of the given string in the module's constant pool.

GetSymWriter()

Vrátí zapisovač symbolů přidružený k tomuto dynamickému modulu.Returns the symbol writer associated with this dynamic module.

GetType()

Získá Type aktuální instance.Gets the Type of the current instance.

(Zděděno od Object)
GetType(String)

Získá pojmenovaný typ definovaný v modulu.Gets the named type defined in the module.

GetType(String, Boolean)

Získá pojmenovaný typ definovaný v modulu, volitelně ignoruje případ názvu typu.Gets the named type defined in the module, optionally ignoring the case of the type name.

GetType(String, Boolean, Boolean)

Získá pojmenovaný typ definovaný v modulu, volitelně ignoruje případ názvu typu.Gets the named type defined in the module, optionally ignoring the case of the type name. Volitelně vyvolá výjimku, pokud typ nebyl nalezen.Optionally throws an exception if the type is not found.

GetTypes()

Vrátí všechny třídy definované v rámci tohoto modulu.Returns all the classes defined within this module.

GetTypeToken(String)

Vrátí token použitý k identifikaci typu se zadaným názvem.Returns the token used to identify the type with the specified name.

GetTypeToken(Type)

Vrátí token použitý k identifikaci zadaného typu v rámci tohoto modulu.Returns the token used to identify the specified type within this module.

IsDefined(Type, Boolean)

Vrátí hodnotu, která označuje, zda byl zadaný typ atributu použit pro tento modul.Returns a value that indicates whether the specified attribute type has been applied to this module.

IsResource()

Načte hodnotu, která označuje, zda je objekt prostředkem.Gets a value indicating whether the object is a resource.

IsTransient()

Vrátí hodnotu, která označuje, zda je tento dynamický modul přechodný.Returns a value that indicates whether this dynamic module is transient.

MemberwiseClone()

Vytvoří kopii aktuálního Objectbez podstruktury.Creates a shallow copy of the current Object.

(Zděděno od Object)
ResolveField(Int32)

Vrátí pole identifikované zadaným tokenem metadat.Returns the field identified by the specified metadata token.

(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.Returns the field identified by the specified metadata token, in the context defined by the specified generic type parameters.

ResolveMember(Int32)

Vrátí typ nebo člen identifikovaný zadaným tokenem metadat.Returns the type or member identified by the specified metadata token.

(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.Returns the type or member identified by the specified metadata token, in the context defined by the specified generic type parameters.

ResolveMethod(Int32)

Vrátí metodu nebo konstruktor identifikovaný zadaným tokenem metadat.Returns the method or constructor identified by the specified metadata token.

(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.Returns the method or constructor identified by the specified metadata token, in the context defined by the specified generic type parameters.

ResolveSignature(Int32)

Vrátí objekt BLOB podpisu identifikovaný tokenem metadat.Returns the signature blob identified by a metadata token.

ResolveString(Int32)

Vrátí řetězec identifikovaný zadaným tokenem metadat.Returns the string identified by the specified metadata token.

ResolveType(Int32)

Vrátí typ identifikovaný zadaným tokenem metadat.Returns the type identified by the specified metadata token.

(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.Returns the type identified by the specified metadata token, in the context defined by the specified generic type parameters.

SetCustomAttribute(ConstructorInfo, Byte[])

Použije vlastní atribut na tento modul pomocí zadaného binárního rozsáhlého objektu (BLOB), který představuje atribut.Applies a custom attribute to this module by using a specified binary large object (BLOB) that represents the attribute.

SetCustomAttribute(CustomAttributeBuilder)

Aplikuje vlastní atribut na tento modul pomocí vlastního tvůrce atributů.Applies a custom attribute to this module by using a custom attribute builder.

SetSymCustomAttribute(String, Byte[])

Tato metoda nedělá nic.This method does nothing.

SetUserEntryPoint(MethodInfo)

Nastaví vstupní bod uživatele.Sets the user entry point.

ToString()

Vrátí název modulu.Returns the name of the module.

(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ů pro rozesílání.Maps a set of names to a corresponding set of dispatch identifiers.

(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 pro rozhraní.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(Zděděno od Module)
_Module.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).Retrieves the number of type information interfaces that an object provides (either 0 or 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.Provides access to properties and methods exposed by an object.

(Zděděno od Module)
_ModuleBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Popis tohoto člena naleznete v tématu GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr).For a description of this member, see GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr).

_ModuleBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

Popis tohoto člena naleznete v tématu GetTypeInfo(UInt32, UInt32, IntPtr).For a description of this member, see GetTypeInfo(UInt32, UInt32, IntPtr).

_ModuleBuilder.GetTypeInfoCount(UInt32)

Popis tohoto člena naleznete v tématu GetTypeInfoCount(UInt32).For a description of this member, see GetTypeInfoCount(UInt32).

_ModuleBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Popis tohoto člena naleznete v tématu Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr).For a description of this member, see Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr).

ICustomAttributeProvider.GetCustomAttributes(Boolean) (Zděděno od Module)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean) (Zděděno od Module)
ICustomAttributeProvider.IsDefined(Type, Boolean) (Zděděno od Module)

Metody rozšíření

GetCustomAttribute(Module, Type)

Načte vlastní atribut zadaného typu, který je použit pro zadaný modul.Retrieves a custom attribute of a specified type that is applied to a specified module.

GetCustomAttribute<T>(Module)

Načte vlastní atribut zadaného typu, který je použit pro zadaný modul.Retrieves a custom attribute of a specified type that is applied to a specified module.

GetCustomAttributes(Module)

Načte kolekci vlastních atributů, které se aplikují na zadaný modul.Retrieves a collection of custom attributes that are applied to a specified module.

GetCustomAttributes(Module, Type)

Načte kolekci vlastních atributů zadaného typu, které se aplikují na zadaný modul.Retrieves a collection of custom attributes of a specified type that are applied to a specified module.

GetCustomAttributes<T>(Module)

Načte kolekci vlastních atributů zadaného typu, které se aplikují na zadaný modul.Retrieves a collection of custom attributes of a specified type that are applied to a specified module.

IsDefined(Module, Type)

Určuje, zda jsou v zadaném modulu aplikovány vlastní atributy zadaného typu.Indicates whether custom attributes of a specified type are applied to a specified module.

GetModuleVersionId(Module)
HasModuleVersionId(Module)

Platí pro