Практическое руководство. Определение и выполнение динамических методов

В следующих процедурах показано, как определить и выполнить простой динамический метод и динамический метод, привязанный к экземпляру класса. Дополнительные сведения о динамических методах см. в DynamicMethod классе.

1. Объявите тип делегата для выполнения метода. Рассмотрите возможность использования универсального делегата, чтобы свести к минимуму количество типов делегатов, которые необходимо объявить. Следующий код объявляет два типа делегатов, которые можно использовать для SquareIt метода, и один из них является универсальным.

   private delegate long SquareItInvoker(int input);
   
   private delegate TReturn OneParameter<TReturn, TParameter0>
       (TParameter0 p0);
   

   Private Delegate Function _
       SquareItInvoker(ByVal input As Integer) As Long
   
   Private Delegate Function _
       OneParameter(Of TReturn, TParameter0) _
       (ByVal p0 As TParameter0) As TReturn
   

2. Создайте массив, указывающий типы параметров для динамического метода. В этом примере единственным параметром является int (Integer в Visual Basic), поэтому массив имеет только один элемент.

   Type[] methodArgs = {typeof(int)};
   

   Dim methodArgs As Type() = {GetType(Integer)}
   

3. Создайте DynamicMethod. В этом примере метод называется SquareIt.

   Примечание.

   Не обязательно предоставлять имена динамических методов, и их нельзя вызывать по имени. Несколько динамических методов могут иметь одно и то же имя. Однако имя отображается в стеках вызовов и может быть полезно для отладки.

   Тип возвращаемого значения указывается как long. Метод связан с модулем, содержащим Example класс, который содержит пример кода. Можно указать любой загруженный модуль. Динамический метод действует как метод уровня static модуля (Shared в Visual Basic).

   DynamicMethod squareIt = new DynamicMethod(
       "SquareIt",
       typeof(long),
       methodArgs,
       typeof(Example).Module);
   

   Dim squareIt As New DynamicMethod( _
       "SquareIt", _
       GetType(Long), _
       methodArgs, _
       GetType(Example).Module)
   

4. Выпустите текст метода. В этом примере объект ILGenerator используется для генерации общего промежуточного языка (CIL). Кроме того, DynamicILInfo объект можно использовать в сочетании с неуправляемыми генераторами кода для выдачи текста метода для объекта DynamicMethod.

   CIL в этом примере загружает аргумент int на стек, преобразует его в long, дублирует long и умножает два числа. Это оставляет квадратный результат в стеке, и все, что должен сделать метод, возвращается.

   ILGenerator il = squareIt.GetILGenerator();
   il.Emit(OpCodes.Ldarg_0);
   il.Emit(OpCodes.Conv_I8);
   il.Emit(OpCodes.Dup);
   il.Emit(OpCodes.Mul);
   il.Emit(OpCodes.Ret);
   

   Dim il As ILGenerator = squareIt.GetILGenerator()
   il.Emit(OpCodes.Ldarg_0)
   il.Emit(OpCodes.Conv_I8)
   il.Emit(OpCodes.Dup)
   il.Emit(OpCodes.Mul)
   il.Emit(OpCodes.Ret)
   

5. Создайте экземпляр делегата (объявленного на шаге 1), который представляет динамический метод путем вызова CreateDelegate метода. Создание делегата завершает метод, и все дальнейшие попытки изменить метод ( например, добавление дополнительных CIL) игнорируются. Следующий код создает делегат и вызывает его с помощью универсального делегата.

   OneParameter<long, int> invokeSquareIt =
       (OneParameter<long, int>)
       squareIt.CreateDelegate(typeof(OneParameter<long, int>));
   
   Console.WriteLine($"123456789 squared = {invokeSquareIt(123456789)}");
   

   Dim invokeSquareIt As OneParameter(Of Long, Integer) = _
       CType( _
           squareIt.CreateDelegate( _
               GetType(OneParameter(Of Long, Integer))), _
           OneParameter(Of Long, Integer) _
       )
   
   Console.WriteLine("123456789 squared = {0}", _
       invokeSquareIt(123456789))
   

