DynamicMethod Class

Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Globalization

Public Class Example
   ' Declare a delegate type that can be used to execute the completed
   ' dynamic method. 
   Private Delegate Function HelloDelegate(ByVal sendee As String, _
       ByVal square As Integer) As String

   Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)
      ' Create an array that specifies the types of the parameters
      ' of the dynamic method. This dynamic method has a String
      ' parameter and an Integer parameter.
      Dim helloArgs() As Type = {GetType(String), GetType(Integer)}

      ' Create a dynamic method with the name "Hello", a return type
      ' of Integer, and two parameters whose types are specified by
      ' the array helloArgs. 
      Dim hello As New DynamicMethod("Hello", _
          GetType(String), _
          helloArgs)

      ' Create an array that specifies the parameter types of the
      ' overload of String.Format to be used in Hello.
      Dim formatStringArgs() As Type = { GetType(String), GetType(Object), _
                                 GetType(Object), GetType(Object) }
      Dim formatString As MethodInfo = GetType(String). _
          GetMethod("Format", formatStringArgs)

      ' Get an ILGenerator and emit a body for the dynamic method,
      ' using a stream size larger than the IL that will be
      ' emitted.
      Dim il As ILGenerator = hello.GetILGenerator(256)
      ' Push the format string for String.Format on the stack.
      il.Emit(OpCodes.Ldstr, "Hello, {0}, {1} squared is {2}!")
      ' Load the first argument, which is a string, onto the stack,
      ' as the second argument of String.Format.
      il.Emit(OpCodes.Ldarg_0)
      ' Load the second argument, and box it. This is the third argument
      ' of String.Format, and because it is a value type it must be boxed
      ' in order to pass it as an object.
      il.Emit(OpCodes.Ldarg_1)
      il.Emit(OpCodes.Box, GetType(Integer))
      ' Load the second argument twice more, as the arguments of the 
      ' multiply operation that will square it. 
      il.Emit(OpCodes.Ldarg_1)
      il.Emit(OpCodes.Ldarg_1)
      ' Multiply the last two arguments on the stack, leaving the 
      ' result on the stack. The result must be boxed, so it can be passed
      ' as the fourth argument of String.Format.
      il.Emit(OpCodes.Mul)
      il.Emit(OpCodes.Box, GetType(Integer))
      ' Call the overload of String.Format that prints a string, formatting
      ' it to include the next three objects on the stack.
      il.Emit(OpCodes.Call, formatString)
      ' The Hello method returns the formatted string, which is already
      ' on the stack after the call to String.Format.
      il.Emit(OpCodes.Ret)

      ' Add parameter information to the dynamic method. (This is not
      ' necessary, but can be useful for debugging.) For each parameter,
      ' identified by position, supply the parameter attributes and a 
      ' parameter name.
      hello.DefineParameter(1, ParameterAttributes.In, "message")
      hello.DefineParameter(2, ParameterAttributes.In, "valueToReturn")

      ' Create a delegate that represents the dynamic method. This
      ' action completes the method. Any further attempts to
      ' change the method are ignored.
      Dim hi As HelloDelegate = _
                 CType(hello.CreateDelegate(GetType(HelloDelegate)), HelloDelegate)

      ' Use the delegate to execute the dynamic method.
      outputBlock.Text &= vbLf & "Use the delegate to execute the dynamic method:" & vbLf
      outputBlock.Text &= "hi(""Dad"", 42) returned: '" _
                       & hi("Dad", 42) & "'" & vbLf
      ' Execute it again, with different arguments.
      outputBlock.Text &= "hi(""Mom"", 5280) returned:  '" _
                       & hi("Mom", 5280) & "'" & vbLf

      outputBlock.Text &= vbLf & "Use the Invoke method to execute the dynamic method:" & vbLf
      ' Create an array of arguments to use with the Invoke method.
      Dim invokeArgs() As Object = { "Mom", 42 }
      ' Invoke the dynamic method using the arguments. This is much
      ' slower than using the delegate, because you must create an
      ' array to contain the arguments, and value-type arguments
      ' must be boxed.
      Dim objRet As Object = hello.Invoke(Nothing, _
          BindingFlags.ExactBinding, Nothing, invokeArgs, _
          New CultureInfo("en-us"))
      outputBlock.Text &= "hello.Invoke(...) returned:  '" & objRet & "'" & vbLf

      outputBlock.Text &= vbCrLf & _
          " ----- Display information about the dynamic method -----" & vbLf
      ' Display MethodAttributes for the dynamic method, set when 
      ' the dynamic method was created.
      outputBlock.Text &= String.Format("Method Attributes: {0}", _
          hello.Attributes) & vbLf

      ' Display the calling convention of the dynamic method, set when the 
      ' dynamic method was created.
      outputBlock.Text &= String.Format("Calling convention: {0}", _
          hello.CallingConvention) & vbLf

      ' Display the declaring type, which is always Nothing for dynamic
      ' methods.
      If hello.DeclaringType Is Nothing Then
         outputBlock.Text &= "DeclaringType is always Nothing for dynamic methods." & vbLf
      Else
         outputBlock.Text += String.Format("DeclaringType: {0}", hello.DeclaringType) & vbLf
      End If

      ' Display the default value for InitLocals.
      If hello.InitLocals Then
         outputBlock.Text &= "This method contains verifiable code."
      Else
         outputBlock.Text &= "This method contains unverifiable code."
      End If
      outputBlock.Text += String.Format(" (InitLocals = {0})", hello.InitLocals) & vbLf

      ' Display the module specified when the dynamic method was created.
      outputBlock.Text += String.Format("Module: {0}", hello.Module) & vbLf

      ' Display the name specified when the dynamic method was created.
      ' Note that the name can be blank.
      outputBlock.Text += String.Format("Name: {0}", hello.Name) & vbLf

      ' For dynamic methods, the reflected type is always Nothing.
      If hello.ReflectedType Is Nothing Then
         outputBlock.Text &= "ReflectedType is Nothing." & vbLf
      Else
         outputBlock.Text &= String.Format("ReflectedType: {0}", _
             hello.ReflectedType) &vbLf
      End If

      If hello.ReturnParameter Is Nothing Then
         outputBlock.Text &= "Method has no return parameter." & vbLf
      Else
         outputBlock.Text &= String.Format("Return parameter: {0}", _
             hello.ReturnParameter) & vbLf
      End If

      ' If the method has no return type, ReturnType is System.Void.
      outputBlock.Text += String.Format("Return type: {0}", hello.ReturnType) & vbCrLf

      ' ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
      ' that can be used to enumerate the custom attributes of the
      ' return value. At present, there is no way to set such custom
      ' attributes, so the list is empty.
      If hello.ReturnType Is GetType(System.Void) Then
         outputBlock.Text &= "The method has no return type." & vbLf
      Else
         Dim caProvider As ICustomAttributeProvider = _
             hello.ReturnTypeCustomAttributes
         Dim returnAttributes() As Object = _
             caProvider.GetCustomAttributes(True)
         If returnAttributes.Length = 0 Then
            outputBlock.Text &= "The return type has no custom attributes." & vbLf
         Else
            outputBlock.Text &= "The return type has the following custom attributes:" & vbLf
            For Each attr As Object In returnAttributes
               outputBlock.Text &= "     " & attr.ToString() & vbLf
            Next attr
         End If
      End If

      outputBlock.Text &= "ToString: " & hello.ToString() & vbLf

      ' Display parameter information.
      Dim parameters() As ParameterInfo = hello.GetParameters()
      outputBlock.Text &= "Parameters: name, type, ParameterAttributes" & vbLf
      For Each p As ParameterInfo In parameters
         outputBlock.Text &= String.Format("     {0}, {1}, {2}", _
             p.Name, p.ParameterType, p.Attributes) & vbLf
      Next p
   End Sub
