AppDomain.TypeResolve Událost
Důležité
Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.
Vyvolá se při selhání překladu typu.
public:
event ResolveEventHandler ^ TypeResolve;
public:
virtual event ResolveEventHandler ^ TypeResolve;
public event ResolveEventHandler? TypeResolve;
public event ResolveEventHandler TypeResolve;
[add: System.Security.SecurityCritical]
[remove: System.Security.SecurityCritical]
public event ResolveEventHandler TypeResolve;
member this.TypeResolve : ResolveEventHandler
[<add: System.Security.SecurityCritical>]
[<remove: System.Security.SecurityCritical>]
member this.TypeResolve : ResolveEventHandler
Public Custom Event TypeResolve As ResolveEventHandler
- Atributy
Následující ukázka ukazuje TypeResolve událost.
Pro spuštění této ukázky kódu je nutné zadat plně kvalifikovaný název. Informace o tom, jak získat plně kvalifikovaný název sestavení naleznete v části Názvy sestavení.
#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".
'
Událost TypeResolve nastane, když modul CLR (Common Language Runtime) nedokáže určit sestavení, které může vytvořit požadovaný typ. K tomu může dojít, pokud je typ definován v dynamickém sestavení nebo není definován v dynamickém sestavení, ale modul runtime neví, ve kterém sestavení je typ definován. Druhá situace může nastat, pokud Type.GetType je volána s názvem typu, který není kvalifikovaný s názvem sestavení.
Pro ResolveEventHandler tuto událost se může pokusit najít a vytvořit typ.
Událost však nedochází, pokud modul runtime ví, TypeResolve že není možné najít typ v určitých sestaveních. Například k této události nedojde, pokud typ není nalezen ve statickém sestavení, protože modul runtime zná typy nelze dynamicky přidat do statických sestavení.
Počínaje rozhraním .NET Framework 4 ResolveEventArgs.RequestingAssembly obsahuje vlastnost sestavení, které požadovalo typ. Další informace naleznete v tématu ResolveEventArgs.RequestingAssembly.
Chcete-li zaregistrovat obslužnou rutinu události pro tuto událost, musíte mít požadovaná oprávnění nebo SecurityException je vyvolán.
Další informace o zpracování událostí najdete v tématu Zpracování a vyvolávání událostí.
Produkt | Verze |
---|---|
.NET | Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 2.0, 2.1 |
Zpětná vazba k produktu .NET
.NET je open source projekt. Vyberte odkaz pro poskytnutí zpětné vazby: