AppDomain.TypeResolve Evento

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Origem:

AppDomain.cs

Ocorre quando a resolução de um tipo falha.

public:
 event ResolveEventHandler ^ TypeResolve;

public event ResolveEventHandler? TypeResolve;

member this.TypeResolve : ResolveEventHandler 

Public Custom Event TypeResolve As ResolveEventHandler 

Tipo de evento

ResolveEventHandler

Exemplos

O exemplo a seguir demonstra o TypeResolve evento .

Para este exemplo de código ser executado, você deve fornecer o nome de assembly totalmente qualificado. Para obter informações sobre como obter o nome do assembly totalmente qualificado, consulte Nomes de assembly.

#using <System.dll>
#using <System.Windows.Forms.dll>
#using <System.Drawing.dll>

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

ref class Test
{
private:
    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); 
    }

    // For this code example, the following information needs to be
    // available to both Demo and the HandleTypeResolve event
    // handler:
    static AssemblyBuilder^ ab;
    static String^ moduleName;

public:
    static void Demo() 
    {
        AppDomain^ currDom = AppDomain::CurrentDomain;

        // Create a dynamic assembly with one module, to be saved to 
        // disk (AssemblyBuilderAccess::Save).
        // 
        AssemblyName^ aName = gcnew 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 += 
            gcnew 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);
    }
};

void main()
{
    Test::Demo();
}

/* This code example produces the following output:

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

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".
 */

open System
open System.Reflection
open System.Reflection.Emit

let currDom = AppDomain.CurrentDomain

// Create a dynamic assembly with one module, to be saved to
// disk (AssemblyBuilderAccess.Save).
//
let aName = AssemblyName()
aName.Name <- "Transient"
let moduleName = aName.Name + ".dll"
let ab = currDom.DefineDynamicAssembly(aName, AssemblyBuilderAccess.Save)

let handleTypeResolve _ _ =
    printfn "TypeResolve event handler."

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

let mb = ab.DefineDynamicModule(aName.Name, moduleName)

// The dynamic assembly has just one dummy type, to demonstrate
// type resolution.
let tb = mb.DefineType "Example"
tb.CreateType() |> ignore

// First, try to load the type without saving the dynamic
// assembly and without hooking up the TypeResolve event. The
// type cannot be loaded.
try
    let temp = Type.GetType("Example", true)
    printfn $"Loaded type {temp}."
with :? TypeLoadException ->
    printfn "Loader could not resolve the type."

// Hook up the TypeResolve event.
//
currDom.add_TypeResolve(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.
let t = Type.GetType("Example", true)
printfn $"Loaded type \"{t}\"."
let o = Activator.CreateInstance t

(* This code example produces the following output:

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

Option Strict On
Option Explicit On

Imports System.Reflection
Imports System.Reflection.Emit

Module Test

    ' For this code example, the following information needs to be
    ' available to both Main and the HandleTypeResolve event
    ' handler:
    Private ab As AssemblyBuilder
    Private moduleName As String

    Sub Main() 
    
        Dim currDom As AppDomain = AppDomain.CurrentDomain

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

        ' The dynamic assembly has just one dummy type, to demonstrate
        ' type resolution.
        Dim tb As TypeBuilder = 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
            Dim temp As Type = Type.GetType("Example", true)
            Console.WriteLine("Loaded type {0}.", temp)
        Catch ex As TypeLoadException
            Console.WriteLine("Loader could not resolve the type.")
        End Try

        ' Hook up the TypeResolve event.
        '      
        AddHandler currDom.TypeResolve, AddressOf 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.
        Dim t As Type = Type.GetType("Example", true)
        Console.WriteLine("Loaded type ""{0}"".", t)
        Dim o As Object = Activator.CreateInstance(t)
    End Sub

    Private Function HandleTypeResolve(ByVal sender As Object, _
        ByVal e As ResolveEventArgs) As [Assembly]
    
        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) 
    End Function
End Module

' This code example produces the following output:
'
'Loader could not resolve the type.
'TypeResolve event handler.
'Loaded type "Example".
'

Comentários

O TypeResolve evento ocorre quando o Common Language Runtime não consegue determinar o assembly que pode criar o tipo solicitado. Isso poderá ocorrer se o tipo for definido em um assembly dinâmico ou se o tipo não estiver definido em um assembly dinâmico, mas o runtime não souber em qual assembly o tipo está definido. A última situação pode ocorrer quando Type.GetType é chamado com um nome de tipo que não é qualificado com o nome do assembly.

O ResolveEventHandler para esse evento pode tentar localizar e criar o tipo.

No entanto, o TypeResolve evento não ocorrerá se o runtime souber que não é possível encontrar um tipo em determinados assemblies. Por exemplo, esse evento não ocorrerá se o tipo não for encontrado em um assembly estático porque o runtime sabe que os tipos não podem ser adicionados dinamicamente a assemblies estáticos.

A partir do .NET Framework 4, a ResolveEventArgs.RequestingAssembly propriedade contém o assembly que solicitou o tipo. Para obter mais informações, consulte ResolveEventArgs.RequestingAssembly.

Para registrar um manipulador de eventos para esse evento, você deve ter as permissões necessárias, ou um SecurityException é lançado.

Para obter mais informações sobre como lidar com eventos, consulte Manipulando e gerando eventos.

Confira também

• RequestingAssembly