ModuleBuilder 类

定义

定义和表示动态程序集中的模块。

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
继承
ModuleBuilder
属性
实现

示例

下面的代码示例演示如何使用 ModuleBuilder 创建动态模块。 请注意,ModuleBuilder 是通过调用 AssemblyBuilder中的 DefineDynamicModule 而不是通过构造函数创建的。

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

注解

若要获取 ModuleBuilder实例,请使用 AssemblyBuilder.DefineDynamicModule 方法。

构造函数

ModuleBuilder()

初始化 ModuleBuilder 类的新实例。

属性

Assembly

获取定义此 ModuleBuilder实例的动态程序集。

Assembly

获取此 Module实例的相应 Assembly

(继承自 Module)
CustomAttributes

获取包含此模块的自定义属性的集合。

(继承自 Module)
FullyQualifiedName

获取表示此模块的完全限定名称和路径的 String

MDStreamVersion

获取元数据流版本。

MDStreamVersion

获取元数据流版本。

(继承自 Module)
MetadataToken

获取标识元数据中当前动态模块的令牌。

MetadataToken

获取标识元数据中的模块的令牌。

(继承自 Module)
ModuleHandle

获取模块的句柄。

(继承自 Module)
ModuleVersionId

获取可用于区分模块的两个版本的通用唯一标识符(UUID)。

ModuleVersionId

获取可用于区分模块的两个版本的通用唯一标识符(UUID)。

(继承自 Module)
Name

一个字符串,指示这是内存中模块。

Name

获取一个 String,表示删除路径的模块的名称。

(继承自 Module)
ScopeName

获取表示动态模块名称的字符串。

ScopeName

获取表示模块名称的字符串。

(继承自 Module)

方法

CreateGlobalFunctions()

完成此动态模块的全局函数定义和全局数据定义。

CreateGlobalFunctionsCore()

在派生类中重写时,完成此动态模块的全局函数定义和全局数据定义。

DefineDocument(String, Guid)

定义源的文档。

DefineDocument(String, Guid, Guid, Guid)

定义源的文档。

DefineDocumentCore(String, Guid)

在派生类中重写时,定义源的文档。

DefineEnum(String, TypeAttributes, Type)

定义一个枚举类型,该类型是一个值类型,该类型具有一个名为指定类型的 value__ 的非静态字段。

DefineEnumCore(String, TypeAttributes, Type)

在派生类中重写时,定义一个枚举类型,该枚举类型是具有指定类型的单个非静态字段(称为value__)的值类型。

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

定义具有指定名称、属性、调用约定、返回类型和参数类型的全局方法。

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

定义具有指定名称、属性、调用约定、返回类型、返回类型的自定义修饰符、参数类型以及参数类型的自定义修饰符的全局方法。

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

定义具有指定名称、属性、返回类型和参数类型的全局方法。

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

在派生类中重写时,定义具有指定名称、属性、调用约定、返回类型、返回类型的自定义修饰符、参数类型和参数类型的自定义修饰符的全局方法。

DefineInitializedData(String, Byte[], FieldAttributes)

在可移植可执行文件 (PE) 文件的 .sdata 节中定义初始化的数据字段。

DefineInitializedDataCore(String, Byte[], FieldAttributes)

在派生类中重写时,在可移植可执行文件 (PE) 文件的 .sdata 节中定义初始化的数据字段。

DefineManifestResource(String, Stream, ResourceAttributes)

定义一个二进制大型对象(BLOB),该对象表示要在动态程序集中嵌入的清单资源。

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

定义一个具有指定名称、在其中定义方法的 DLL 的名称、方法的属性、方法的调用约定、方法的返回类型、方法的参数类型和 PInvoke 标志的 PInvoke 方法。

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

定义一个具有指定名称、在其中定义方法的 DLL 的名称、方法的属性、方法的调用约定、方法的返回类型、方法的参数类型和 PInvoke 标志的 PInvoke 方法。

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

在派生类中重写时,定义 PInvoke 方法。

DefineResource(String, String)

定义要存储在此模块中的命名托管嵌入式资源。

DefineResource(String, String, ResourceAttributes)

使用要存储在本模块中的给定属性定义命名的托管嵌入式资源。

DefineType(String)

为此模块中具有指定名称的专用类型构造 TypeBuilder

DefineType(String, TypeAttributes)

根据类型名称和类型属性构造 TypeBuilder

