Procedura: associare un delegato tramite reflection
Quando si utilizza la reflection per il caricamento e l'esecuzione di assembly, non è possibile associare gli eventi tramite funzionalità quale l'operatore += di C# o l'istruzione AddHandler di Visual Basic. Nelle procedure riportate di seguito viene illustrato come associare un metodo esistente a un evento recuperando tutti i tipi necessari tramite la reflection e come creare un metodo dinamico utilizzando la reflection emit e associarlo a un evento.
.gif "Nota") Nota |
|---|
L'esempio di codice per il metodo AddEventHandler della classe EventInfo rappresenta un altro modo di associare un delegato di gestione degli eventi. |
Per associare un delegato tramite la reflection
Caricare un assembly contenente un tipo che genera eventi. Gli assembly vengono in genere caricati con il metodo Assembly.Load. Per evitare che l'esempio diventi troppo complesso, viene utilizzato un form derivato nell'assembly corrente, pertanto quest'ultimo viene caricato tramite il metodo GetExecutingAssembly.
Dim assem As [Assembly] = [Assembly].GetExecutingAssembly()Assembly assem = Assembly.GetExecutingAssembly();Assembly^ assem = Assembly::GetExecutingAssembly();Ottenere un oggetto Type che rappresenta il tipo e creare un'istanza del tipo. Nel codice che segue viene utilizzato il metodo CreateInstance(Type) perché il form dispone di un costruttore predefinito. Se il tipo creato è privo di un costruttore predefinito, è possibile utilizzare altri overload del metodo CreateInstance. Affinché sembri che non sia disponibile alcuna informazione sull'assembly, la nuova istanza viene memorizzata come tipo Object. In effetti, la reflection consente di ottenere i tipi in un assembly senza sia necessario conoscerne i nomi in anticipo.
Dim tExForm As Type = assem.GetType("ExampleForm") Dim exFormAsObj As Object = _ Activator.CreateInstance(tExForm)Type tExForm = assem.GetType("ExampleForm"); Object exFormAsObj = Activator.CreateInstance(tExForm);Type^ tExForm = assem->GetType("ExampleForm"); Object^ exFormAsObj = Activator::CreateInstance(tExForm);Ottenere un oggetto EventInfo che rappresenta l'evento e utilizzare la proprietà EventHandlerType per recuperare il tipo del delegato utilizzato per la gestione dell'evento. Nel codice riportato di seguito viene recuperato un oggetto EventInfo relativo all'evento Click.
Dim evClick As EventInfo = tExForm.GetEvent("Click") Dim tDelegate As Type = evClick.EventHandlerTypeEventInfo evClick = tExForm.GetEvent("Click"); Type tDelegate = evClick.EventHandlerType;EventInfo^ evClick = tExForm->GetEvent("Click"); Type^ tDelegate = evClick->EventHandlerType;Ottenere un oggetto MethodInfo che rappresenta il metodo che gestisce l'evento. Nel codice del programma completo, riportato nella sezione Esempio più avanti in questo argomento, è presente un metodo che corrisponde alla firma del delegato EventHandler che gestisce l'evento Click, ma è anche possibile generare metodi dinamici in fase di esecuzione. Per informazioni dettagliate, vedere la procedura associata Per generare un gestore eventi in fase di esecuzione tramite un metodo dinamico.
Dim miHandler As MethodInfo = _ GetType(Example).GetMethod("LuckyHandler", _ BindingFlags.NonPublic Or BindingFlags.Instance)MethodInfo miHandler = typeof(Example).GetMethod("LuckyHandler", BindingFlags.NonPublic | BindingFlags.Instance);MethodInfo^ miHandler = Type::GetType("Example")->GetMethod("LuckyHandler", BindingFlags::NonPublic | BindingFlags::Instance);Creare un'istanza del delegato utilizzando il metodo CreateDelegate. Poiché il metodo è statico (Shared in Visual Basic), è necessario specificare il tipo delegato. Si consiglia di utilizzare gli overload del metodo CreateDelegate, che accettano un oggetto MethodInfo.
Dim d As [Delegate] = _ [Delegate].CreateDelegate(tDelegate, Me, miHandler)Delegate d = Delegate.CreateDelegate(tDelegate, this, miHandler);Delegate^ d = Delegate::CreateDelegate(tDelegate, this, miHandler);Ottenere il metodo della funzione di accesso add e richiamarlo per associare l'evento. Tutti gli eventi dispongono di una funzione di accesso add e di una funzione di accesso remove, nascoste dalla sintassi dei linguaggi ad alto livello. Per associare gli eventi, ad esempio, C# utilizza l'operatore +=, mentre Visual Basic utilizza l'istruzione AddHandler. Nel codice riportato di seguito viene ottenuta la funzione di accesso add dell'evento Click, che viene quindi richiamata con associazione tardiva passando l'istanza del delegato. Gli argomenti devono essere passati come matrice.
Dim miAddHandler As MethodInfo = evClick.GetAddMethod() Dim addHandlerArgs() As Object = { d } miAddHandler.Invoke(exFormAsObj, addHandlerArgs)MethodInfo addHandler = evClick.GetAddMethod(); Object[] addHandlerArgs = { d }; addHandler.Invoke(exFormAsObj, addHandlerArgs);MethodInfo^ addHandler = evClick->GetAddMethod(); array<Object^>^ addHandlerArgs = { d }; addHandler->Invoke(exFormAsObj, addHandlerArgs);Verificare l'evento. Nel codice seguente viene illustrato il form definito nell'esempio. Facendo clic sul form, verrà richiamato il gestore eventi.
Application.Run(CType(exFormAsObj, Form))Application.Run((Form) exFormAsObj);Application::Run((Form^) exFormAsObj);
Per generare un gestore eventi in fase di esecuzione tramite un metodo dinamico
I metodi per la gestione degli eventi possono essere generati in fase di esecuzione utilizzando metodi dinamici di tipo lightweight e la reflection emit. Per costruire un gestore eventi, è necessario disporre del tipo restituito e dei tipi di parametro del delegato, che possono essere ottenuti esaminando il metodo Invoke del delegato. Nel codice riportato di seguito vengono utilizzati i metodi GetDelegateReturnType e GetDelegateParameterTypes per il recupero di tali informazioni. Il codice relativo a questi metodi è disponibile nella sezione Esempio più avanti in questo argomento.
Poiché non è necessario assegnare un nome a DynamicMethod, può essere utilizzata la stringa vuota. Nel codice riportato di seguito l'ultimo argomento associa il metodo dinamico al tipo corrente, concedendo al delegato l'accesso a tutti i membri pubblici e privati della classe Example.
Dim returnType As Type = GetDelegateReturnType(tDelegate) If returnType IsNot GetType(Void) Then Throw New ApplicationException("Delegate has a return type.") End If Dim handler As New DynamicMethod( _ "", _ Nothing, _ GetDelegateParameterTypes(tDelegate), _ GetType(Example) _ )Type returnType = GetDelegateReturnType(tDelegate); if (returnType != typeof(void)) throw new ApplicationException("Delegate has a return type."); DynamicMethod handler = new DynamicMethod("", null, GetDelegateParameterTypes(tDelegate), typeof(Example));Type^ returnType = GetDelegateReturnType(tDelegate); if (returnType != void::typeid) throw gcnew ApplicationException("Delegate has a return type."); DynamicMethod^ handler = gcnew DynamicMethod("", nullptr, GetDelegateParameterTypes(tDelegate), Example::typeid);Generare il corpo di un metodo. Quest'ultimo carica una stringa, chiama l'overload del metodo MessageBox.Show che accetta una stringa, estrae il valore restituito dallo stack perché il gestore non ha alcun tipo restituito e termina. Per ulteriori informazioni sulla creazione di metodi dinamici, vedere Procedura: definire ed eseguire metodi dinamici.
Dim ilgen As ILGenerator = handler.GetILGenerator() Dim showParameters As Type() = { GetType(String) } Dim simpleShow As MethodInfo = _ GetType(MessageBox).GetMethod("Show", showParameters) ilgen.Emit(OpCodes.Ldstr, _ "This event handler was constructed at run time.") ilgen.Emit(OpCodes.Call, simpleShow) ilgen.Emit(OpCodes.Pop) ilgen.Emit(OpCodes.Ret)ILGenerator ilgen = handler.GetILGenerator(); Type[] showParameters = { typeof(String) }; MethodInfo simpleShow = typeof(MessageBox).GetMethod("Show", showParameters); ilgen.Emit(OpCodes.Ldstr, "This event handler was constructed at run time."); ilgen.Emit(OpCodes.Call, simpleShow); ilgen.Emit(OpCodes.Pop); ilgen.Emit(OpCodes.Ret);ILGenerator^ ilgen = handler->GetILGenerator(); array<Type^>^ showParameters = { String::typeid }; MethodInfo^ simpleShow = MessageBox::typeid->GetMethod("Show", showParameters); ilgen->Emit(OpCodes::Ldstr, "This event handler was constructed at run time."); ilgen->Emit(OpCodes::Call, simpleShow); ilgen->Emit(OpCodes::Pop); ilgen->Emit(OpCodes::Ret);Completare il metodo dinamico chiamando il relativo metodo CreateDelegate. Utilizzare la funzione di accesso add per aggiungere il delegato all'elenco di chiamate per l'evento.
Dim dEmitted As [Delegate] = handler.CreateDelegate(tDelegate) miAddHandler.Invoke(exFormAsObj, New Object() { dEmitted })Delegate dEmitted = handler.CreateDelegate(tDelegate); addHandler.Invoke(exFormAsObj, new Object[] { dEmitted });Delegate^ dEmitted = handler->CreateDelegate(tDelegate); addHandler->Invoke(exFormAsObj, gcnew array<Object^> { dEmitted });Verificare l'evento. Nel codice riportato di seguito viene caricato il form definito nell'esempio. Facendo clic sul form, verranno richiamati sia il gestore eventi predefinito che il gestore eventi creato.
Application.Run(CType(exFormAsObj, Form))Application.Run((Form) exFormAsObj);Application::Run((Form^) exFormAsObj);
Esempio
Nell'esempio di codice riportato di seguito viene illustrato come associare un metodo esistente a un evento tramite la reflection, nonché come utilizzare la classe DynamicMethod per creare un metodo in fase di esecuzione e associarlo a un evento.
Imports System
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Windows.Forms
Class ExampleForm
Inherits Form
Public Sub New()
Me.Text = "Click me"
End Sub 'New
End Class 'ExampleForm
Class Example
Public Shared Sub Main()
Dim ex As New Example()
ex.HookUpDelegate()
End Sub 'Main
Private Sub HookUpDelegate()
' Load an assembly, for example using the Assembly.Load
' method. In this case, the executing assembly is loaded, to
' keep the demonstration simple.
'
Dim assem As [Assembly] = [Assembly].GetExecutingAssembly()
' Get the type that is to be loaded, and create an instance
' of it. Activator.CreateInstance also has an overload that
' takes an array of types representing the types of the
' constructor parameters, if the type you are creating does
' not have a parameterless constructor. The new instance
' is stored as type Object, to maintain the fiction that
' nothing is known about the assembly. (Note that you can
' get the types in an assembly without knowing their names
' in advance.)
'
Dim tExForm As Type = assem.GetType("ExampleForm")
Dim exFormAsObj As Object = _
Activator.CreateInstance(tExForm)
' Get an EventInfo representing the Click event, and get the
' type of delegate that handles the event.
'
Dim evClick As EventInfo = tExForm.GetEvent("Click")
Dim tDelegate As Type = evClick.EventHandlerType
' If you already have a method with the correct signature,
' you can simply get a MethodInfo for it.
'
Dim miHandler As MethodInfo = _
GetType(Example).GetMethod("LuckyHandler", _
BindingFlags.NonPublic Or BindingFlags.Instance)
' Create an instance of the delegate. Using the overloads
' of CreateDelegate that take MethodInfo is recommended.
'
Dim d As [Delegate] = _
[Delegate].CreateDelegate(tDelegate, Me, miHandler)
' Get the "add" accessor of the event and invoke it late-
' bound, passing in the delegate instance. This is equivalent
' to using the += operator in C#, or AddHandler in Visual
' Basic. The instance on which the "add" accessor is invoked
' is the form; the arguments must be passed as an array.
'
Dim miAddHandler As MethodInfo = evClick.GetAddMethod()
Dim addHandlerArgs() As Object = { d }
miAddHandler.Invoke(exFormAsObj, addHandlerArgs)
' Event handler methods can also be generated at run time,
' using lightweight dynamic methods and Reflection.Emit.
' To construct an event handler, you need the return type
' and parameter types of the delegate. These can be obtained
' by examining the delegate's Invoke method.
'
' It is not necessary to name dynamic methods, so the empty
' string can be used. The last argument associates the
' dynamic method with the current type, giving the delegate
' access to all the public and private members of Example,
' as if it were an instance method.
'
Dim returnType As Type = GetDelegateReturnType(tDelegate)
If returnType IsNot GetType(Void) Then
Throw New ApplicationException("Delegate has a return type.")
End If
Dim handler As New DynamicMethod( _
"", _
Nothing, _
GetDelegateParameterTypes(tDelegate), _
GetType(Example) _
)
' Generate a method body. This method loads a string, calls
' the Show method overload that takes a string, pops the
' return value off the stack (because the handler has no
' return type), and returns.
'
Dim ilgen As ILGenerator = handler.GetILGenerator()
Dim showParameters As Type() = { GetType(String) }
Dim simpleShow As MethodInfo = _
GetType(MessageBox).GetMethod("Show", showParameters)
ilgen.Emit(OpCodes.Ldstr, _
"This event handler was constructed at run time.")
ilgen.Emit(OpCodes.Call, simpleShow)
ilgen.Emit(OpCodes.Pop)
ilgen.Emit(OpCodes.Ret)
' Complete the dynamic method by calling its CreateDelegate
' method. Use the "add" accessor to add the delegate to
' the invocation list for the event.
'
Dim dEmitted As [Delegate] = handler.CreateDelegate(tDelegate)
miAddHandler.Invoke(exFormAsObj, New Object() { dEmitted })
' Show the form. Clicking on the form causes the two
' delegates to be invoked.
'
Application.Run(CType(exFormAsObj, Form))
End Sub
Private Sub LuckyHandler(ByVal sender As [Object], _
ByVal e As EventArgs)
MessageBox.Show("This event handler just happened to be lying around.")
End Sub
Private Function GetDelegateParameterTypes(ByVal d As Type) _
As Type()
If d.BaseType IsNot GetType(MulticastDelegate) Then
Throw New ApplicationException("Not a delegate.")
End If
Dim invoke As MethodInfo = d.GetMethod("Invoke")
If invoke Is Nothing Then
Throw New ApplicationException("Not a delegate.")
End If
Dim parameters As ParameterInfo() = invoke.GetParameters()
' Dimension this array Length - 1, because VB adds an extra
' element to zero-based arrays.
Dim typeParameters(parameters.Length - 1) As Type
For i As Integer = 0 To parameters.Length - 1
typeParameters(i) = parameters(i).ParameterType
Next i
Return typeParameters
End Function
Private Function GetDelegateReturnType(ByVal d As Type) As Type
If d.BaseType IsNot GetType(MulticastDelegate) Then
Throw New ApplicationException("Not a delegate.")
End If
Dim invoke As MethodInfo = d.GetMethod("Invoke")
If invoke Is Nothing Then
Throw New ApplicationException("Not a delegate.")
End If
Return invoke.ReturnType
End Function
End Class
using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Windows.Forms;
class ExampleForm : Form
{
public ExampleForm() : base()
{
this.Text = "Click me";
}
}
class Example
{
public static void Main()
{
Example ex = new Example();
ex.HookUpDelegate();
}
private void HookUpDelegate()
{
// Load an assembly, for example using the Assembly.Load
// method. In this case, the executing assembly is loaded, to
// keep the demonstration simple.
//
Assembly assem = Assembly.GetExecutingAssembly();
// Get the type that is to be loaded, and create an instance
// of it. Activator.CreateInstance has other overloads, if
// the type lacks a default constructor. The new instance
// is stored as type Object, to maintain the fiction that
// nothing is known about the assembly. (Note that you can
// get the types in an assembly without knowing their names
// in advance.)
//
Type tExForm = assem.GetType("ExampleForm");
Object exFormAsObj = Activator.CreateInstance(tExForm);
// Get an EventInfo representing the Click event, and get the
// type of delegate that handles the event.
//
EventInfo evClick = tExForm.GetEvent("Click");
Type tDelegate = evClick.EventHandlerType;
// If you already have a method with the correct signature,
// you can simply get a MethodInfo for it.
//
MethodInfo miHandler =
typeof(Example).GetMethod("LuckyHandler",
BindingFlags.NonPublic | BindingFlags.Instance);
// Create an instance of the delegate. Using the overloads
// of CreateDelegate that take MethodInfo is recommended.
//
Delegate d = Delegate.CreateDelegate(tDelegate, this, miHandler);
// Get the "add" accessor of the event and invoke it late-
// bound, passing in the delegate instance. This is equivalent
// to using the += operator in C#, or AddHandler in Visual
// Basic. The instance on which the "add" accessor is invoked
// is the form; the arguments must be passed as an array.
//
MethodInfo addHandler = evClick.GetAddMethod();
Object[] addHandlerArgs = { d };
addHandler.Invoke(exFormAsObj, addHandlerArgs);
// Event handler methods can also be generated at run time,
// using lightweight dynamic methods and Reflection.Emit.
// To construct an event handler, you need the return type
// and parameter types of the delegate. These can be obtained
// by examining the delegate's Invoke method.
//
// It is not necessary to name dynamic methods, so the empty
// string can be used. The last argument associates the
// dynamic method with the current type, giving the delegate
// access to all the public and private members of Example,
// as if it were an instance method.
//
Type returnType = GetDelegateReturnType(tDelegate);
if (returnType != typeof(void))
throw new ApplicationException("Delegate has a return type.");
DynamicMethod handler =
new DynamicMethod("",
null,
GetDelegateParameterTypes(tDelegate),
typeof(Example));
// Generate a method body. This method loads a string, calls
// the Show method overload that takes a string, pops the
// return value off the stack (because the handler has no
// return type), and returns.
//
ILGenerator ilgen = handler.GetILGenerator();
Type[] showParameters = { typeof(String) };
MethodInfo simpleShow =
typeof(MessageBox).GetMethod("Show", showParameters);
ilgen.Emit(OpCodes.Ldstr,
"This event handler was constructed at run time.");
ilgen.Emit(OpCodes.Call, simpleShow);
ilgen.Emit(OpCodes.Pop);
ilgen.Emit(OpCodes.Ret);
// Complete the dynamic method by calling its CreateDelegate
// method. Use the "add" accessor to add the delegate to
// the invocation list for the event.
//
Delegate dEmitted = handler.CreateDelegate(tDelegate);
addHandler.Invoke(exFormAsObj, new Object[] { dEmitted });
// Show the form. Clicking on the form causes the two
// delegates to be invoked.
//
Application.Run((Form) exFormAsObj);
}
private void LuckyHandler(Object sender, EventArgs e)
{
MessageBox.Show("This event handler just happened to be lying around.");
}
private Type[] GetDelegateParameterTypes(Type d)
{
if (d.BaseType != typeof(MulticastDelegate))
throw new ApplicationException("Not a delegate.");
MethodInfo invoke = d.GetMethod("Invoke");
if (invoke == null)
throw new ApplicationException("Not a delegate.");
ParameterInfo[] parameters = invoke.GetParameters();
Type[] typeParameters = new Type[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
typeParameters[i] = parameters[i].ParameterType;
}
return typeParameters;
}
private Type GetDelegateReturnType(Type d)
{
if (d.BaseType != typeof(MulticastDelegate))
throw new ApplicationException("Not a delegate.");
MethodInfo invoke = d.GetMethod("Invoke");
if (invoke == null)
throw new ApplicationException("Not a delegate.");
return invoke.ReturnType;
}
}
#using <System.dll>
#using <System.Windows.Forms.dll>
using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Windows::Forms;
public ref class ExampleForm : public Form
{
public:
ExampleForm() : Form()
{
this->Text = "Click me";
}
};
public ref class Example
{
public:
static void Main()
{
Example^ ex = gcnew Example();
ex->HookUpDelegate();
}
private:
void HookUpDelegate()
{
// Load an assembly, for example using the Assembly.Load
// method. In this case, the executing assembly is loaded, to
// keep the demonstration simple.
//
Assembly^ assem = Assembly::GetExecutingAssembly();
// Get the type that is to be loaded, and create an instance
// of it. Activator::CreateInstance has other overloads, if
// the type lacks a default constructor. The new instance
// is stored as type Object, to maintain the fiction that
// nothing is known about the assembly. (Note that you can
// get the types in an assembly without knowing their names
// in advance.)
//
Type^ tExForm = assem->GetType("ExampleForm");
Object^ exFormAsObj = Activator::CreateInstance(tExForm);
// Get an EventInfo representing the Click event, and get the
// type of delegate that handles the event.
//
EventInfo^ evClick = tExForm->GetEvent("Click");
Type^ tDelegate = evClick->EventHandlerType;
// If you already have a method with the correct signature,
// you can simply get a MethodInfo for it.
//
MethodInfo^ miHandler =
Type::GetType("Example")->GetMethod("LuckyHandler",
BindingFlags::NonPublic | BindingFlags::Instance);
// Create an instance of the delegate. Using the overloads
// of CreateDelegate that take MethodInfo is recommended.
//
Delegate^ d = Delegate::CreateDelegate(tDelegate, this, miHandler);
// Get the "add" accessor of the event and invoke it late-
// bound, passing in the delegate instance. This is equivalent
// to using the += operator in C#, or AddHandler in Visual
// Basic. The instance on which the "add" accessor is invoked
// is the form; the arguments must be passed as an array.
//
MethodInfo^ addHandler = evClick->GetAddMethod();
array<Object^>^ addHandlerArgs = { d };
addHandler->Invoke(exFormAsObj, addHandlerArgs);
// Event handler methods can also be generated at run time,
// using lightweight dynamic methods and Reflection.Emit.
// To construct an event handler, you need the return type
// and parameter types of the delegate. These can be obtained
// by examining the delegate's Invoke method.
//
// It is not necessary to name dynamic methods, so the empty
// string can be used. The last argument associates the
// dynamic method with the current type, giving the delegate
// access to all the public and private members of Example,
// as if it were an instance method.
//
Type^ returnType = GetDelegateReturnType(tDelegate);
if (returnType != void::typeid)
throw gcnew ApplicationException("Delegate has a return type.");
DynamicMethod^ handler =
gcnew DynamicMethod("",
nullptr,
GetDelegateParameterTypes(tDelegate),
Example::typeid);
// Generate a method body. This method loads a string, calls
// the Show method overload that takes a string, pops the
// return value off the stack (because the handler has no
// return type), and returns.
//
ILGenerator^ ilgen = handler->GetILGenerator();
array<Type^>^ showParameters = { String::typeid };
MethodInfo^ simpleShow =
MessageBox::typeid->GetMethod("Show", showParameters);
ilgen->Emit(OpCodes::Ldstr,
"This event handler was constructed at run time.");
ilgen->Emit(OpCodes::Call, simpleShow);
ilgen->Emit(OpCodes::Pop);
ilgen->Emit(OpCodes::Ret);
// Complete the dynamic method by calling its CreateDelegate
// method. Use the "add" accessor to add the delegate to
// the invocation list for the event.
//
Delegate^ dEmitted = handler->CreateDelegate(tDelegate);
addHandler->Invoke(exFormAsObj, gcnew array<Object^> { dEmitted });
// Show the form. Clicking on the form causes the two
// delegates to be invoked.
//
Application::Run((Form^) exFormAsObj);
}
void LuckyHandler(Object^ sender, EventArgs^ e)
{
MessageBox::Show("This event handler just happened to be lying around.");
}
array<Type^>^ GetDelegateParameterTypes(Type^ d)
{
if (d->BaseType != MulticastDelegate::typeid)
throw gcnew ApplicationException("Not a delegate.");
MethodInfo^ invoke = d->GetMethod("Invoke");
if (invoke == nullptr)
throw gcnew ApplicationException("Not a delegate.");
array<ParameterInfo^>^ parameters = invoke->GetParameters();
array<Type^>^ typeParameters = gcnew array<Type^>(parameters->Length);
for (int i = 0; i < parameters->Length; i++)
{
typeParameters[i] = parameters[i]->ParameterType;
}
return typeParameters;
}
Type^ GetDelegateReturnType(Type^ d)
{
if (d->BaseType != MulticastDelegate::typeid)
throw gcnew ApplicationException("Not a delegate.");
MethodInfo^ invoke = d->GetMethod("Invoke");
if (invoke == nullptr)
throw gcnew ApplicationException("Not a delegate.");
return invoke->ReturnType;
}
};
int main()
{
Example::Main();
}
Compilazione del codice
Nel codice sono incluse le istruzioni using di C# (Imports in Visual Basic) necessarie per la compilazione.
Per la compilazione dalla riga di comando, non sono necessari altri riferimenti ad assembly. Poiché questo esempio rappresenta un'applicazione console, in Visual Studio sarà necessario aggiungere un riferimento a System.Windows.Forms.dll.
Compilare il codice alla riga di comando utilizzando csc.exe, vbc.exe o cl.exe. Per compilare il codice in Visual Studio, inserirlo in un modello di progetto di applicazione console.
Vedere anche
Attività
Procedura: definire ed eseguire metodi dinamici