TypeBuilder.CreateType 方法
定义
重要
一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。 对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。
创建类的 Type 对象。 定义了类的字段和方法后，调用 CreateType 以加载其 Type 对象。
public:
Type ^ CreateType();public Type? CreateType ();public Type CreateType ();member this.CreateType : unit -> TypePublic Function CreateType () As Type返回
为此类返回新的 Type 对象。
例外
ILGenerator 中的错误标签内容：你定义了一个不调用 MarkLabel(Label) 的标签。
此类型包含无效的 Microsoft 中间语言 (MSIL) 代码。
- 或 -
分支目标使用 1 个字节的偏移量指定，但目标离分支的距离大于 127 个字节。
无法加载此类型。 例如，它包含具有调用约定 HasThis 的 static 方法。
示例
下面的代码示例演示如何为 AppDomain.TypeResolve 事件定义事件处理程序，以便在对封闭类型调用 CreateType 期间 CreateType 对嵌套类型调用 方法。
using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Threading;
using namespace System::Text;
using namespace System::Resources;
using namespace System::Collections;
using namespace System::IO;
// Helper class called when a resolve type event is raised.
ref class TypeResolveHandler
{
private:
Module^ m_Module;
public:
TypeResolveHandler( Module^ mod )
{
m_Module = mod;
}
Assembly^ ResolveEvent( Object^ sender, ResolveEventArgs^ args );
};
ref class NestedEnum
{
internal:
static TypeBuilder^ enumType = nullptr;
static Type^ tNested = nullptr;
static Type^ tNesting = nullptr;
public:
static void Main()
{
AssemblyName^ asmName = gcnew AssemblyName;
asmName->Name = "NestedEnum";
AssemblyBuilder^ asmBuild = Thread::GetDomain()->DefineDynamicAssembly( asmName, AssemblyBuilderAccess::RunAndSave );
ModuleBuilder^ modBuild = asmBuild->DefineDynamicModule( "ModuleOne", "NestedEnum.dll" );
// Hook up the event listening.
TypeResolveHandler^ typeResolveHandler = gcnew TypeResolveHandler( modBuild );
// Add a listener for the type resolve events.
AppDomain^ currentDomain = Thread::GetDomain();
ResolveEventHandler^ resolveHandler = gcnew ResolveEventHandler( typeResolveHandler, &TypeResolveHandler::ResolveEvent );
currentDomain->TypeResolve += resolveHandler;
TypeBuilder^ tb = modBuild->DefineType( "AType", TypeAttributes::Public );
TypeBuilder^ eb = tb->DefineNestedType( "AnEnum", static_cast<TypeAttributes>(TypeAttributes::NestedPublic | TypeAttributes::Sealed), Enum::typeid, 0 );
eb->DefineField( "value__", int::typeid, static_cast<FieldAttributes>(FieldAttributes::Private | FieldAttributes::SpecialName) );
FieldBuilder^ fb = eb->DefineField( "Field1", eb, static_cast<FieldAttributes>(FieldAttributes::Public | FieldAttributes::Literal | FieldAttributes::Static) );
fb->SetConstant( 1 );
enumType = eb;
// Comment out this field.
// When this field is defined, the loader cannot determine the size
// of the type. Therefore, a TypeResolve event is generated when the
// nested type is completed.
tb->DefineField( "Field2", eb, FieldAttributes::Public );
tNesting = tb->CreateType();
if ( tNesting == nullptr )
Console::WriteLine( "NestingType CreateType failed but didn't throw!" );
try
{
tNested = eb->CreateType();
if ( tNested == nullptr )
Console::WriteLine( "NestedType CreateType failed but didn't throw!" );
}
catch ( Exception^ )
{
// This is needed because you might have already completed the type in the TypeResolve event.
}
if ( tNested != nullptr )
{
Type^ x = tNested->DeclaringType;
if ( x == nullptr )
Console::WriteLine( "Declaring type is null." );
else
Console::WriteLine( x->Name );
}
asmBuild->Save( "NestedEnum.dll" );
// Remove the listener for the type resolve events.
currentDomain->TypeResolve -= resolveHandler;
}
};
Assembly^ TypeResolveHandler::ResolveEvent( Object^ sender, ResolveEventArgs^ args )
{
Console::WriteLine( args->Name );
// Use args.Name to look up the type name. In this case, you are getting AnEnum.
try
{
NestedEnum::tNested = NestedEnum::enumType->CreateType();
}
catch ( Exception^ )
{
// This is needed to throw away InvalidOperationException.
// Loader might send the TypeResolve event more than once
// and the type might be complete already.
}
// Complete the type.
return m_Module->Assembly;
}
int main()
{
NestedEnum::Main();
}
using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading;
using System.Text;
using System.Resources;
using System.Collections;
using System.IO;
internal class NestedEnum {
internal static TypeBuilder enumType = null;
internal static Type tNested = null;
internal static Type tNesting = null;
public static void Main(String[] args) {
AssemblyName asmName = new AssemblyName();
asmName.Name = "NestedEnum";
AssemblyBuilder asmBuild = Thread.GetDomain().DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave);
ModuleBuilder modBuild = asmBuild.DefineDynamicModule("ModuleOne", "NestedEnum.dll");
// Hook up the event listening.
TypeResolveHandler typeResolveHandler = new TypeResolveHandler(modBuild);
// Add a listener for the type resolve events.
AppDomain currentDomain = Thread.GetDomain();
ResolveEventHandler resolveHandler = new ResolveEventHandler(typeResolveHandler.ResolveEvent);
currentDomain.TypeResolve += resolveHandler;
TypeBuilder tb = modBuild.DefineType("AType", TypeAttributes.Public);
TypeBuilder eb = tb.DefineNestedType("AnEnum", TypeAttributes.NestedPublic | TypeAttributes.Sealed, typeof(Enum), null);
eb.DefineField("value__", typeof(int), FieldAttributes.Private | FieldAttributes.SpecialName);
FieldBuilder fb = eb.DefineField("Field1", eb, FieldAttributes.Public | FieldAttributes.Literal | FieldAttributes.Static);
fb.SetConstant(1);
enumType = eb;
// Comment out this field.
// When this field is defined, the loader cannot determine the size
// of the type. Therefore, a TypeResolve event is generated when the
// nested type is completed.
tb.DefineField("Field2", eb, FieldAttributes.Public);
tNesting = tb.CreateType();
if (tNesting == null)
Console.WriteLine("NestingType CreateType failed but didn't throw!");
try {
tNested = eb.CreateType();
if (tNested == null)
Console.WriteLine("NestedType CreateType failed but didn't throw!");
}
catch {
// This is needed because you might have already completed the type in the TypeResolve event.
}
if (tNested != null) {
Type x = tNested.DeclaringType;
if (x == null)
Console.WriteLine("Declaring type was null.");
else
Console.WriteLine(x.Name);
}
asmBuild.Save( "NestedEnum.dll" );
// Remove the listener for the type resolve events.
currentDomain.TypeResolve -= resolveHandler;
}
}
// Helper class called when a resolve type event is raised.
internal class TypeResolveHandler
{
private Module m_Module;
public TypeResolveHandler(Module mod)
{
m_Module = mod;
}
public Assembly ResolveEvent(Object sender, ResolveEventArgs args)
{
Console.WriteLine(args.Name);
// Use args.Name to look up the type name. In this case, you are getting AnEnum.
try {
NestedEnum.tNested = NestedEnum.enumType.CreateType();
}
catch {
// This is needed to throw away InvalidOperationException.
// Loader might send the TypeResolve event more than once
// and the type might be complete already.
}
// Complete the type.
return m_Module.Assembly;
}
}
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Threading
Imports System.Text
Imports System.Resources
Imports System.Collections
Imports System.IO
Friend Class NestedEnum
Friend Shared enumType As TypeBuilder = Nothing
Friend Shared tNested As Type = Nothing
Friend Shared tNesting As Type = Nothing
Public Shared Sub Main()
Dim asmName As New AssemblyName()
asmName.Name = "NestedEnum"
Dim asmBuild As AssemblyBuilder = Thread.GetDomain().DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave)
Dim modBuild As ModuleBuilder = asmBuild.DefineDynamicModule("ModuleOne", "NestedEnum.dll")
' Hook up the event listening.
Dim typeResolveHandler As New TypeResolveHandler(modBuild)
' Add a listener for the type resolve events.
Dim currentDomain As AppDomain = Thread.GetDomain()
Dim resolveHandler As ResolveEventHandler = AddressOf typeResolveHandler.ResolveEvent
AddHandler currentDomain.TypeResolve, resolveHandler
Dim tb As TypeBuilder = modBuild.DefineType("AType", TypeAttributes.Public)
Dim eb As TypeBuilder = tb.DefineNestedType("AnEnum", TypeAttributes.NestedPublic Or TypeAttributes.Sealed, GetType([Enum]))
eb.DefineField("value__", GetType(Integer), FieldAttributes.Private Or FieldAttributes.SpecialName)
Dim fb As FieldBuilder = eb.DefineField("Field1", eb, FieldAttributes.Public Or FieldAttributes.Literal Or FieldAttributes.Static)
fb.SetConstant(1)
enumType = eb
' Comment out this field.
' When this field is defined, the loader cannot determine the size
' of the type. Therefore, a TypeResolve event is generated when the
' nested type is completed.
tb.DefineField("Field2", eb, FieldAttributes.Public)
tNesting = tb.CreateType()
If tNesting Is Nothing Then
Console.WriteLine("NestingType CreateType failed but didn't throw!")
End If
Try
tNested = eb.CreateType()
If tNested Is Nothing Then
Console.WriteLine("NestedType CreateType failed but didn't throw!")
End If
Catch
End Try ' This is needed because you might have already completed the type in the TypeResolve event.
If Not (tNested Is Nothing) Then
Dim x As Type = tNested.DeclaringType
If x Is Nothing Then
Console.WriteLine("Declaring type is Nothing.")
Else
Console.WriteLine(x.Name)
End If
End If
asmBuild.Save("NestedEnum.dll")
' Remove the listener for the type resolve events.
RemoveHandler currentDomain.TypeResolve, resolveHandler
End Sub
End Class
' Helper class called when a resolve type event is raised.
Friend Class TypeResolveHandler
Private m_Module As [Module]
Public Sub New([mod] As [Module])
m_Module = [mod]
End Sub
Public Function ResolveEvent(sender As [Object], args As ResolveEventArgs) As [Assembly]
Console.WriteLine(args.Name)
' Use args.Name to look up the type name. In this case, you are getting AnEnum.
Try
NestedEnum.tNested = NestedEnum.enumType.CreateType()
Catch
End Try ' This is needed to throw away InvalidOperationException.
' Loader might send the TypeResolve event more than once
' and the type might be complete already.
' Complete the type.
Return m_Module.Assembly
End Function 'ResolveEvent
End Class
注解
如果此类型是嵌套类型， CreateType 则必须对封闭类型调用 方法，然后才能对嵌套类型调用该方法。
如果当前类型派生自不完整的类型或实现不完整的接口，则先对父类型和接口类型调用 CreateType 方法，然后再对当前类型调用该方法。
例如，如果封闭类型包含一个字段，该字段是定义为嵌套类型的值类型 (，则) 定义为嵌套类型的枚举字段，则对封闭类型调用 CreateType 方法将生成一个 AppDomain.TypeResolve 事件。 这是因为，在完成嵌套类型之前，加载程序无法确定封闭类型的大小。 调用方应定义TypeResolve事件的处理程序，以便通过在表示嵌套类型的 对象上TypeBuilder调用 CreateType 来完成嵌套类型的定义。 本主题的代码示例演示如何定义此类事件处理程序。
无论调用方法的次数 CreateType 如何，类型都只创建一次。 所有调用都返回相同的 Type 对象。