DefineType(String, TypeAttributes, Type)

构造 TypeBuilder 给定的类型名称、其属性以及定义类型扩展的类型。

DefineType(String, TypeAttributes, Type, Int32)

构造一个给定类型名称、属性、定义类型扩展的类型和类型的总大小 TypeBuilder

DefineType(String, TypeAttributes, Type, PackingSize)

根据类型名称、属性、定义类型扩展的类型以及类型的包装大小,构造 TypeBuilder

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

构造一个给定类型名称、属性、定义类型扩展的类型、定义的类型的包装大小以及定义类型的总大小 TypeBuilder

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

构造一个 TypeBuilder 给定类型名称、属性、定义类型扩展的类型以及定义类型实现的接口。

DefineTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)

在派生类中重写时,构造 TypeBuilder

DefineUninitializedData(String, Int32, FieldAttributes)

在可移植可执行文件 (PE) 文件的 .sdata 节中定义未初始化的数据字段。

DefineUninitializedDataCore(String, Int32, FieldAttributes)

在派生类中重写时,在可移植可执行文件 (PE) 文件的 .sdata 节中定义未初始化的数据字段。

DefineUnmanagedResource(Byte[])

定义给定字节的不透明二进制大型对象(BLOB)的非托管嵌入式资源。

DefineUnmanagedResource(String)

定义给定 Win32 资源文件名称的非托管资源。

Equals(Object)

返回一个值,该值指示此实例是否等于指定的对象。

Equals(Object)

确定此模块和指定的对象是否相等。

(继承自 Module)
FindTypes(TypeFilter, Object)

返回给定筛选器和筛选条件接受的类数组。

(继承自 Module)
GetArrayMethod(Type, String, CallingConventions, Type, Type[])

返回数组类上的命名方法。

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

在派生类中重写时,返回数组类上的命名方法。

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

返回数组类上命名方法的标记。

GetConstructorToken(ConstructorInfo)

返回用于标识此模块中指定构造函数的令牌。

GetConstructorToken(ConstructorInfo, IEnumerable<Type>)

返回用于标识此模块中具有指定属性和参数类型的构造函数的标记。

GetCustomAttributes(Boolean)

返回已应用于当前 ModuleBuilder的所有自定义属性。

GetCustomAttributes(Boolean)

返回所有自定义属性。

(继承自 Module)
GetCustomAttributes(Type, Boolean)

返回已应用于当前 ModuleBuilder的所有自定义属性,以及派生自指定属性类型的所有自定义属性。

GetCustomAttributes(Type, Boolean)

获取指定类型的自定义属性。

(继承自 Module)
GetCustomAttributesData()

返回已应用于当前 ModuleBuilder的属性的信息,这些属性表示为 CustomAttributeData 对象。

GetCustomAttributesData()

返回当前模块的 CustomAttributeData 对象列表,该对象可在仅反射上下文中使用。

(继承自 Module)
GetField(String)

返回具有指定名称的字段。

(继承自 Module)
GetField(String, BindingFlags)

返回在可移植可执行文件 (PE) 文件的 .sdata 区域中定义的模块级字段,该字段具有指定的名称和绑定属性。

GetField(String, BindingFlags)

返回具有指定名称和绑定属性的字段。

(继承自 Module)
GetFieldMetadataToken(FieldInfo)

在派生类中重写时,返回给定 FieldInfo 相对于模块的元数据令牌。

GetFields()

返回在模块上定义的全局字段。

(继承自 Module)
GetFields(BindingFlags)

返回在可移植可执行文件 (PE) 文件的 .sdata 区域中定义的所有字段,这些字段与指定的绑定标志匹配。

GetFields(BindingFlags)

返回在模块上定义的与指定绑定标志匹配的全局字段。

(继承自 Module)
GetFieldToken(FieldInfo)

返回用于标识此模块中的指定字段的令牌。

GetHashCode()

返回此实例的哈希代码。

GetHashCode()

返回此实例的哈希代码。

(继承自 Module)
GetMethod(String)

返回具有指定名称的方法。

(继承自 Module)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

返回具有指定名称、绑定信息、调用约定和参数类型和修饰符的方法。

(继承自 Module)
GetMethod(String, Type[])

返回具有指定名称和参数类型的方法。

(继承自 Module)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

返回与指定条件匹配的模块级方法。

GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

根据指定的条件返回方法实现。

(继承自 Module)
GetMethodMetadataToken(ConstructorInfo)

