如何：定义和执行动态方法

项目
08/12/2011

下面的过程显示如何定义和执行简单的动态方法和绑定到类实例的动态方法。有关动态方法的更多信息，请参见 DynamicMethod 类和反射发出动态方法应用场景。

定义和执行动态方法

声明一个用于执行方法的委托类型。考虑使用泛型委托，以将需要声明的委托类型数降到最低。下面的代码声明两种可用于 SquareIt 方法的委托类型，其中一个是泛型。

Private Delegate Function _
    SquareItInvoker(ByVal input As Integer) As Long 

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

private delegate long SquareItInvoker(int input);

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

private: 
    delegate long long SquareItInvoker(int input);

    generic<typename TReturn, typename TParameter0> 
        delegate TReturn OneParameter(TParameter0 p0);

创建用于指定动态方法的参数类型的数组。在此示例中，唯一的参数为 int（在 Visual Basic 中为 Integer），所以数组只有一个元素。
```
Dim methodArgs As Type() = { GetType(Integer) }
```
```
Type[] methodArgs = {typeof(int)};
```
```
array<Type^>^ methodArgs = { int::typeid };
```

创建 DynamicMethod。在此示例中，方法被命名为 SquareIt。

注意
不需要给出动态方法名，动态方法不能通过名称调用。多个动态方法可以具有相同的名称。但是，名称将在调用堆栈中显示并且可用于调试过程。

返回值的类型被指定为 long。该方法与包含 Example 类的模块关联，该类包含代码示例。可以指定任何加载的模块。动态方法的行为类似于模块级的 static 方法（在 Visual Basic 中为 Shared）。

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

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

DynamicMethod^ squareIt = gcnew DynamicMethod(
    "SquareIt", 
    long long::typeid, 
    methodArgs, 
    Example::typeid->Module);

发出方法体。在此示例中，ILGenerator 对象被用于发出 Microsoft 中间语言 (MSIL)。也可以结合使用 DynamicILInfo 对象与非托管代码生成器，来发出 DynamicMethod 的方法体。

此示例中的 MSIL 将该参数（属于 int）加载到堆栈上，将其转换为 long，复制该 long，然后将这两个数字相乘。这将把平方结果保留在堆栈中，方法只需将结果返回即可。

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)

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

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

通过调用 CreateDelegate 方法创建表示动态方法的委托（在步骤 1 中声明）的实例。创建完委托即完成了该方法，任何更改方法的进一步尝试（例如，添加更多 MSIL）都将被忽略。下面的代码使用泛型委托创建委托并调用它。

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

OneParameter<long, int> invokeSquareIt = 
    (OneParameter<long, int>)
    squareIt.CreateDelegate(typeof(OneParameter<long, int>));

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

OneParameter<long long, int>^ invokeSquareIt = 
    (OneParameter<long long, int>^)
    squareIt->CreateDelegate(OneParameter<long long, int>::typeid);

Console::WriteLine("123456789 squared = {0}",
    invokeSquareIt(123456789));

定义和执行绑定到对象的动态方法

声明一个用于执行方法的委托类型。考虑使用泛型委托，以将需要声明的委托类型数降到最低。下面的代码声明一个泛型委托类型，该类型可用于执行任何具有一个参数和一个返回值的方法，如果委托绑定到对象，则该类型也可以执行具有两个参数和一个返回值的方法。
```
Private Delegate Function _
    OneParameter(Of TReturn, TParameter0) _
    (ByVal p0 As TParameter0) As TReturn 
```
```
private delegate TReturn OneParameter<TReturn, TParameter0>
    (TParameter0 p0);
```
```
generic<typename TReturn, typename TParameter0> 
    delegate TReturn OneParameter(TParameter0 p0);
```
创建用于指定动态方法的参数类型的数组。如果表示方法的委托要绑定到对象，则第一个参数必须与委托绑定到的类型相匹配。在此示例中，有两个参数，分别属于 Example 和 int（在 Visual Basic 中为 Integer）类型。
```
Dim methodArgs2 As Type() = _
    { GetType(Example), GetType(Integer) }
```
```
Type[] methodArgs2 = { typeof(Example), typeof(int) };
```
```
array<Type^>^ methodArgs2 = { Example::typeid, int::typeid };
```

创建 DynamicMethod。在此示例中，方法没有名称。返回值的类型被指定为 int（在 Visual Basic 中为 Integer）。该方法可以访问 Example 类的私有和受保护成员。

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

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