End Class

' This code example produces the following output:
'
'Use the delegate to execute the dynamic method:
'hi("Dad", 42) returned:  'Hello, Dad, 42 squared is 1764!'
'hi("Mom", 5280) returned:  'Hello, Mom, 5280 squared is 27878400!'
'
'Use the Invoke method to execute the dynamic method:
'hello.Invoke returned:  'Hello, Mom, 42 squared is 1764!'
'
' ----- Display information about the dynamic method -----
'Method Attributes: PrivateScope, Public, Static
'Calling convention: Standard
'DeclaringType is always Nothing for dynamic methods.
'This method contains verifiable code. (InitLocals = True)
'Module: RefEmit_InMemoryManifestModule
'Name: Hello
'ReflectedType is Nothing.
'Method has no return parameter.
'Return type: System.Int32
'The return type has no custom attributes.
'ToString: Int32 Hello(System.String, Int32)
'Parameters: name, type, ParameterAttributes
'        message, System.String, In
'        valueToReturn, System.Int32, In

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

public class Example
{
   // Declare a delegate type that can be used to execute the completed
   // dynamic method. 
   private delegate string HelloDelegate(string sendee, int square);

   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      // Create an array that specifies the types of the parameters
      // of the dynamic method. This dynamic method has a String
      // parameter and an Integer parameter.
      Type[] helloArgs = { typeof(string), typeof(int) };