在派生类中重写时,返回给定 ConstructorInfo 相对于模块的元数据令牌。

GetMethodMetadataToken(MethodInfo)

在派生类中重写时,返回给定 MethodInfo 相对于模块的元数据令牌。

GetMethods()

返回在模块上定义的全局方法。

(继承自 Module)
GetMethods(BindingFlags)

返回在当前 ModuleBuilder的模块级别定义的所有方法,这些方法与指定的绑定标志匹配。

GetMethods(BindingFlags)

返回在模块上定义的与指定绑定标志匹配的全局方法。

(继承自 Module)
GetMethodToken(MethodInfo)

返回用于标识此模块中的指定方法的令牌。

GetMethodToken(MethodInfo, IEnumerable<Type>)

返回用于标识在此模块中具有指定属性和参数类型的方法的标记。

GetObjectData(SerializationInfo, StreamingContext)
已过时.

为序列化对象提供 ISerializable 实现。

(继承自 Module)
GetPEKind(PortableExecutableKinds, ImageFileMachine)

获取一对值,该值指示模块中的代码的性质以及模块面向的平台。

GetPEKind(PortableExecutableKinds, ImageFileMachine)

获取一对值,该值指示模块中的代码的性质以及模块面向的平台。

(继承自 Module)
GetSignatureMetadataToken(SignatureHelper)

在派生类中重写时,返回给定 SignatureHelper 相对于模块的元数据令牌。

GetSignatureToken(Byte[], Int32)

为具有指定字符数组和签名长度的签名定义令牌。

GetSignatureToken(SignatureHelper)

定义由指定 SignatureHelper定义的签名的令牌。

GetSignerCertificate()

返回一个 X509Certificate 对象,该对象对应于此模块所属程序集的 Authenticode 签名中包含的证书。 如果程序集尚未签名验证码,则返回 null

GetSignerCertificate()

返回一个 X509Certificate 对象,该对象对应于此模块所属程序集的 Authenticode 签名中包含的证书。 如果程序集尚未签名验证码,则返回 null

(继承自 Module)
GetStringConstant(String)

返回模块常量池中给定字符串的标记。

GetStringMetadataToken(String)

在派生类中重写时,返回给定 String 常量相对于模块的元数据令牌。

GetSymWriter()

返回与此动态模块关联的符号编写器。

GetType()

获取当前实例的 Type

(继承自 Object)
GetType(String)

获取模块中定义的命名类型。

GetType(String)

返回指定类型,执行区分大小写的搜索。

(继承自 Module)
GetType(String, Boolean)

获取模块中定义的命名类型,可以选择忽略类型名称大小写。

GetType(String, Boolean)

返回指定类型,使用指定的大小写搜索模块。

(继承自 Module)
GetType(String, Boolean, Boolean)

获取模块中定义的命名类型,可以选择忽略类型名称大小写。 (可选)如果未找到类型,则引发异常。

GetType(String, Boolean, Boolean)

返回指定的类型,指定是否对模块进行区分大小写的搜索,以及是否在找不到该类型时引发异常。

(继承自 Module)
GetTypeMetadataToken(Type)

在派生类中重写时,返回给定 Type 相对于模块的元数据令牌。

GetTypes()

返回在此模块中定义的所有类。

GetTypes()

返回在此模块中定义的所有类型。

(继承自 Module)
GetTypeToken(String)

返回用于标识具有指定名称的类型的标记。

GetTypeToken(Type)

返回用于标识此模块中指定类型的令牌。

IsDefined(Type, Boolean)

返回一个值,该值指示指定的属性类型是否已应用于此模块。

IsDefined(Type, Boolean)

返回一个值,该值指示指定的属性类型是否已应用于此模块。

(继承自 Module)
IsResource()

获取一个值,该值指示对象是否为资源。

IsResource()

获取一个值,该值指示对象是否为资源。

(继承自 Module)
IsTransient()

返回一个值,该值指示此动态模块是否为暂时性模块。

MemberwiseClone()

创建当前 Object的浅表副本。

(继承自 Object)
ResolveField(Int32)

返回由指定的元数据标记标识的字段。

(继承自 Module)
ResolveField(Int32, Type[], Type[])

返回由指定元数据标记标识的字段,该字段由指定的泛型类型参数定义的上下文中。

ResolveField(Int32, Type[], Type[])

返回由指定元数据标记标识的字段,该字段由指定的泛型类型参数定义的上下文中。