6. Объявите тип делегата для выполнения метода. Рассмотрите возможность использования универсального делегата, чтобы свести к минимуму количество типов делегатов, которые необходимо объявить. Следующий код объявляет универсальный тип делегата, который можно использовать для выполнения любого метода с одним параметром и возвращаемым значением, или методом с двумя параметрами и возвращаемым значением, если делегат привязан к объекту.

   private delegate TReturn OneParameter<TReturn, TParameter0>
       (TParameter0 p0);
   

   Private Delegate Function _
       OneParameter(Of TReturn, TParameter0) _
       (ByVal p0 As TParameter0) As TReturn
   

7. Создайте массив, указывающий типы параметров для динамического метода. Если делегат, представляющий метод, должен быть привязан к объекту, первый параметр должен соответствовать типу, к которым привязан делегат. В этом примере есть два параметра, типа Example и типа int (Integer в Visual Basic).

   Type[] methodArgs2 = { typeof(Example), typeof(int) };
   

   Dim methodArgs2 As Type() = _
       {GetType(Example), GetType(Integer)}
   

8. Создайте DynamicMethod. В этом примере метод не имеет имени. Тип возвращаемого значения указывается как int (Integer в Visual Basic). Метод имеет доступ к частным и защищенным членам Example класса.

   DynamicMethod multiplyHidden = new DynamicMethod(
       "",
       typeof(int),
       methodArgs2,
       typeof(Example));
   

   Dim multiplyPrivate As New DynamicMethod( _
       "", _
       GetType(Integer), _
       methodArgs2, _
       GetType(Example))
   

9. Выпустите текст метода. В этом примере объект ILGenerator используется для генерации общего промежуточного языка (CIL). Кроме того, DynamicILInfo объект можно использовать в сочетании с неуправляемыми генераторами кода для выдачи текста метода для объекта DynamicMethod.

   CIL в этом примере загружает первый аргумент, являющийся экземпляром Example класса, и использует его для загрузки значения поля частного экземпляра типа int. Второй аргумент загружается, а два числа умножаются. Если результат больше int, значение усечено, а самые значительные биты удаляются. Метод возвращает значение, помещенное в стек.

   ILGenerator ilMH = multiplyHidden.GetILGenerator();
   ilMH.Emit(OpCodes.Ldarg_0);
   
   FieldInfo testInfo = typeof(Example).GetField("test",
       BindingFlags.NonPublic | BindingFlags.Instance);
   
   ilMH.Emit(OpCodes.Ldfld, testInfo);
   ilMH.Emit(OpCodes.Ldarg_1);
   ilMH.Emit(OpCodes.Mul);
   ilMH.Emit(OpCodes.Ret);
   

   Dim ilMP As ILGenerator = multiplyPrivate.GetILGenerator()
   ilMP.Emit(OpCodes.Ldarg_0)
   
   Dim testInfo As FieldInfo = _
       GetType(Example).GetField("test", _
           BindingFlags.NonPublic Or BindingFlags.Instance)
   
   ilMP.Emit(OpCodes.Ldfld, testInfo)
   ilMP.Emit(OpCodes.Ldarg_1)
   ilMP.Emit(OpCodes.Mul)
   ilMP.Emit(OpCodes.Ret)
   

10. Создайте экземпляр делегата (объявленного на шаге 1), который представляет динамический метод путем вызова перегруженного метода CreateDelegate(Type, Object). Создание делегата завершает метод, и все дальнейшие попытки изменить метод ( например, добавление дополнительных CIL) игнорируются.

    Примечание.

    Метод можно вызывать CreateDelegate несколько раз, чтобы создать делегаты, привязанные к другим экземплярам целевого типа.

    Следующий код привязывает метод к новому экземпляру Example класса, частное поле теста которого имеет значение 42. То есть при каждом вызове делегата экземпляр Example передается первому параметру метода.

    OneParameter Делегат используется, так как первый параметр метода всегда получает экземпляр Example. При вызове делегата требуется только второй параметр.

    OneParameter<int, int> invoke = (OneParameter<int, int>)
        multiplyHidden.CreateDelegate(
            typeof(OneParameter<int, int>),
            new Example(42)
        );
    
    Console.WriteLine($"3 * test = {invoke(3)}");
    

    Dim invoke As OneParameter(Of Integer, Integer) = _
        CType( _
            multiplyPrivate.CreateDelegate( _
                GetType(OneParameter(Of Integer, Integer)), _
                new Example(42) _
            ), _
            OneParameter(Of Integer, Integer) _
        )
    
    Console.WriteLine("3 * test = {0}", invoke(3))
    

