Практическое руководство. Подключение делегата с помощью отражения

Статья
11/05/2008

Обновлен: Ноябрь 2007

При использовании отражения для загрузки и запуска сборок невозможно использовать функциональные возможности языка, такие как оператор C# += или оператор AddHandler в Visual Basic, для подключения событий. В следующих процедурах показано, как подключить существующий метод к событию посредством получения всех необходимых типов через отражение и как создать динамический метод с помощью порожденного отражения и подключить этот метод к событию.

Примечание.
Другой способ подключения делегата, обрабатывающего событие, см. в примере кода для метода AddEventHandler класса EventInfo.

Чтобы подключить делегат с помощью отражения

Загрузите сборку, которая содержит тип, создающий события. Как правило, сборки загружаются с помощью метода Assembly.Load. Чтобы не усложнять этот пример, используется производная форма из текущей сборки, чтобы для загрузки текущей сборки использовался метод GetExecutingAssembly.
```
Dim assem As [Assembly] = [Assembly].GetExecutingAssembly()
```
```
Assembly assem = Assembly.GetExecutingAssembly();
```
Получите объект Type, который представляет тип, и создайте экземпляр типа. Метод CreateInstance(Type) используется в следующем кода, так как эта форма имеет конструктор по умолчанию. Существует несколько других перегрузок метода CreateInstance, которые можно использовать, если создаваемый тип не имеет конструктора по умолчанию. Новый экземпляр сохраняется как тип Object для поддержки утверждения, что об этой сборке ничего не известно. (Отражение позволяет получить типы в сборке, заведомо не зная их имена.)
```
Dim tExForm As Type = assem.GetType("ExampleForm")
Dim exFormAsObj As Object = _
    Activator.CreateInstance(tExForm)
```
```
Type tExForm = assem.GetType("ExampleForm");
Object exFormAsObj = Activator.CreateInstance(tExForm);
```
Получите объект EventInfo, который представляет событие, и используйте свойство EventHandlerType для получения типа делегата, используемого для обработки события. В следующем коде получается объект EventInfo для события Click.
```
Dim evClick As EventInfo = tExForm.GetEvent("Click")
Dim tDelegate As Type = evClick.EventHandlerType
```
```
EventInfo evClick = tExForm.GetEvent("Click");
Type tDelegate = evClick.EventHandlerType;
```
Получите объект MethodInfo, представляющий метод, обрабатывающий событие. Полные программный код в подразделе Пример этого раздела содержит метод, который соответствует подписи делегата EventHandler, который обрабатывает событие Click, однако также можно создавать динамические методы во время выполнения. Подробности см. в соответствующей процедуре Чтобы создать обработчик события во время выполнения, используя динамический метод.
```
Dim miHandler As MethodInfo = _
    GetType(Example).GetMethod("LuckyHandler", _
        BindingFlags.NonPublic Or BindingFlags.Instance)
```
```
MethodInfo miHandler = 
    typeof(Example).GetMethod("LuckyHandler", 
        BindingFlags.NonPublic | BindingFlags.Instance);
```
Создайте экземпляр делегата с помощью метода CreateDelegate. Этот метод является статическим (Shared в Visual Basic), поэтому следует предоставить тип делегата. Рекомендуется использовать перегрузки метода CreateDelegate, принимающие MethodInfo.
```
Dim d As [Delegate] = _
    [Delegate].CreateDelegate(tDelegate, Me, miHandler)
```
```
Delegate d = Delegate.CreateDelegate(tDelegate, this, miHandler);
```
Получите метод доступа add и вызовите его для подключения события. Все события имеют метод доступа add и метод доступа remove, которые скрыты с помощью синтаксиса в высокоуровневых языках. Например, в C# используется оператор += для подключения событий, а в Visual Basic используется оператор AddHandler. В следующем коде получается метод доступа add для события Click и вызывается с поздней привязкой, передавая в него экземпляр делегата. Аргументы должны передаваться в качестве массива.
```
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);
```
Проверьте событие. В следующем фрагменте кода показана форма, определенная в примере кода. Щелчок формы приводит к вызову обработчика события.
```
Application.Run(CType(exFormAsObj, Form))
```
```
Application.Run((Form) exFormAsObj);
```

