Verknüpfen mit einem Delegaten mit Reflektion

Wenn Sie Assemblys mithilfe von Reflexion laden und ausführen, können Sie Ereignisse nicht mit Sprachfunktionen wie dem Operator += von C# oder der AddHandler-Anweisung von Visual Basic verknüpfen. In den folgenden Verfahrensweisen wird veranschaulicht, wie eine vorhandene Methode mit einem Ereignis verknüpft wird, indem alle erforderlichen Typen über Reflektion abgerufen werden, und wie eine dynamische Methode mithilfe von Reflektionsausgabe erstellt und mit einem Ereignis verknüpft wird.

Hinweis

Eine andere Möglichkeit, einen Delegaten für die Ereignisbehandlung zu verknüpfen, zeigt das Codebeispiel für die AddEventHandler-Methode der EventInfo-Klasse.

So verknüpfen Sie einen Delegaten mithilfe von Reflektion

1. Laden Sie eine Assembly, die einen Typ enthält, der Ereignisse auslöst. Assemblys werden üblicherweise anhand der Assembly.Load-Methode geladen. Um dieses Beispiel möglichst einfach zu halten, wird ein abgeleitetes Formular in der aktuellen Assembly verwendet, es wird daher die GetExecutingAssembly-Methode zum Laden der aktuellen Assembly verwendet.

   Assembly^ assem = Example::typeid->Assembly;
   

   Assembly assem = typeof(Example).Assembly;
   

   Dim assem As Assembly = GetType(Example).Assembly
   

2. Rufen Sie ein Type-Objekt ab, das den Typ darstellt, und erstellen Sie eine Instanz des Typs. Da das Formular über einen parameterlosen Konstruktor verfügt, wird im folgenden Code die Methode CreateInstance(Type) verwendet. Es gibt verschiedene andere Überladungen der Methode CreateInstance, die Sie verwenden können, wenn der erstellte Typ nicht über einen parameterlosen Konstruktor verfügt. Die neue Instanz wird als Typ Object gespeichert, um bei der Idee zu bleiben, dass keine Informationen über die Assembly bekannt sind. (Mithilfe der Reflektion können Sie die Typen in einer Assembly abrufen, ohne ihre Namen bereits zu kennen.)

   Type^ tExForm = assem->GetType("ExampleForm");
   Object^ exFormAsObj = Activator::CreateInstance(tExForm);
   

   Type tExForm = assem.GetType("ExampleForm");
   Object exFormAsObj = Activator.CreateInstance(tExForm);
   

   Dim tExForm As Type = assem.GetType("ExampleForm")
   Dim exFormAsObj As Object = _
       Activator.CreateInstance(tExForm)
   

3. Rufen Sie ein EventInfo-Objekt ab, dass das Ereignis darstellt, und rufen Sie mithilfe der EventHandlerType-Eigenschaft den Typ des Delegaten ab, der für die Ereignisbehandlung verwendet wird. Im folgenden Code wird ein EventInfo für das Click-Ereignis abgerufen.

   EventInfo^ evClick = tExForm->GetEvent("Click");
   Type^ tDelegate = evClick->EventHandlerType;
   

   EventInfo evClick = tExForm.GetEvent("Click");
   Type tDelegate = evClick.EventHandlerType;
   

   Dim evClick As EventInfo = tExForm.GetEvent("Click")
   Dim tDelegate As Type = evClick.EventHandlerType
   

4. Rufen Sie ein MethodInfo-Objekt ab, das die Methode darstellt, die das Ereignis behandelt. Der vollständige Programmcode im Abschnitt „Beispiel“ weiter unten enthält eine Methode, die der Signatur des EventHandler-Delegaten entspricht, der das Click-Ereignis behandelt, zur Laufzeit können Sie auch dynamische Methoden generieren. Einzelheiten finden Sie in der zugehörigen Prozedur zum Generieren eines Ereignishandlers zur Laufzeit durch eine dynamische Methode.

   MethodInfo^ miHandler =
       Type::GetType("Example")->GetMethod("LuckyHandler",
           BindingFlags::NonPublic | BindingFlags::Instance);
   

   MethodInfo miHandler =
       typeof(Example).GetMethod("LuckyHandler",
           BindingFlags.NonPublic | BindingFlags.Instance);
   

   Dim miHandler As MethodInfo = _
       GetType(Example).GetMethod("LuckyHandler", _
           BindingFlags.NonPublic Or BindingFlags.Instance)
   