      // Create a dynamic method with the name "Hello", a return type
      // of String, and two parameters whose types are specified by
      // the array helloArgs. 
      DynamicMethod hello = new DynamicMethod("Hello",
          typeof(string),
          helloArgs);

      // Create an array that specifies the parameter types of the
      // overload of String.Format to be used in Hello.
      Type[] formatStringArgs = { typeof(string), typeof(object), typeof(object), 
                                 typeof(object) };
      // Get the overload of String.Format that has one String 
      // parameter for the format, and three object parameters.
      MethodInfo formatString = typeof(String).GetMethod("Format",
          formatStringArgs);

      // Get an ILGenerator and emit a body for the dynamic method,
      // using a stream size larger than the IL that will be
      // emitted.
      ILGenerator il = hello.GetILGenerator(256);
      // Push the format string for String.Format on the stack.
      il.Emit(OpCodes.Ldstr, "Hello, {0}, {1} squared is {2}!");
      // Load the first argument, which is a string, onto the stack,
      // as the second argument of String.Format.
      il.Emit(OpCodes.Ldarg_0);
      // Load the second argument, and box it. This is the third argument
      // of String.Format, and because it is a value type it must be boxed
      // in order to pass it as an object.
      il.Emit(OpCodes.Ldarg_1);
      il.Emit(OpCodes.Box, typeof(int));
      // Load the second argument twice more, as the arguments of the 
      // multiply operation that will square it. 
      il.Emit(OpCodes.Ldarg_1);
      il.Emit(OpCodes.Ldarg_1);
      // Multiply the last two arguments on the stack, leaving the 
      // result on the stack. The result must be boxed, so it can be passed
      // as the fourth argument of String.Format.
      il.Emit(OpCodes.Mul);
      il.Emit(OpCodes.Box, typeof(int));
      // Call the overload of String.Format that prints a string, formatting
      // it to include the next three objects on the stack.
      il.Emit(OpCodes.Call, formatString);
      // The Hello method returns the formatted string, which is already
      // on the stack after the call to String.Format.
      il.Emit(OpCodes.Ret);

      // Add parameter information to the dynamic method. (This is not
      // necessary, but can be useful for debugging.) For each parameter,
      // identified by position, supply the parameter attributes and a 
      // parameter name.
      hello.DefineParameter(1, ParameterAttributes.In, "message");
      hello.DefineParameter(2, ParameterAttributes.In, "valueToReturn");

      // Create a delegate that represents the dynamic method. This
      // action completes the method. Any further attempts to
      // change the method are ignored.
      HelloDelegate hi =
          (HelloDelegate)hello.CreateDelegate(typeof(HelloDelegate));

      // Use the delegate to execute the dynamic method.
      outputBlock.Text += "\r\nUse the delegate to execute the dynamic method:" + "\n";
      outputBlock.Text += "hi(\"Dad\", 42) returned: '" 
                       + hi("Dad", 42) + "'\n";
      // Execute it again, with different arguments.
      outputBlock.Text += "hi(\"Mom\", 5280) returned:  '" 
                       + hi("Mom", 5280) + "'\n";

      outputBlock.Text += "\r\nUse the Invoke method to execute the dynamic method:" + "\n";
      // Create an array of arguments to use with the Invoke method.
      object[] invokeArgs = { "Mom", 42 };
      // Invoke the dynamic method using the arguments. This is much
      // slower than using the delegate, because you must create an
      // array to contain the arguments, and value-type arguments
      // must be boxed.
      object objRet = hello.Invoke(null, BindingFlags.ExactBinding, null, invokeArgs, new CultureInfo("en-us"));
      outputBlock.Text += "hello.Invoke(...) returned:  '" + objRet + "'\n";

