DynamicMethod Class

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
 */