5. Erstellen Sie mithilfe der CreateDelegate-Methode eine Instanz des Delegaten. Diese Methode ist statisch (Shared in Visual Basic), daher muss der Delegattyp angegeben werden. Es empfiehlt sich, die Überladungen von CreateDelegate zu verwenden, die eine MethodInfo akzeptieren.

   Delegate^ d = Delegate::CreateDelegate(tDelegate, this, miHandler);
   

   Delegate d = Delegate.CreateDelegate(tDelegate, this, miHandler);
   

   Dim d As [Delegate] = _
       [Delegate].CreateDelegate(tDelegate, Me, miHandler)
   

6. Rufen Sie die add-Accessormethode ab, und rufen Sie sie auf, auf das Ereignis zu verknüpfen. Alle Ereignisse verfügen über einen add-Accessor und einen remove-Accessor, die durch die Syntax hoch entwickelter Sprachen verborgen sind. Ereignisse werden beispielsweise in C# mit dem Operator += und in Visual Basic mit der AddHandler-Anweisung verknüpft. Im folgenden Code wird der add-Accessor des Click-Ereignisses abgerufen und dieses dann spät gebunden aufgerufen, indem die Delegatinstanz übergeben wird. Die Argumente müssen als Array übergeben werden.

   MethodInfo^ addHandler = evClick->GetAddMethod();
   array<Object^>^ addHandlerArgs = { d };
   addHandler->Invoke(exFormAsObj, addHandlerArgs);
   

   MethodInfo addHandler = evClick.GetAddMethod();
   Object[] addHandlerArgs = { d };
   addHandler.Invoke(exFormAsObj, addHandlerArgs);
   

   Dim miAddHandler As MethodInfo = evClick.GetAddMethod()
   Dim addHandlerArgs() As Object = {d}
   miAddHandler.Invoke(exFormAsObj, addHandlerArgs)
   

7. Testen Sie das Ereignis. Im folgenden Code wird das im Codebeispiel definierte Formular veranschaulicht. Wenn Sie auf das Formular klicken, wird der Ereignishandler aufgerufen.

   Application::Run((Form^) exFormAsObj);
   

   Application.Run((Form) exFormAsObj);
   

   Application.Run(CType(exFormAsObj, Form))
   

Generieren eines Ereignishandlers zur Laufzeit anhand einer dynamischen Methode

1. Ereignishandlermethoden können mithilfe einfacher dynamischer Methoden und Reflektionsausgabe zur Laufzeit generiert werden. Zum Erstellen eines Ereignishandlers benötigen Sie den Rückgabetyp und die Parametertypen des Delegaten. Diese können über die Invoke-Methode des Delegaten abgerufen werden. Im folgenden Code werden diese Informationen über die GetDelegateReturnType-Methode und die GetDelegateParameterTypes-Methode ermittelt. Den Code für diese Methoden können Sie später in diesem Artikel im Abschnitt „Beispiel“ finden.

   Eine DynamicMethod muss nicht bezeichnet werden, Sie können eine leere Zeichenfolge verwenden. Im folgenden Code wird die dynamische Methode mit dem letzten Argument dem aktuellen Typ zugeordnet. Dadurch erhält der Delegat Zugriff auf alle öffentlichen und privaten Member der Example-Klasse.

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

   Type returnType = GetDelegateReturnType(tDelegate);
   if (returnType != typeof(void))
       throw new ArgumentException("Delegate has a return type.", nameof(d));
   
   DynamicMethod handler =
       new DynamicMethod("",
                         null,
                         GetDelegateParameterTypes(tDelegate),
                         typeof(Example));
   

   Dim returnType As Type = GetDelegateReturnType(tDelegate)
   If returnType IsNot GetType(Void) Then
       Throw New ArgumentException("Delegate has a return type.", NameOf(d))
   End If
   
   Dim handler As New DynamicMethod( _
       "", _
       Nothing, _
       GetDelegateParameterTypes(tDelegate), _
       GetType(Example) _
   )
   

