How to: Define and Execute Dynamic Methods

Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Runtime.InteropServices

Public Class Example

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

    ' The following delegates are used to invoke the methods.
    '
    Private Delegate Function Square(ByVal input As Integer) As Long
    Private Delegate Function Bound(ByVal input As Integer) As Integer
    Private Delegate Function Unbound(ByVal target As Example, _
        ByVal input As Integer) As Integer

    Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)

        outputBlock.Text &= "Example 1:" & vbLf & vbLf

        ' 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. 
        '
        Dim squareIt As New DynamicMethod( _
            "SquareIt", _
            GetType(Long), _
            methodArgs)

        ' 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 shows how to use the Square delegate,
        ' defined in this code example, and also Func, a generic 
        ' delegate that can produce delegate types matching any
        ' single-parameter method that has a return type.
        '
        Dim invokeSquareIt As Square = CType( _
            squareIt.CreateDelegate(GetType(Square)), _
            Square)

        outputBlock.Text &= String.Format("123456789 squared = {0}", _
            invokeSquareIt(123456789)) & vbCrLf

        Dim invokeGeneric As Func(Of Integer, Long) = CType( _
            squareIt.CreateDelegate(GetType(Func(Of Integer, Long))),  _
            Func(Of Integer, Long))

        outputBlock.Text &= String.Format("987654321 squared = {0}", _
            invokeGeneric(987654321)) & vbCrLf


        outputBlock.Text &= vbLf & "Example 2:" & vbLf & vbLf

        ' 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 an object of type Example. 
        '
        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 public members of the Example class. 
        '
        Dim multiplyTestField As New DynamicMethod( _
            "", _
            GetType(Integer), _
            methodArgs2)

        ' Emit the method body. In this example ILGenerator is used
        ' to emit the MSIL. 
        '
        ' The MSIL loads the first argument, which is an instance of
        ' the Example class, and uses it to get the value of the public
        ' instance field Text, 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 = multiplyTestField.GetILGenerator()
        ilMP.Emit(OpCodes.Ldarg_0)

        Dim testInfo As FieldInfo = _
            GetType(Example).GetField("Test", _
                BindingFlags.Public 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 Test field is set to 42. That 
        ' is, each time the delegate is invoked the same instance of
        ' Example is passed to the first parameter of the method.
        '
        ' The delegate Func is used, with a parameter of type Integer
        ' and a return type of Integer. The delegate doesn't have a
        ' parameter of type Example, because the instance of Example 
        ' is bound to the delegate, and therefore acts like a hidden 
        ' first parameter of the method.
        ' 
        ' The delegate is invoked invoked twice, with different 
        ' argument values. 
        '
        ' The program doesn't have a reference to the bound instance
        ' of Example, but it can be accessed through the Target 
        ' property of the delegate. The Target property is used to 
        ' multiply the Test field by two, and the delegate is 
        ' invoked again.
        '
        Dim invoke As Bound = CType( _
            multiplyTestField.CreateDelegate(GetType(Bound), New Example(42)), _
            Bound)

        outputBlock.Text &= String.Format( _
            "Example.Test = {0}; {1} * Example.Test = {2}" & vbLf, _
            invoke.Target.Test, 3, invoke(3))
        outputBlock.Text &= String.Format( _
            "Example.Test = {0}; {1} * Example.Test = {2}" & vbLf, _
            invoke.Target.Test, 5, invoke(5))

        invoke.Target.Test *= 2

        outputBlock.Text &= String.Format( _
            "Example.Test = {0}; {1} * Example.Test = {2}" & vbLf & vbLf, _
            invoke.Target.Test, 5, invoke(5))

        ' A second instance of Example is created, and bound to a new
        ' instance of the delegate. The delegate is invoked twice, and 
        ' between the two invocations the value of Test is incremented.
        '
        Dim ex As New Example(5280)

        Dim another As Bound = CType( _
            multiplyTestField.CreateDelegate(GetType(Bound), ex), _
            Bound)

        outputBlock.Text &= String.Format( _
            "Example.Test = {0}; {1} * Example.Test = {2}" & vbLf, _
            ex.Test, 3, another(3))

        ex.Test += 1

        outputBlock.Text &= String.Format( _
            "Example.Test = {0}; {1} * Example.Test = {2}" & vbLf & vbLf, _
            ex.Test, 3, another(3))

        ' Finally, the example creates a delegate of type Unbound, which
        ' takes two parameters: an instance of Example and an Integer.
        ' This delegate calls the same method without binding it to an
        ' instance of Example. The delegate is invoked with two new 
        ' instances of Example.
        '
        Dim notBound As Unbound = CType( _
            multiplyTestField.CreateDelegate(GetType(Unbound)), _
            Unbound)

        outputBlock.Text &= String.Format("{0} * Example.Test = {1}" & vbLf, _
            10, notBound(new Example(42), 10))
        outputBlock.Text &= String.Format("{0} * Example.Test = {1}" & vbLf, _
            10, notBound(new Example(56), 10))
    End Sub

End Class

' This code example produces the following output:
'
'Example 1:
'
'123456789 squared = 15241578750190521
'987654321 squared = 975461057789971041
'
'Example 2:
'
'Example.Test = 42; 3 * Example.Test = 126
'Example.Test = 42; 5 * Example.Test = 210
'Example.Test = 84; 5 * Example.Test = 420
'
'Example.Test = 5280; 3 * Example.Test = 15840
'Example.Test = 5281; 3 * Example.Test = 15843
'
'10 * Example.Test = 420
'10 * Example.Test = 560

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.InteropServices;

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

    // The following delegates are used to invoke the methods.
    //
    private delegate long Square(int input);
    private delegate int Bound(int input);
    private delegate int Unbound(Example target, int input);

    public static void Demo(System.Windows.Controls.TextBlock outputBlock)
    {
        outputBlock.Text += "Example 1:\n\n";

        // 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.
        //
        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. 
        //
        DynamicMethod squareIt = new DynamicMethod(
            "SquareIt", 
            typeof(long), 
            methodArgs
        );

        // 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.
        //
        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 shows how to use the Square delegate,
        // defined in this code example, and also Func, a generic 
        // delegate that can produce delegate types matching any
        // single-parameter method that has a return type.
        //
        Square invokeSquareIt = 
            (Square) squareIt.CreateDelegate(typeof(Square));

        outputBlock.Text += String.Format("123456789 squared = {0}\n",
            invokeSquareIt(123456789));

        Func<int, long> invokeGeneric = 
            (Func<int, long>) squareIt.CreateDelegate(typeof(Func<int, long>));

        outputBlock.Text += String.Format("987654321 squared = {0}\n",
            invokeGeneric(987654321));


        outputBlock.Text += "\nExample 2:\n\n";

        // 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 an object of type Example. 
        //
        Type[] methodArgs2 = { typeof(Example), typeof(int) };

        // 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 public members of the Example class. 
        //
        DynamicMethod multiplyTestField = new DynamicMethod(
            "", 
            typeof(int), 
            methodArgs2
        );

        // Emit the method body. In this example ILGenerator is used
        // to emit the MSIL. 
        //
        // The MSIL loads the first argument, which is an instance of
        // the Example class, and uses it to get the value of the public
        // instance field Text, 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.
        //
        ILGenerator ilMP = multiplyTestField.GetILGenerator();
        ilMP.Emit(OpCodes.Ldarg_0);

        FieldInfo testInfo = typeof(Example).GetField("Test", 
            BindingFlags.Public | 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 Test field is set to 42. That 
        // is, each time the delegate is invoked the same instance of
        // Example is passed to the first parameter of the method.
        //
        // The delegate Func is used, with a parameter of type Integer
        // and a return type of Integer. The delegate doesn't have a
        // parameter of type Example, because the instance of Example 
        // is bound to the delegate, and therefore acts like a hidden 
        // first parameter of the method.
        // 
        // The delegate is invoked invoked twice, with different 
        // argument values. 
        //
        // The program doesn't have a reference to the bound instance
        // of Example, but it can be accessed through the Target 
        // property of the delegate. The Target property is used to 
        // multiply the Test field by two, and the delegate is 
        // invoked again.
        //
        Bound invoke = (Bound) multiplyTestField.CreateDelegate(
            typeof(Bound), new Example(42));

        outputBlock.Text += String.Format(
            "Example.Test = {0}; {1} * Example.Test = {2}\n", 
            ((Example)invoke.Target).Test, 3, invoke(3));
        outputBlock.Text += String.Format(
            "Example.Test = {0}; {1} * Example.Test = {2}\n", 
            ((Example)invoke.Target).Test, 5, invoke(5));

        ((Example)invoke.Target).Test *= 2;

        outputBlock.Text += String.Format(
            "Example.Test = {0}; {1} * Example.Test = {2}\n\n", 
            ((Example)invoke.Target).Test, 5, invoke(5));

        // A second instance of Example is created, and bound to a new
        // instance of the delegate. The delegate is invoked twice, and 
        // between the two invocations the value of Test is incremented.
        //
        Example ex = new Example(5280);

        Bound another = 
            (Bound) multiplyTestField.CreateDelegate(typeof(Bound), ex);

        outputBlock.Text += String.Format(
            "Example.Test = {0}; {1} * Example.Test = {2}\n", 
            ex.Test, 3, another(3));

        ex.Test += 1;

        outputBlock.Text += String.Format(
            "Example.Test = {0}; {1} * Example.Test = {2}\n\n", 
            ex.Test, 3, another(3));

        // Finally, the example creates a delegate of type Unbound, which
        // takes two parameters: an instance of Example and an Integer.
        // This delegate calls the same method without binding it to an
        // instance of Example. The delegate is invoked with two new 
        // instances of Example.
        //
        Unbound notBound = 
            (Unbound) multiplyTestField.CreateDelegate(typeof(Unbound));

        outputBlock.Text += String.Format("{0} * Example.Test = {1}\n",
            10, notBound(new Example(42), 10));
        outputBlock.Text += String.Format("{0} * Example.Test = {1}\n",
            10, notBound(new Example(56), 10));
    }
}

/* This code example produces the following output:

Example 1:

123456789 squared = 15241578750190521
987654321 squared = 975461057789971041

Example 2:

Example.Test = 42; 3 * Example.Test = 126
Example.Test = 42; 5 * Example.Test = 210
Example.Test = 84; 5 * Example.Test = 420

Example.Test = 5280; 3 * Example.Test = 15840
Example.Test = 5281; 3 * Example.Test = 15843

10 * Example.Test = 420
10 * Example.Test = 560
 */