Чтобы создать обработчик события во время выполнения с помощью динамического метода

Методы обработчика события могут быть созданы во время выполнения с помощью облегченных динамических методов и порождения отражения. Чтобы создать обработчик события будут необходимы тип возвращаемого значения и типы параметров делегата. Их можно получить посредством просмотра метода Invoke, относящегося к делегату. В следующем примере кода используются методы GetDelegateReturnType и GetDelegateParameterTypes для получения этих сведений. Код этих методов можно найти в подразделе Пример этого раздела.

Нет необходимости называть DynamicMethod, поэтому можно использовать пустую строку. В следующем коде последний аргумент связывает динамический метод с текущим типом, предоставляя доступ делегата ко всем открытым и закрытым элементам класса Example.
```
Dim returnType As Type = GetDelegateReturnType(tDelegate)
If returnType IsNot GetType(Void) Then
    Throw New ApplicationException("Delegate has a return type.")
End If

Dim handler As New DynamicMethod( _
    "", _
    Nothing, _
    GetDelegateParameterTypes(tDelegate), _
    GetType(Example) _
)
```
```
Type returnType = GetDelegateReturnType(tDelegate);
if (returnType != typeof(void))
    throw new ApplicationException("Delegate has a return type.");

DynamicMethod handler = 
    new DynamicMethod("", 
                      null,
                      GetDelegateParameterTypes(tDelegate),
                      typeof(Example));
```

Создайте основную часть метода. Этот метод загружает строку, вызывает перегрузку метода MessageBox.Show, которая принимает строку, берет возвращаемое значение со стека (потому что обработчик не имеет типа возвращаемого значения) и возвращается. Дополнительные сведения о выпуске динамических методов см. в разделе Практическое руководство. Определение и выполнение динамических методов.

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

Завершите динамический метод посредством вызова метода CreateDelegate. Используйте метод доступа add для добавления делегата в список вызова для этого события.
```
Dim dEmitted As [Delegate] = handler.CreateDelegate(tDelegate)
miAddHandler.Invoke(exFormAsObj, New Object() { dEmitted })
```
```
Delegate dEmitted = handler.CreateDelegate(tDelegate);
addHandler.Invoke(exFormAsObj, new Object[] { dEmitted });
```
Проверьте событие. В следующем фрагменте кода загружается форма, определенная в примере кода. Щелчок этой формы приводит к вызову предварительно определенного обработчика события и выпущенного обработчика события.
```
Application.Run(CType(exFormAsObj, Form))
```
```
Application.Run((Form) exFormAsObj);
```

Пример

В следующем примере кода показано, как подключить существующий метод к событию с помощью отражения, а также как использовать класс DynamicMethod для выпуска метода во время выполнения и подключить его к событию.

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

Компиляция кода

Код содержит операторы C# using (Imports в Visual Basic), необходимые для компиляции.
Отсутствует необходимость в дополнительных ссылках на сборки в целях компиляции из командной строки. В Visual Studio необходимо добавить ссылку в System.Windows.Forms.dll, так как этот пример является приложением консоли.
Откомпилируйте код из командной строки, используя команды csc.exe, vbc.exe или cl.exe. Чтобы откомпилировать код в Visual Studio, поместите его в шаблон проекта консольного приложения.

См. также

Поделиться через

Практическое руководство. Подключение делегата с помощью отражения

Чтобы подключить делегат с помощью отражения

Чтобы создать обработчик события во время выполнения с помощью динамического метода

Пример

Компиляция кода

См. также

Задачи

Ссылки

Другие ресурсы

Дополнительные ресурсы