Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

AppDomain.TypeResolve événement

 

Date de publication : novembre 2016

Se produit quand la résolution d’un type échoue.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

public event ResolveEventHandler TypeResolve

Le TypeResolve événement se produit lorsque le common language runtime ne parvient pas à déterminer l’assembly capable de créer le type demandé. Cela peut se produire si le type est défini dans un assembly dynamique, ou le type n’est pas défini dans un assembly dynamique, mais que le runtime ne sait pas quel assembly le type est défini dans. Dans ce dernier cas peut se produire lorsque Type.GetType est appelée avec un nom de type qui n’est pas qualifié avec le nom de l’assembly.

Le ResolveEventHandler pour cet événement peut tenter de localiser et de créer le type.

Toutefois, le TypeResolve événement ne survient pas si le runtime sait qu’il n’est pas possible de trouver un type dans certains assemblys. Par exemple, cet événement n’a pas lieu si le type est introuvable dans un assembly statique, car le runtime sait types ne peuvent pas être ajoutés dynamiquement à des assemblys statiques.

Compter les .NET Framework 4, le ResolveEventArgs.RequestingAssembly propriété contient l’assembly qui a demandé le type. Pour plus d'informations, consultez ResolveEventArgs.RequestingAssembly.

Pour inscrire un gestionnaire d’événements pour cet événement, vous devez disposer des autorisations requises, ou un SecurityException est levée.

Pour plus d'informations sur la gestion des événements, consultez Gestion et déclenchement d'événements.

L’exemple suivant montre comment la TypeResolve événement.

Pour exécuter cet exemple de code, vous devez fournir le nom d’assembly qualifié complet. Pour plus d’informations sur la façon d’obtenir le nom d’assembly qualifié complet, consultez Noms d'assemblys.

using System;
using System.Reflection;
using System.Reflection.Emit;

class Test 
{
    // For this code example, the following information needs to be
    // available to both Main and the HandleTypeResolve event
    // handler:
    private static AssemblyBuilder ab;
    private static string moduleName;

    public static void Main() 
    {
        AppDomain currDom = AppDomain.CurrentDomain;

        // Create a dynamic assembly with one module, to be saved to 
        // disk (AssemblyBuilderAccess.Save).
        // 
        AssemblyName aName = new AssemblyName();
        aName.Name = "Transient";
        moduleName = aName.Name + ".dll";
        ab = currDom.DefineDynamicAssembly(aName,
            AssemblyBuilderAccess.Save);
        ModuleBuilder mb = ab.DefineDynamicModule(aName.Name, moduleName);

        // The dynamic assembly has just one dummy type, to demonstrate
        // type resolution.
        TypeBuilder tb = mb.DefineType("Example");
        tb.CreateType();


        // First, try to load the type without saving the dynamic 
        // assembly and without hooking up the TypeResolve event. The
        // type cannot be loaded.
        try
        {
            Type temp = Type.GetType("Example", true);
            Console.WriteLine("Loaded type {0}.", temp);
        }
        catch (TypeLoadException)
        {
            Console.WriteLine("Loader could not resolve the type.");
        }

        // Hook up the TypeResolve event.
        //      
        currDom.TypeResolve += 
            new ResolveEventHandler(HandleTypeResolve);

        // Now try to load the type again. The TypeResolve event is 
        // raised, the dynamic assembly is saved, and the dummy type is
        // loaded successfully. Display it to the console, and create
        // an instance.
        Type t = Type.GetType("Example", true);
        Console.WriteLine("Loaded type \"{0}\".", t);
        Object o = Activator.CreateInstance(t);
    }

    static Assembly HandleTypeResolve(object sender, ResolveEventArgs args) 
    {
        Console.WriteLine("TypeResolve event handler.");

        // Save the dynamic assembly, and then load it using its
        // display name. Return the loaded assembly.
        //
        ab.Save(moduleName);
        return Assembly.Load(ab.FullName); 
    }
}

/* This code example produces the following output:

Loader could not resolve the type.
TypeResolve event handler.
Loaded type "Example".
 */

SecurityCriticalAttribute

requires full trust for the immediate caller. This member cannot be used by partially trusted or transparent code.

.NET Framework
Disponible depuis 1.1
Retour au début
Afficher: