Instrukcje: podłączenie delegata przy użyciu odbicia

Jeśli używasz odbicia do ładowania i uruchamiania zestawów, nie można używać funkcji językowych, takich jak operator języka C# += lub instrukcja Visual Basic AddHandler, aby podłączyć zdarzenia. Poniższe procedury pokazują, jak podłączyć istniejącą metodę do zdarzenia przez pobranie wszystkich niezbędnych typów przez odbicie oraz jak utworzyć metodę dynamiczną przy użyciu emisji odbicia i podłączyć ją do zdarzenia.

Uwaga

Aby uzyskać inny sposób podłączenia delegata obsługi zdarzeń, zobacz przykład AddEventHandler kodu dla metody EventInfo klasy.

Aby podłączyć delegata przy użyciu odbicia

1. Załaduj zestaw zawierający typ, który zgłasza zdarzenia. Zestawy są zwykle ładowane z Assembly.Load metodą . Aby zachować prosty przykład, używany jest formularz pochodny w bieżącym zestawie, więc GetExecutingAssembly metoda jest używana do ładowania bieżącego zestawu.

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

   Assembly assem = typeof(Example).Assembly;
   

   Dim assem As Assembly = GetType(Example).Assembly
   

2. Type Pobierz obiekt reprezentujący typ i utwórz wystąpienie typu. Metoda CreateInstance(Type) jest używana w poniższym kodzie, ponieważ formularz ma konstruktor bez parametrów. Istnieje kilka innych przeciążeń CreateInstance metody, których można użyć, jeśli tworzony typ nie ma konstruktora bez parametrów. Nowe wystąpienie jest przechowywane jako typ Object w celu zachowania fikcji, że nic nie jest znane o zestawie. (Emocje ion umożliwia uzyskanie typów w zestawie bez wcześniejszej znajomości ich nazw).

   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. EventInfo Pobierz obiekt reprezentujący zdarzenie i użyj EventHandlerType właściwości , aby uzyskać typ delegata używanego do obsługi zdarzenia. W poniższym kodzie EventInfo jest uzyskiwany element dla Click zdarzenia.

   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. Pobierz obiekt reprezentujący metodę MethodInfo , która obsługuje zdarzenie. Kompletny kod programu w sekcji Przykład w dalszej części tego artykułu zawiera metodę zgodną z podpisem EventHandler delegata, która obsługuje Click zdarzenie, ale można również wygenerować metody dynamiczne w czasie wykonywania. Aby uzyskać szczegółowe informacje, zobacz procedurę towarzyszącą generowania programu obsługi zdarzeń w czasie wykonywania przy użyciu metody dynamicznej.

   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. Utwórz wystąpienie delegata przy użyciu CreateDelegate metody . Ta metoda jest statyczna (Shared w Visual Basic), więc należy podać typ delegata. Zaleca się użycie przeciążeń CreateDelegate tego elementu MethodInfo .

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

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

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

6. Pobierz metodę add dostępu i wywołaj ją, aby podłączyć zdarzenie. Wszystkie zdarzenia mają add metodę dostępu i remove metodę dostępu, które są ukryte przez składnię języków wysokiego poziomu. Na przykład język C# używa += operatora do podłączania zdarzeń, a język Visual Basic używa instrukcji AddHandler. Poniższy kod pobiera metodę add dostępu do Click zdarzenia i wywołuje je z opóźnieniem, przekazując wystąpienie delegata. Argumenty muszą być przekazywane jako tablica.

   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. Przetestuj zdarzenie. Poniższy kod przedstawia formularz zdefiniowany w przykładzie kodu. Kliknięcie formularza wywołuje procedurę obsługi zdarzeń.

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

   Application.Run((Form) exFormAsObj);
   

   Application.Run(CType(exFormAsObj, Form))
   

Generowanie programu obsługi zdarzeń w czasie wykonywania przy użyciu metody dynamicznej

1. Metody obsługi zdarzeń można wygenerować w czasie wykonywania przy użyciu lekkich metod dynamicznych i emisji odbicia. Aby utworzyć procedurę obsługi zdarzeń, potrzebny jest typ zwracany i typy parametrów delegata. Można je uzyskać, sprawdzając metodę delegata Invoke . Poniższy kod używa GetDelegateReturnType metod i GetDelegateParameterTypes w celu uzyskania tych informacji. Kod tych metod można znaleźć w sekcji Przykład w dalszej części tego artykułu.

   Nie jest konieczne nadanie nazwy DynamicMethod, więc można użyć pustego ciągu. W poniższym kodzie ostatni argument kojarzy metodę dynamiczną z bieżącym typem, dając delegatowi dostęp do wszystkich publicznych i prywatnych składowych Example klasy.

   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. Wygeneruj treść metody. Ta metoda ładuje ciąg, wywołuje przeciążenie MessageBox.Show metody, która pobiera ciąg, uruchamia wartość zwracaną ze stosu (ponieważ program obsługi nie ma zwracanego typu) i zwraca wartość. Aby dowiedzieć się więcej na temat emitowania metod dynamicznych, zobacz How to: Define and Execute Dynamic Methods (Instrukcje: Definiowanie i wykonywanie metod dynamicznych).

   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. Ukończ metodę dynamiczną, wywołując jej CreateDelegate metodę. add Użyj metody dostępu, aby dodać delegata do listy wywołań dla zdarzenia.

   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. Przetestuj zdarzenie. Poniższy kod ładuje formularz zdefiniowany w przykładzie kodu. Kliknięcie formularza wywołuje zarówno wstępnie zdefiniowaną procedurę obsługi zdarzeń, jak i program obsługi zdarzeń emitowanych.

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

   Application.Run((Form) exFormAsObj);
   

   Application.Run(CType(exFormAsObj, Form))
   

Przykład

Poniższy przykład kodu pokazuje, jak podłączyć istniejącą metodę do zdarzenia przy użyciu odbicia, a także jak używać DynamicMethod klasy do emitowania metody w czasie wykonywania i podłączać ją do zdarzenia.

#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

Zobacz też

• Assembly.Load
• DynamicMethod
• CreateInstance
• CreateDelegate
• Instrukcje: definiowanie i wykonywanie metod dynamicznych
• Odbicie