Пример

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

Простой динамический метод принимает один аргумент, 32-разрядное целое число и возвращает 64-разрядный квадрат целого числа. Универсальный делегат используется для вызова метода.

Второй динамический метод имеет два параметра: параметр типа Example и параметр типа int (Integer в Visual Basic). При создании динамического метода Example, он привязан к экземпляру Example, с использованием обобщенного делегата с одним аргументом типа . Делегат не имеет аргумента типа Example , так как первый параметр метода всегда получает связанный экземпляр Example. При вызове делегата предоставляется только int аргумент. Этот динамический метод обращается к частному полю Example класса и возвращает продукт частного поля и аргумента int .

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

using System;
using System.Reflection;
using System.Reflection.Emit;

public class Example
{
    // The following constructor and private field are used to
    // demonstrate a method bound to an object.
    private int test;
    public Example(int test) { this.test = test; }

    // Declare delegates that can be used to execute the completed
    // SquareIt dynamic method. The OneParameter delegate can be
    // used to execute any method with one parameter and a return
    // value, or a method with two parameters and a return value
    // if the delegate is bound to an object.
    //
    private delegate long SquareItInvoker(int input);

    private delegate TReturn OneParameter<TReturn, TParameter0>
        (TParameter0 p0);

    public static void Main()
    {
        // Example 1: A simple dynamic method.
        //
        // Create an array that specifies the parameter types for the
        // dynamic method. In this example the only parameter is an
        // int, so the array has only one element.
        //
        Type[] methodArgs = {typeof(int)};

        // Create a DynamicMethod. In this example the method is
        // named SquareIt. It is not necessary to give dynamic
        // methods names. They cannot be invoked by name, and two
        // dynamic methods can have the same name. However, the
        // name appears in calls stacks and can be useful for
        // debugging.
        //
        // In this example the return type of the dynamic method
        // is long. The method is associated with the module that
        // contains the Example class. Any loaded module could be
        // specified. The dynamic method is like a module-level
        // static method.
        //
        DynamicMethod squareIt = new DynamicMethod(
            "SquareIt",
            typeof(long),
            methodArgs,
            typeof(Example).Module);

        // Emit the method body. In this example ILGenerator is used
        // to emit the MSIL. DynamicMethod has an associated type
        // DynamicILInfo that can be used in conjunction with
        // unmanaged code generators.
        //
        // The MSIL loads the argument, which is an int, onto the
        // stack, converts the int to a long, duplicates the top
        // item on the stack, and multiplies the top two items on the
        // stack. This leaves the squared number on the stack, and
        // all the method has to do is return.
        //
        ILGenerator il = squareIt.GetILGenerator();
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Conv_I8);
        il.Emit(OpCodes.Dup);
        il.Emit(OpCodes.Mul);
        il.Emit(OpCodes.Ret);

        // Create a delegate that represents the dynamic method.
        // Creating the delegate completes the method, and any further
        // attempts to change the method (for example, by adding more
        // MSIL) are ignored. The following code uses a generic
        // delegate that can produce delegate types matching any
        // single-parameter method that has a return type.
        //
        OneParameter<long, int> invokeSquareIt =
            (OneParameter<long, int>)
            squareIt.CreateDelegate(typeof(OneParameter<long, int>));

        Console.WriteLine($"123456789 squared = {invokeSquareIt(123456789)}");

        // Example 2: A dynamic method bound to an instance.
        //
        // Create an array that specifies the parameter types for a
        // dynamic method. If the delegate representing the method
        // is to be bound to an object, the first parameter must
        // match the type the delegate is bound to. In the following
        // code the bound instance is of the Example class.
        //
        Type[] methodArgs2 = { typeof(Example), typeof(int) };

