TypeBuilder.CreateType Yöntem

Tanım

Ad Alanı:

System.Reflection.Emit

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Reflection.Emit.dll

Kaynak:

TypeBuilder.cs

sınıfı için bir Type nesnesi oluşturur. sınıfındaki alanları ve yöntemleri tanımladıktan sonra, CreateType nesnesini yüklemek için çağrılır Type .

public:
 Type ^ CreateType();

public Type CreateType();

member this.CreateType : unit -> Type

Public Function CreateType () As Type

Döndürülenler

Type

Bu sınıf için yeni Type nesneyi döndürür.

Özel durumlar

InvalidOperationException

Kapsayan tür oluşturulmadı.

-veya-

Bu tür soyut değildir ve soyut bir yöntem içerir.

-veya-

Bu tür soyut bir sınıf veya arabirim değildir ve yöntem gövdesi olmayan bir yöntemi vardır.

ArgumentException

içindeki ILGeneratorhatalı etiket içeriği: çağrısı MarkLabel(Label)yapmadan bir etiket tanımlamışsınız.

NotSupportedException

Türü geçersiz Microsoft ara dil (MSIL) kodu içeriyor.

-veya-

Dal hedefi 1 bayt uzaklık kullanılarak belirtilir, ancak hedef daldan 127 bayttan büyük bir mesafededir.

TypeLoadException

Tür yüklenemiyor. Örneğin, çağırma kuralına staticsahip bir HasThis yöntem içerir.

Örnekler

Aşağıdaki kod örneğinde, kapsayan türdeki AppDomain.TypeResolve bir çağrı sırasında iç içe bir türde yöntemini çağırmak CreateType için olay için bir CreateType olay işleyicisinin nasıl tanımlanacağı gösterilmektedir.

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

Açıklamalar

Bu tür iç içe bir türse, CreateType iç içe türüne çağrılmadan önce yöntemin kapsayan türde çağrılmalıdır.

Geçerli tür tamamlanmamış bir türden türetilirse veya tamamlanmamış arabirimler uygularsa, geçerli türde çağırmadan önce üst tür ve arabirim türleri üzerinde yöntemini çağırın CreateType .

Kapsayan tür iç içe türü olarak tanımlanan bir değer türü olan bir alan içeriyorsa (örneğin, iç içe türü olarak tanımlanan bir numaralandırma olan bir alan), kapsayan CreateType türde yöntemini çağırmak bir AppDomain.TypeResolve olay oluşturur. Bunun nedeni, iç içe türü tamamlanana kadar yükleyicinin kapsayan türün boyutunu belirleyememesidir. Çağıran, iç içe türü temsil eden nesnede TypeResolve çağırarak CreateType iç içe türün tanımını tamamlamak için olay için TypeBuilder bir işleyici tanımlamalıdır. Bu konu için kod örneğinde böyle bir olay işleyicisinin nasıl tanımlanacağı gösterilmektedir.

Yöntem kaç kez çağrılırsa çağrılsın, bir tür yalnızca bir kez CreateType oluşturulur. Tüm çağrılar aynı Type nesneyi döndürür.