TypeBuilder.CreateType メソッドとは何？わかりやすく解説 Weblio辞書

.NET Framework クラスライブラリリファレンス

索引トップ用語の索引ランキング

TypeBuilder.CreateType メソッド

このクラスの Type オブジェクトを作成します。クラスのフィールドとメソッドを定義した後、Type オブジェクトを読み込むために、CreateType を呼び出します。

名前空間: System.Reflection.Emit
アセンブリ: mscorlib (mscorlib.dll 内)
構文

Visual Basic (宣言)

Public Function CreateType As
 Type

Visual Basic (使用法)

Dim instance As TypeBuilder
Dim returnValue As Type

returnValue = instance.CreateType

public Type CreateType ()

C++

public:
Type^ CreateType ()

public Type CreateType ()

JScript

public function CreateType () : Type

戻り値
このクラスの新しい Type オブジェクトを返します。

例外

例外の種類	条件
InvalidOperationException	この型は既に作成されています。または外側の型が作成されていません。またはこの型は非抽象型ですが、抽象メソッドが含まれています。またはこの型は抽象型ですが、メソッド本体を持つメソッドがあります。またはこの型は抽象クラスまたはインターフェイスではありませんが、メソッド本体のないメソッドがあります。
NotSupportedException	型に無効な MSIL (Microsoft Intermediate Language) コードが含まれている場合。または分岐ターゲットが、1 バイトオフセットを使用して指定されているが、分岐からターゲットまでの距離が 127 バイトを超えています。

例外の種類

条件

InvalidOperationException

この型は既に作成されています。

または

外側の型が作成されていません。

または

この型は非抽象型ですが、抽象メソッドが含まれています。

または

この型は抽象型ですが、メソッド本体を持つメソッドがあります。

または

この型は抽象クラスまたはインターフェイスではありませんが、メソッド本体のないメソッドがあります。

NotSupportedException

型に無効な MSIL (Microsoft Intermediate Language) コードが含まれている場合。

または

分岐ターゲットが、1 バイトオフセットを使用して指定されているが、分岐からターゲットまでの距離が 127 バイトを超えています。

解説

この型が入れ子にされた型の場合は、入れ子にされた型で CreateType メソッドを呼び出す前に、外側の型で呼び出す必要があります。

現在の型が不完全な型から派生しているか、不完全なインターフェイスを実装している場合は、CreateType メソッドを現在の型で呼び出す前に、親の型とインターフェイスの型で呼び出します。

外側の型に、入れ子にされた型として定義された値型のフィールド (入れ子にされた型として定義された列挙型のフィールドなど) が含まれている場合、外側の型で CreateType メソッドを呼び出すと AppDomain.TypeResolve イベントが生成されます。これは、入れ子にされた型が完了するまで、ローダーが外側の型のサイズを確認できないためです。呼び出し元は、入れ子にされた型を表す TypeBuilder オブジェクトに対して CreateType を呼び出すことで、TypeResolve イベントのハンドラを定義し、入れ子にされた型の定義を完了する必要があります。このトピックのコード例では、このようなイベントハンドラを定義する方法を示しています。

使用例

外側の型で CreateType を呼び出しているときに、入れ子にされた型で CreateType メソッドを呼び出すために、AppDomain.TypeResolve イベントのイベントハンドラを定義する方法を次のコード例に示します。

Visual Basic

Imports System
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 'Main
End Class 'NestedEnum


' 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 'New
   
   
   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 'TypeResolveHandler

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;
    }
}

C++

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();
}