Como: Conectar um delegado usando reflexão

Quando você usa reflexão para carregar e executar assemblies, você não pode usar recursos de linguagem como o operador C# += ou a instrução AddHandler do Visual Basic para conectar eventos. Os procedimentos a seguir mostram como conectar um método existente a um evento, obtendo todos os tipos necessários por meio de reflexão, e como criar um método dinâmico usando a emissão de reflexão e conectá-lo a um evento.

Nota

Para outra maneira de conectar um delegado de manipulação de eventos, consulte o exemplo de código para o AddEventHandler método da EventInfo classe.

Para conectar um delegado usando reflexão

1. Carregue um assembly que contém um tipo que gera eventos. Os assemblies geralmente são carregados com o Assembly.Load método. Para manter este exemplo simples, um formulário derivado no assembly atual é usado, portanto, o GetExecutingAssembly método é usado para carregar o assembly atual.

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

   Assembly assem = typeof(Example).Assembly;
   

   Dim assem As Assembly = GetType(Example).Assembly
   

2. Obtenha um Type objeto que represente o tipo e crie uma instância do tipo. O CreateInstance(Type) método é usado no código a seguir porque o formulário tem um construtor sem parâmetros. Há várias outras sobrecargas do CreateInstance método que você pode usar se o tipo que você está criando não tem um construtor sem parâmetros. A nova instância é armazenada como tipo Object para manter a ficção de que nada se sabe sobre o assembly. (A reflexão permite que você obtenha os tipos em uma montagem sem saber seus nomes com antecedência.)

   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. Obtenha um EventInfo objeto que represente o evento e use a EventHandlerType propriedade para obter o tipo de delegado usado para manipular o evento. No código a seguir, um EventInfo para o Click evento é obtido.

   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. Obtenha um MethodInfo objeto que represente o método que manipula o evento. O código completo do programa na seção Exemplo mais adiante neste artigo contém um método que corresponde à assinatura do delegado, que manipula o Click evento, mas você também pode gerar métodos dinâmicos em tempo de EventHandler execução. Para obter detalhes, consulte o procedimento que acompanha o processo, para gerar um manipulador de eventos em tempo de execução usando um método dinâmico.

   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. Crie uma instância do delegado, usando o CreateDelegate método. Esse método é estático (Shared no Visual Basic), portanto, o tipo de delegado deve ser fornecido. Usando as sobrecargas de CreateDelegate que tomar um MethodInfo é recomendado.

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

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

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

6. Obtenha o add método accessor e invoque-o para conectar o evento. Todos os eventos têm um add acessador e um remove acessador, que são ocultos pela sintaxe de linguagens de alto nível. Por exemplo, C# usa o += operador para conectar eventos e Visual Basic usa a instrução AddHandler. O código a seguir obtém o addClick acessador do evento e o invoca tardiamente, passando na instância delegada. Os argumentos devem ser passados como uma matriz.

   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. Teste o evento. O código a seguir mostra o formulário definido no exemplo de código. Clicar no formulário invoca o manipulador de eventos.

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

   Application.Run((Form) exFormAsObj);
   

   Application.Run(CType(exFormAsObj, Form))
   

Gerar um manipulador de eventos em tempo de execução usando um método dinâmico

1. Os métodos do manipulador de eventos podem ser gerados em tempo de execução, usando métodos dinâmicos leves e emissão de reflexão. Para construir um manipulador de eventos, você precisa do tipo de retorno e dos tipos de parâmetro do delegado. Estes podem ser obtidos examinando o método do Invoke delegado. O código a seguir usa os GetDelegateReturnType métodos e GetDelegateParameterTypes para obter essas informações. O código para esses métodos pode ser encontrado na seção Exemplo mais adiante neste artigo.

   Não é necessário nomear um DynamicMethod, para que a string vazia possa ser usada. No código a seguir, o último argumento associa o método dinâmico ao tipo atual, dando ao delegado acesso a todos os membros públicos e privados da Example classe.

   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. Gere um corpo de método. Esse método carrega uma cadeia de caracteres, chama a sobrecarga do método que usa uma cadeia de caracteres, exibe o valor de retorno da pilha (porque o manipulador não tem tipo de MessageBox.Show retorno) e retorna. Para saber mais sobre como emitir métodos dinâmicos, consulte Como definir e executar métodos dinâmicos.

   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. Conclua o método dinâmico chamando seu CreateDelegate método. Use o add acessador para adicionar o delegado à lista de invocação do evento.

   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. Teste o evento. O código a seguir carrega o formulário definido no exemplo de código. Clicar no formulário invoca o manipulador de eventos predefinido e o manipulador de eventos emitido.

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

   Application.Run((Form) exFormAsObj);
   

   Application.Run(CType(exFormAsObj, Form))
   

Exemplo

O exemplo de código a seguir mostra como conectar um método existente a um evento usando reflexão e também como usar a DynamicMethod classe para emitir um método em tempo de execução e conectá-lo a um evento.

#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

Consulte também

• Assembly.Load
• DynamicMethod
• CreateInstance
• CreateDelegate
• Como: Definir e executar métodos dinâmicos
• Reflexão