      outputBlock.Text += "\r\n ----- Display information about the dynamic method -----" + "\n";
      // Display MethodAttributes for the dynamic method, set when 
      // the dynamic method was created.
      outputBlock.Text += String.Format("Method Attributes: {0}", hello.Attributes) + "\n";

      // Display the calling convention of the dynamic method, set when the 
      // dynamic method was created.
      outputBlock.Text += String.Format("Calling convention: {0}", hello.CallingConvention) + "\n";

      // Display the declaring type, which is always null for dynamic
      // methods.
      if (hello.DeclaringType == null)
      {
         outputBlock.Text += "DeclaringType is always null for dynamic methods." + "\n";
      }
      else
      {
         outputBlock.Text += String.Format("DeclaringType: {0}", hello.DeclaringType) + "\n";
      }

      // Display the default value for InitLocals.
      if (hello.InitLocals)
      {
         outputBlock.Text += "This method contains verifiable code.";
      }
      else
      {
         outputBlock.Text += "This method contains unverifiable code.";
      }
      outputBlock.Text += String.Format(" (InitLocals = {0})", hello.InitLocals) + "\n";

      // Display the module specified when the dynamic method was created.
      outputBlock.Text += String.Format("Module: {0}", hello.Module) + "\n";

      // Display the name specified when the dynamic method was created.
      // Note that the name can be blank.
      outputBlock.Text += String.Format("Name: {0}", hello.Name) + "\n";

      // For dynamic methods, the reflected type is always null.
      if (hello.ReflectedType == null)
      {
         outputBlock.Text += "ReflectedType is null." + "\n";
      }
      else
      {
         outputBlock.Text += String.Format("ReflectedType: {0}", hello.ReflectedType) + "\n";
      }

      if (hello.ReturnParameter == null)
      {
         outputBlock.Text += "Method has no return parameter." + "\n";
      }
      else
      {
         outputBlock.Text += String.Format("Return parameter: {0}", hello.ReturnParameter) + "\n";
      }

      // If the method has no return type, ReturnType is System.Void.
      outputBlock.Text += String.Format("Return type: {0}", hello.ReturnType) + "\n";

      // ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
      // that can be used to enumerate the custom attributes of the
      // return value. At present, there is no way to set such custom
      // attributes, so the list is empty.
      if (hello.ReturnType == typeof(void))
      {
         outputBlock.Text += "The method has no return type." + "\n";
      }
      else
      {
         ICustomAttributeProvider caProvider = hello.ReturnTypeCustomAttributes;
         object[] returnAttributes = caProvider.GetCustomAttributes(true);
         if (returnAttributes.Length == 0)
         {
            outputBlock.Text += "The return type has no custom attributes." + "\n";
         }
         else
         {
            outputBlock.Text += "The return type has the following custom attributes:" + "\n";
            foreach (object attr in returnAttributes)
            {
               outputBlock.Text += "     " + attr.ToString() + "\n";
            }
         }
      }

      outputBlock.Text += String.Format("ToString: {0}", hello.ToString()) + "\n";

      // Display parameter information.
      ParameterInfo[] parameters = hello.GetParameters();
      outputBlock.Text += String.Format("Parameters: name, type, ParameterAttributes") + "\n";
      foreach (ParameterInfo p in parameters)
      {
         outputBlock.Text += String.Format("     {0}, {1}, {2}",
             p.Name, p.ParameterType, p.Attributes) + "\n";
      }
   }
}

/* This code example produces the following output:

Use the delegate to execute the dynamic method:
hi("Dad", 42) returned:  'Hello, Dad, 42 squared is 1764!'
hi("Mom", 5280) returned:  'Hello, Mom, 5280 squared is 27878400!'

Use the Invoke method to execute the dynamic method:
hello.Invoke returned:  'Hello, Mom, 42 squared is 1764!'

 ----- Display information about the dynamic method -----
Method Attributes: PrivateScope, Public, Static
Calling convention: Standard
DeclaringType is always null for dynamic methods.
This method contains verifiable code. (InitLocals = True)
Module: RefEmit_InMemoryManifestModule
Name: Hello
ReflectedType is null.
Method has no return parameter.
Return type: System.Int32
The return type has no custom attributes.
ToString: Int32 Hello(System.String, Int32)
Parameters: name, type, ParameterAttributes
        sendee, System.String, In
        valueToSquare, System.Int32, In
 */