Gewusst wie: Verknüpfen mit einem Delegaten anhand von Reflektion

Wenn Sie Assemblys mithilfe von Reflektion laden und ausführen, können Sie Ereignisse nicht mit Sprachfeatures 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.

   Dim assem As [Assembly] = [Assembly].GetExecutingAssembly()
   

   Assembly assem = Assembly.GetExecutingAssembly();
   

   Assembly^ assem = Assembly::GetExecutingAssembly();
   

2. Rufen Sie ein Type-Objekt ab, das den Typ darstellt, und erstellen Sie eine Instanz des Typs. Da das Formular über einen Standardkonstruktor verfügt, wird im folgenden Code die CreateInstance(Type)-Methode verwendet. Es gibt verschiedene andere Überladungen der CreateInstance-Methode, die Sie verwenden können, wenn der erstellte Typ nicht über einen Standardkonstruktor 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.)

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

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.

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

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

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

4. Rufen Sie ein MethodInfo-Objekt ab, das die Methode darstellt, die das Ereignis behandelt. Der vollständige Programmcode, der sich später in diesem Thema im Abschnitt Beispiel befindet, enthält eine Methode, die der Signatur des EventHandler-Delegaten entspricht, der das Click-Ereignis behandelt. Sie können jedoch auch zur Laufzeit dynamische Methoden generieren. Weitere Einzelheiten hierzu finden Sie in der zugehörigen Prozedur So generieren Sie anhand einer dynamischen Methode zur Laufzeit einen Ereignishandler.

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

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.

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

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

   Delegate^ d = Delegate::CreateDelegate(tDelegate, this, 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.

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

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(CType(exFormAsObj, Form))
   

   Application.Run((Form) exFormAsObj);
   

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

So generieren Sie anhand einer dynamischen Methode zur Laufzeit einen Ereignishandler

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 Thema 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.

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

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 Gewusst wie: Definieren und Ausführen von dynamischen Methoden.

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

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.

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

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(CType(exFormAsObj, Form))
   

   Application.Run((Form) exFormAsObj);
   

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

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.

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

Kompilieren des Codes

• Der Code enthält die für die Kompilierung erforderlichen using-Anweisungen für C# (Imports in Visual Basic).

• Für die Kompilierung von der Befehlszeile aus sind keine zusätzlichen Assemblyverweise erforderlich. In Visual Studio müssen Sie einen Verweis auf System.Windows.Forms.dll hinzufügen, da es sich bei diesem Beispiel um eine Konsolenanwendung handelt.

• Kompilieren Sie den Code über die Befehlszeile mit csc.exe, vbc.exe oder cl.exe. Um den Code in Visual Studio zu kompilieren, fügen Sie ihn in eine Projektvorlage für eine Konsolenanwendung ein.

Siehe auch

Aufgaben

Gewusst wie: Definieren und Ausführen von dynamischen Methoden

Referenz

Assembly.Load

DynamicMethod

CreateInstance

CreateDelegate

Konzepte

Reflektion