        // Create a DynamicMethod. In this example the method has no
        // name. The return type of the method is int. The method
        // has access to the protected and private data of the
        // Example class.
        //
        DynamicMethod multiplyHidden = new DynamicMethod(
            "",
            typeof(int),
            methodArgs2,
            typeof(Example));

        // Emit the method body. In this example ILGenerator is used
        // to emit the MSIL. DynamicMethod has an associated type
        // DynamicILInfo that can be used in conjunction with
        // unmanaged code generators.
        //
        // The MSIL loads the first argument, which is an instance of
        // the Example class, and uses it to load the value of a
        // private instance field of type int. The second argument is
        // loaded, and the two numbers are multiplied. If the result
        // is larger than int, the value is truncated and the most
        // significant bits are discarded. The method returns, with
        // the return value on the stack.
        //
        ILGenerator ilMH = multiplyHidden.GetILGenerator();
        ilMH.Emit(OpCodes.Ldarg_0);

        FieldInfo testInfo = typeof(Example).GetField("test",
            BindingFlags.NonPublic | BindingFlags.Instance);

        ilMH.Emit(OpCodes.Ldfld, testInfo);
        ilMH.Emit(OpCodes.Ldarg_1);
        ilMH.Emit(OpCodes.Mul);
        ilMH.Emit(OpCodes.Ret);

        // Create a delegate that represents the dynamic method.
        // Creating the delegate completes the method, and any further
        // attempts to change the method — for example, by adding more
        // MSIL — are ignored.
        //
        // The following code binds the method to a new instance
        // of the Example class whose private test field is set to 42.
        // That is, each time the delegate is invoked the instance of
        // Example is passed to the first parameter of the method.
        //
        // The delegate OneParameter is used, because the first
        // parameter of the method receives the instance of Example.
        // When the delegate is invoked, only the second parameter is
        // required.
        //
        OneParameter<int, int> invoke = (OneParameter<int, int>)
            multiplyHidden.CreateDelegate(
                typeof(OneParameter<int, int>),
                new Example(42)
            );

        Console.WriteLine($"3 * test = {invoke(3)}");
    }
}
/* This code example produces the following output:

123456789 squared = 15241578750190521
3 * test = 126
 */

Imports System.Reflection
Imports System.Reflection.Emit

