TypeBuilder.CreateType Méthode

Définition

Espace de noms:

System.Reflection.Emit

Assemblys:

netstandard.dll, System.Reflection.Emit.dll

Source:

TypeBuilder.cs

Crée un objet Type pour la classe. Après avoir défini les champs et les méthodes sur la classe, CreateType est appelé pour charger son objet Type.

C#

public Type CreateType();

Retours

Type

Retourne le nouvel objet Type pour cette classe.

Exceptions

InvalidOperationException

Le type englobant n’a pas été créé.

- ou -

Ce type est non abstrait et contient une méthode abstraite.

- ou -

Ce type n’est pas une classe abstraite ni une interface et contient une méthode sans corps de méthode.

ArgumentException

Contenu de l’étiquette incorrect dans ILGenerator : vous avez défini une étiquette sans appeler MarkLabel(Label).

NotSupportedException

Le type contient un code MSIL (Microsoft Intermediate Language) non valide.

- ou -

La cible de branche est spécifiée à l’aide d’un offset de 1 octet, mais la cible est à une distance supérieure à 127 octets de la branche.

TypeLoadException

Impossible de charger le type. Par exemple, il contient une méthode static avec la convention d’appel HasThis.

Exemples

L’exemple de code suivant montre comment définir un gestionnaire d’événements pour l’événement AppDomain.TypeResolve , afin d’appeler la CreateType méthode sur un type imbriqué lors d’un CreateType appel sur le type englobant.

C#

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

Remarques

Si ce type est un type imbriqué, la CreateType méthode doit être appelée sur le type englobant avant d’être appelée sur le type imbriqué.

Si le type actuel dérive d’un type incomplet ou implémente des interfaces incomplètes, appelez la CreateType méthode sur le type parent et les types d’interface avant de l’appeler sur le type actuel.

Si le type englobant contient un champ qui est un type valeur défini en tant que type imbriqué (par exemple, un champ qui est une énumération définie comme un type imbriqué), l’appel de la CreateType méthode sur le type englobant génère un AppDomain.TypeResolve événement. Cela est dû au fait que le chargeur ne peut pas déterminer la taille du type englobant tant que le type imbriqué n’a pas été terminé. L’appelant doit définir un gestionnaire pour l’événement TypeResolve afin de terminer la définition du type imbriqué en appelant CreateType sur l’objet TypeBuilder qui représente le type imbriqué. L’exemple de code de cette rubrique montre comment définir un tel gestionnaire d’événements.

Un type n’est créé qu’une seule fois, quel que soit le nombre de fois où la CreateType méthode est appelée. Tous les appels retournent le même Type objet.

S’applique à