2. Generieren Sie einen Methodentext. Diese Methode lädt eine Zeichenfolge, ruft die Überladung der MessageBox.Show-Methode auf, die eine Zeichenfolge akzeptiert, nimmt den Rückgabewert vom Stapel auf (da der Handler keinen Rückgabetyp aufweist) und wird dann beendet. Weitere Informationen zum Ausgeben dynamischer Methoden finden Sie unter Vorgehensweise: Definieren und Ausführen von dynamischen Methoden.

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

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

   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)
   

3. Schließen Sie die dynamische Methode ab, indem Sie seine CreateDelegate-Methode aufrufen. Fügen Sie den Delegaten mithilfe des add-Accessors zur Aufrufliste des Ereignisses hinzu.

   Delegate^ dEmitted = handler->CreateDelegate(tDelegate);
   addHandler->Invoke(exFormAsObj, gcnew array<Object^> { dEmitted });
   

   Delegate dEmitted = handler.CreateDelegate(tDelegate);
   addHandler.Invoke(exFormAsObj, new Object[] { dEmitted });
   

   Dim dEmitted As [Delegate] = handler.CreateDelegate(tDelegate)
   miAddHandler.Invoke(exFormAsObj, New Object() {dEmitted})
   

4. Testen Sie das Ereignis. Im folgenden Code wird das im Codebeispiel definierte Formular geladen. Wenn Sie auf das Formular klicken, werden sowohl der vordefinierte als auch der ausgegebene Ereignishandler aufgerufen.

   Application::Run((Form^) exFormAsObj);
   

   Application.Run((Form) exFormAsObj);
   

   Application.Run(CType(exFormAsObj, Form))
   

Beispiel

In den folgenden Codebeispielen wird veranschaulicht, wie eine vorhandene Methode anhand von Reflektion mit einem Ereignis verknüpft wird, und wie eine Methode mithilfe der DynamicMethod-Klasse zur Laufzeit ausgegeben und mit einem Ereignis verknüpft wird.

#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 = Example::typeid->Assembly;

        // 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();
}

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 = typeof(Example).Assembly;

        // 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 ArgumentException("Delegate has a return type.", nameof(d));

        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 ArgumentException("Not a delegate.", nameof(d));

        MethodInfo invoke = d.GetMethod("Invoke");
        if (invoke == null)
            throw new ArgumentException("Not a delegate.", nameof(d));

        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 ArgumentException("Not a delegate.", nameof(d));

        MethodInfo invoke = d.GetMethod("Invoke");
        if (invoke == null)
            throw new ArgumentException("Not a delegate.", nameof(d));

        return invoke.ReturnType;
    }
}

Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Windows.Forms

Class ExampleForm
    Inherits Form

    Public Sub New()
        Me.Text = "Click me"

    End Sub
End Class

Class Example
    Public Shared Sub Main()
        Dim ex As New Example()
        ex.HookUpDelegate()
    End Sub

    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 = GetType(Example).Assembly

        ' 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 ArgumentException("Delegate has a return type.", NameOf(d))
        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 ArgumentException("Not a delegate.", NameOf(d))
        End If

        Dim invoke As MethodInfo = d.GetMethod("Invoke")
        If invoke Is Nothing Then
            Throw New ArgumentException("Not a delegate.", NameOf(d))
        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 ArgumentException("Not a delegate.", NameOf(d))
        End If

        Dim invoke As MethodInfo = d.GetMethod("Invoke")
        If invoke Is Nothing Then
            Throw New ArgumentException("Not a delegate.", NameOf(d))
        End If

        Return invoke.ReturnType

    End Function
End Class

Siehe auch

• Assembly.Load
• DynamicMethod
• CreateInstance
• CreateDelegate
• How to: Definieren und Ausführen von dynamischen Methoden
• Reflexion