Public Class Example

    ' The following constructor and private field are used to
    ' demonstrate a method bound to an object.
    '
    Private test As Integer
    Public Sub New(ByVal test As Integer)
        Me.test = test
    End Sub

    ' Declare delegates that can be used to execute the completed 
    ' SquareIt dynamic method. The OneParameter delegate can be 
    ' used to execute any method with one parameter and a return
    ' value, or a method with two parameters and a return value
    ' if the delegate is bound to an object.
    '
    Private Delegate Function _
        SquareItInvoker(ByVal input As Integer) As Long

    Private Delegate Function _
        OneParameter(Of TReturn, TParameter0) _
        (ByVal p0 As TParameter0) As TReturn

    Public Shared Sub Main()

        ' Example 1: A simple dynamic method.
        '
        ' Create an array that specifies the parameter types for the
        ' dynamic method. In this example the only parameter is an 
        ' Integer, so the array has only one element.
        '
        Dim methodArgs As Type() = {GetType(Integer)}

        ' Create a DynamicMethod. In this example the method is
        ' named SquareIt. It is not necessary to give dynamic 
        ' methods names. They cannot be invoked by name, and two
        ' dynamic methods can have the same name. However, the 
        ' name appears in calls stacks and can be useful for
        ' debugging. 
        '
        ' In this example the return type of the dynamic method
        ' is Long. The method is associated with the module that 
        ' contains the Example class. Any loaded module could be
        ' specified. The dynamic method is like a module-level
        ' Shared method.
        '
        Dim squareIt As New DynamicMethod( _
            "SquareIt", _
            GetType(Long), _
            methodArgs, _
            GetType(Example).Module)

        ' Emit the method body. In this example ILGenerator is used
        ' to emit the MSIL. DynamicMethod has an associated type
        ' DynamicILInfo that can be used in conjunction with 
        ' unmanaged code generators.
        '
        ' The MSIL loads the argument, which is an Integer, onto the 
        ' stack, converts the Integer to a Long, duplicates the top
        ' item on the stack, and multiplies the top two items on the
        ' stack. This leaves the squared number on the stack, and 
        ' all the method has to do is return.
        '
        Dim il As ILGenerator = squareIt.GetILGenerator()
        il.Emit(OpCodes.Ldarg_0)
        il.Emit(OpCodes.Conv_I8)
        il.Emit(OpCodes.Dup)
        il.Emit(OpCodes.Mul)
        il.Emit(OpCodes.Ret)

        ' Create a delegate that represents the dynamic method. 
        ' Creating the delegate completes the method, and any further 
        ' attempts to change the method (for example, by adding more
        ' MSIL) are ignored. The following code uses a generic 
        ' delegate that can produce delegate types matching any
        ' single-parameter method that has a return type.
        '
        Dim invokeSquareIt As OneParameter(Of Long, Integer) = _
            CType( _
                squareIt.CreateDelegate( _
                    GetType(OneParameter(Of Long, Integer))), _
                OneParameter(Of Long, Integer) _
            )

        Console.WriteLine("123456789 squared = {0}", _
            invokeSquareIt(123456789))


        ' Example 2: A dynamic method bound to an instance.
        '
        ' Create an array that specifies the parameter types for a
        ' dynamic method. If the delegate representing the method
        ' is to be bound to an object, the first parameter must 
        ' match the type the delegate is bound to. In the following
        ' code the bound instance is of the Example class. 
        '
        Dim methodArgs2 As Type() = _
            {GetType(Example), GetType(Integer)}

        ' Create a DynamicMethod. In this example the method has no
        ' name. The return type of the method is Integer. The method 
        ' has access to the protected and private members of the 
        ' Example class. 
        '
        Dim multiplyPrivate As New DynamicMethod( _
            "", _
            GetType(Integer), _
            methodArgs2, _
            GetType(Example))

        ' Emit the method body. In this example ILGenerator is used
        ' to emit the MSIL. DynamicMethod has an associated type
        ' DynamicILInfo that can be used in conjunction with 
        ' unmanaged code generators.
        '
        ' The MSIL loads the first argument, which is an instance of
        ' the Example class, and uses it to load the value of a 
        ' private instance field of type Integer. The second argument 
        ' is loaded, and the two numbers are multiplied. If the result
        ' is larger than Integer, the value is truncated and the most 
        ' significant bits are discarded. The method returns, with
        ' the return value on the stack.
        '
        Dim ilMP As ILGenerator = multiplyPrivate.GetILGenerator()
        ilMP.Emit(OpCodes.Ldarg_0)

        Dim testInfo As FieldInfo = _
            GetType(Example).GetField("test", _
                BindingFlags.NonPublic Or BindingFlags.Instance)

        ilMP.Emit(OpCodes.Ldfld, testInfo)
        ilMP.Emit(OpCodes.Ldarg_1)
        ilMP.Emit(OpCodes.Mul)
        ilMP.Emit(OpCodes.Ret)

        ' Create a delegate that represents the dynamic method. 
        ' Creating the delegate completes the method, and any further 
        ' attempts to change the method  for example, by adding more
        ' MSIL  are ignored. 
        ' 
        ' The following code binds the method to a new instance
        ' of the Example class whose private test field is set to 42.
        ' That is, each time the delegate is invoked the instance of
        ' Example is passed to the first parameter of the method.
        '
        ' The delegate OneParameter is used, because the first
        ' parameter of the method receives the instance of Example.
        ' When the delegate is invoked, only the second parameter is
        ' required. 
        '
        Dim invoke As OneParameter(Of Integer, Integer) = _
            CType( _
                multiplyPrivate.CreateDelegate( _
                    GetType(OneParameter(Of Integer, Integer)), _
                    new Example(42) _
                ), _
                OneParameter(Of Integer, Integer) _
            )

        Console.WriteLine("3 * test = {0}", invoke(3))

    End Sub

End Class

' This code example produces the following output:
'
'123456789 squared = 15241578750190521
'3 * test = 126
' 

См. также

• DynamicMethod