(继承自 Module)
ResolveMember(Int32)

返回由指定元数据令牌标识的类型或成员。

(继承自 Module)
ResolveMember(Int32, Type[], Type[])

在指定的泛型类型参数定义的上下文中,返回由指定元数据令牌标识的类型或成员。

ResolveMember(Int32, Type[], Type[])

在指定的泛型类型参数定义的上下文中,返回由指定元数据令牌标识的类型或成员。

(继承自 Module)
ResolveMethod(Int32)

返回由指定元数据令牌标识的方法或构造函数。

(继承自 Module)
ResolveMethod(Int32, Type[], Type[])

在指定的泛型类型参数定义的上下文中,返回由指定元数据标记标识的方法或构造函数。

ResolveMethod(Int32, Type[], Type[])

在指定的泛型类型参数定义的上下文中,返回由指定元数据标记标识的方法或构造函数。

(继承自 Module)
ResolveSignature(Int32)

返回由元数据令牌标识的签名 Blob。

ResolveSignature(Int32)

返回由元数据令牌标识的签名 Blob。

(继承自 Module)
ResolveString(Int32)

返回由指定的元数据标记标识的字符串。

ResolveString(Int32)

返回由指定的元数据标记标识的字符串。

(继承自 Module)
ResolveType(Int32)

返回由指定的元数据标记标识的类型。

(继承自 Module)
ResolveType(Int32, Type[], Type[])

返回由指定元数据标记标识的类型,该类型由指定的泛型类型参数定义的上下文中。

ResolveType(Int32, Type[], Type[])

返回由指定元数据标记标识的类型,该类型由指定的泛型类型参数定义的上下文中。

(继承自 Module)
SetCustomAttribute(ConstructorInfo, Byte[])

使用表示该属性的指定二进制大型对象(BLOB)将自定义属性应用于此模块。

SetCustomAttribute(CustomAttributeBuilder)

使用自定义属性生成器将自定义属性应用于此模块。

SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)

在派生类中重写时,在此程序集上设置自定义属性。

SetSymCustomAttribute(String, Byte[])

此方法不执行任何操作。

SetUserEntryPoint(MethodInfo)

设置用户入口点。

ToString()

返回模块的名称。

(继承自 Module)

显式接口实现

_Module.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

将一组名称映射到相应的调度标识符集。

(继承自 Module)
_Module.GetTypeInfo(UInt32, UInt32, IntPtr)

检索对象的类型信息,然后可用于获取接口的类型信息。

(继承自 Module)
_Module.GetTypeInfoCount(UInt32)

检索对象提供的类型信息接口数(0 或 1)。

(继承自 Module)
_Module.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

提供对对象公开的属性和方法的访问。

(继承自 Module)
_ModuleBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

有关此成员的说明,请参阅 GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

_ModuleBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

有关此成员的说明,请参阅 GetTypeInfo(UInt32, UInt32, IntPtr)

_ModuleBuilder.GetTypeInfoCount(UInt32)

有关此成员的说明,请参阅 GetTypeInfoCount(UInt32)

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

有关此成员的说明,请参阅 Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

ICustomAttributeProvider.GetCustomAttributes(Boolean)

返回此成员上定义的所有自定义属性的数组,不包括命名属性,如果没有自定义属性,则返回空数组。

(继承自 Module)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

返回在此成员上定义的自定义属性的数组(按类型标识)或空数组(如果没有该类型的自定义属性)。

(继承自 Module)
ICustomAttributeProvider.IsDefined(Type, Boolean)

指示是否在此成员上定义了一个或多个 attributeType 实例。

(继承自 Module)

扩展方法

GetCustomAttribute(Module, Type)

检索应用于指定模块的指定类型的自定义属性。

GetCustomAttribute<T>(Module)

检索应用于指定模块的指定类型的自定义属性。

GetCustomAttributes(Module)

检索应用于指定模块的自定义属性的集合。

GetCustomAttributes(Module, Type)

检索应用于指定模块的指定类型的自定义属性的集合。

GetCustomAttributes<T>(Module)

检索应用于指定模块的指定类型的自定义属性的集合。

IsDefined(Module, Type)

指示指定类型的自定义属性是否应用于指定的模块。

GetModuleVersionId(Module)

定义和表示动态程序集中的模块。

HasModuleVersionId(Module)

定义和表示动态程序集中的模块。

适用于