DynamicMethod^ multiplyHidden = gcnew DynamicMethod(
    "", 
    int::typeid, 
    methodArgs2, 
    Example::typeid);

在此示例中，MSIL 加载第一个参数（一个 Example 类的实例），然后使用该参数加载类型 int 的私有实例字段的值。然后加载第二个参数，并将两个数相乘。如果结果大于 int，则该值将被截断，最高有效位将被丢弃。该方法返回，返回值保留在堆栈中。

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)

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

ILGenerator^ ilMH = multiplyHidden->GetILGenerator();
ilMH->Emit(OpCodes::Ldarg_0);

FieldInfo^ testInfo = Example::typeid->GetField("test",
    BindingFlags::NonPublic | BindingFlags::Instance);

ilMH->Emit(OpCodes::Ldfld, testInfo);
ilMH->Emit(OpCodes::Ldarg_1);
ilMH->Emit(OpCodes::Mul);
ilMH->Emit(OpCodes::Ret);

通过调用 CreateDelegate(Type, Object) 方法重载创建表示动态方法的委托（在步骤 1 中声明）的实例。创建完委托即完成了该方法，任何更改方法的进一步尝试（例如，添加更多 MSIL）都将被忽略。

注意
可以多次调用 CreateDelegate 方法，以创建绑定到目标类型的其他实例的委托。

下面的代码将该方法绑定到 Example 类的一个新实例，该类的私有测试字段设置为 42。也就是说，每次调用委托时，都将 Example 的实例传递给该方法的第一个参数。

使用委托 OneParameter 的原因是该方法的第一个参数始终会接收 Example 的实例。调用委托时，只需要使用第二个参数。

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

OneParameter<int, int> invoke = (OneParameter<int, int>)
    multiplyHidden.CreateDelegate(
        typeof(OneParameter<int, int>), 
        new Example(42)
    );

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

OneParameter<int, int>^ invoke = (OneParameter<int, int>^)
    multiplyHidden->CreateDelegate(
        OneParameter<int, int>::typeid, 
        gcnew Example(42)
    );

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

示例

下面的代码示例演示一个简单的动态方法和一个绑定到类实例的动态方法。

简单动态方法具有一个 32 位整数类型的参数，返回该整数的 64 位平方。使用泛型委托来调用该方法。

第二个动态方法有两个参数，分别属于 Example 和 int（在 Visual Basic 中为 Integer）类型。创建完动态方法后，将使用具有一个 int 类型参数的泛型委托将其绑定到 Example 的实例。该委托没有 Example 类型的参数，原因是方法的第一个参数始终接收 Example 的绑定实例。调用委托时，只提供 int 参数。此动态方法访问 Example 类的私有字段，并返回私有字段和 int 参数的乘积。

该代码示例定义可用于执行方法的委托。

Imports System
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
'

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 = {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. 
        //
        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 = {0}", invoke(3));
    }
}
/* This code example produces the following output:

123456789 squared = 15241578750190521
3 * test = 126
 */

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

public ref 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 long SquareItInvoker(int input);

    generic<typename TReturn, typename TParameter0> 
        delegate TReturn OneParameter(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.
        //
        array<Type^>^ methodArgs = { int::typeid };

        // 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 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 = gcnew DynamicMethod(
            "SquareIt", 
            long long::typeid, 
            methodArgs, 
            Example::typeid->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 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 long, int>^ invokeSquareIt = 
            (OneParameter<long long, int>^)
            squareIt->CreateDelegate(OneParameter<long long, int>::typeid);

        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. 
        //
        array<Type^>^ methodArgs2 = { Example::typeid, int::typeid };

        // 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 = gcnew DynamicMethod(
            "", 
            int::typeid, 
            methodArgs2, 
            Example::typeid);

        // 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 = Example::typeid->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(
                OneParameter<int, int>::typeid, 
                gcnew Example(42)
            );

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

void main()
{
    Example::Main();
}
/* This code example produces the following output:

123456789 squared = 15241578750190521
3 * test = 126
 */

编译代码

代码包含编译所需的 C# using 语句（在 Visual Basic 中为 Imports）。
不需要其他程序集引用。
在命令行使用 csc.exe、vbc.exe 或 cl.exe 编译代码。若要在 Visual Studio 中编译代码，请将代码置于控制台应用程序项目模板中。

请参见

通过

如何：定义和执行动态方法

定义和执行动态方法

定义和执行绑定到对象的动态方法

示例

编译代码

请参见

参考

概念

其他资源

其他资源