ILGenerator Class

Imports System.Reflection
Imports System.Reflection.Emit

Class Example

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

      Dim myDomain As AppDomain = AppDomain.CurrentDomain
      Dim myAsmName As New AssemblyName("MyDynamicAssembly")

      Dim myAsmBuilder As AssemblyBuilder = _
         myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run)

      Dim pointModule As ModuleBuilder = _
         myAsmBuilder.DefineDynamicModule("PointModule")

      Dim pointTypeBld As TypeBuilder = pointModule.DefineType("Point", _
              TypeAttributes.Public)

      Dim xField As FieldBuilder = pointTypeBld.DefineField("x", _
           GetType(Integer), _
           FieldAttributes.Public)
      Dim yField As FieldBuilder = pointTypeBld.DefineField("y", _
           GetType(Integer), _
           FieldAttributes.Public)

      ' Base class and base class constructor.
      Dim objType As Type = Type.GetType("System.Object")
      Dim objCtor As ConstructorInfo = objType.GetConstructor(New Type() {})

      Dim ctorParams() As Type = {GetType(Integer), GetType(Integer)}

      Dim pointCtor As ConstructorBuilder = pointTypeBld.DefineConstructor( _
        MethodAttributes.Public, _
        CallingConventions.Standard, _
        ctorParams)
      Dim ctorIL As ILGenerator = pointCtor.GetILGenerator()

      ' Build the constructor. Begin by invoking the base class
      ' constructor. The zero-index parameter of the constructor
      ' is the new instance. Store the values of the fields.
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Call, objCtor)
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_1)
      ctorIL.Emit(OpCodes.Stfld, xField)
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_2)
      ctorIL.Emit(OpCodes.Stfld, yField)
      ctorIL.Emit(OpCodes.Ret)

      ' Build a method to output some information about the data
      ' in the dynamic class. This method will have the following
      ' signature:
      '    Public Sub WritePoint(ByVal outputBlock As TextBlock) 

      Dim obType As Type = outputBlock.GetType()
      Dim writePtMthd As MethodBuilder = pointTypeBld.DefineMethod("WritePoint", _
            MethodAttributes.Public, _
            Nothing, _
            New Type() { obType })

      ' To obtain the current text from the text block, and to 
      ' store the updated value, get the "get" and "set" accessors
      ' for the Text property:
      Dim textProp As PropertyInfo = obType.GetProperty("Text")
      Dim getter As MethodInfo = textProp.GetGetMethod()
      Dim setter As MethodInfo = textProp.GetSetMethod()

      ' To concatenate two strings, get the static Concat method of 
      ' the String class:
      Dim concat2 As MethodInfo = _
         GetType(String).GetMethod("Concat", _
                                   BindingFlags.Public Or BindingFlags.Static, _
                                   Type.DefaultBinder, _
                                   New Type() { GetType(String), GetType(String) }, _
                                   Nothing)

      ' To format the point values, get the String.Format method 
      ' overload that takes a format string and two values, which
      ' are passed as objects:
      '    String.Format(String, Object, Object)
      Dim sfParams() As Type = { GetType(String), GetType(Object), GetType(Object) }
        Dim strFormat As MethodInfo = _
           GetType(String).GetMethod("Format", _
                                     BindingFlags.Public Or BindingFlags.Static, _
                                     Type.DefaultBinder, _
                                     sfParams, Nothing)
      ' The format string.
      Dim ptFormat As String = "The value of the Point is: ({0}, {1})" & vbLf

      Dim il As ILGenerator = writePtMthd.GetILGenerator()

      ' At the very end of the method, the TextBlock instance needs 
      ' to be on the execution stack, to call the "set" accessor for
      ' the Text property. The TextBlock is the argument passed to
      ' WritePoint; load it onto the stack now.
      il.Emit(OpCodes.Ldarg_1)

      ' The existing value of the TextBlock.Text property must be on
      ' the stack, too, so load the TextBlock instance again. Then 
      ' call the "get" accessor for the Text property. The second
      ' TextBlock reference is popped off the stack, and the string 
      ' value is pushed onto the stack.
      il.Emit(OpCodes.Ldarg_1)
      il.Emit(OpCodes.Callvirt, getter)


      ' Now load the arguments for the static String.Format method.
      ' There's no need to load an instance, because this is a static
      ' method. Instead, load the first argument for String.Format by 
      ' pushing the format string onto the stack.
      il.Emit(OpCodes.Ldstr, ptFormat)

      ' Since the second argument is an object, and it corresponds to
      ' to the value of an integer field, the integer field must be 
      ' boxed - stored on the heap as an Object. To load the integer
      ' field, push a reference to the current instance of Point, which
      ' is always passed as the hidden 0-index parameter of an instance
      ' method. Load the field, which pops the Point off the stack.
      il.Emit(OpCodes.Ldarg_0)
      il.Emit(OpCodes.Ldfld, xField)

      ' Now execute the box opcode, which pops the value of field 'x'
      ' and pushes a reference to the integer value, boxed as an object.
      il.Emit(OpCodes.Box, GetType(Integer))

      ' Repeat the process for 'y'.
      il.Emit(OpCodes.Ldarg_0)
      il.Emit(OpCodes.Ldfld, yField)
      il.Emit(OpCodes.Box, GetType(Integer))

      ' All three arguments for String.Format are on the execution
      ' stack. Call the static method, which pops the three arguments
      ' off the stack and pushes the return value onto the stack.
      il.Emit(OpCodes.Call, strFormat)

      ' Call the static String.Concat method to concatenate the value
      ' of the Text property and the formatted string.
      il.Emit(OpCodes.Call, concat2)

      ' The stack now has an instance of TextBlock and the concatenated
      ' string. Call the "set" accessor, which pops these items off the
      ' stack and stores the string in the property. 
      il.Emit(OpCodes.Callvirt, setter)

      ' There is nothing left on the stack, so it is safe to return 
      ' from the Sub.
      il.Emit(OpCodes.Ret)

      ' Create the type, and then create an instance of the type with
      ' 'x' and 'y' values of 8 and 19.
      Dim ptType As Type = pointTypeBld.CreateType()
      Dim ptInstance As Object = Activator.CreateInstance(ptType, _
         New Object() { 8, 19 })

      ' Invoke WritePoint, to display the values.
      ptType.InvokeMember("WritePoint", _
         BindingFlags.InvokeMethod, _
         Type.DefaultBinder, _
         ptInstance, _
         New Object() {outputBlock})

   End Sub 
End Class 

' This code example produces the following output:
'
'The value of the Point is: (8, 19)

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

class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      AppDomain myDomain = AppDomain.CurrentDomain;
      AssemblyName myAsmName = new AssemblyName("MyDynamicAssembly");

      AssemblyBuilder myAsmBuilder = 
         myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);

      ModuleBuilder pointModule = myAsmBuilder.DefineDynamicModule("PointModule");

      TypeBuilder pointTypeBld = pointModule.DefineType("Point", TypeAttributes.Public);

      FieldBuilder xField = pointTypeBld.DefineField("x", typeof(int), FieldAttributes.Public);
      FieldBuilder yField = pointTypeBld.DefineField("y", typeof(int), FieldAttributes.Public);

      // Base class and base class constructor.
      Type objType = Type.GetType("System.Object");
      ConstructorInfo objCtor = objType.GetConstructor(new Type[] {});

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

      ConstructorBuilder pointCtor = 
         pointTypeBld.DefineConstructor(MethodAttributes.Public, 
                                        CallingConventions.Standard, ctorParams);
      ILGenerator ctorIL = pointCtor.GetILGenerator();

      // Build the constructor. Begin by invoking the base class
      // constructor. The zero-index parameter of the constructor
      // is the new instance. Store the values of the fields.
      ctorIL.Emit(OpCodes.Ldarg_0);
      ctorIL.Emit(OpCodes.Call, objCtor);
      ctorIL.Emit(OpCodes.Ldarg_0);
      ctorIL.Emit(OpCodes.Ldarg_1);
      ctorIL.Emit(OpCodes.Stfld, xField);
      ctorIL.Emit(OpCodes.Ldarg_0);
      ctorIL.Emit(OpCodes.Ldarg_2);
      ctorIL.Emit(OpCodes.Stfld, yField);
      ctorIL.Emit(OpCodes.Ret);

      // Build a method to output some information about the data
      // in the dynamic class. This method will have the following
      // signature:
      //    public void WritePoint(TextBlock outputBlock) 

      Type obType = outputBlock.GetType();
      MethodBuilder writePtMthd = 
         pointTypeBld.DefineMethod("WritePoint", 
                                   MethodAttributes.Public, 
                                   null, 
                                   new Type[] { obType });

      // To obtain the current text from the text block, and to 
      // store the updated value, get the "get" and "set" accessors
      // for the Text property:
      PropertyInfo textProp = obType.GetProperty("Text");
      MethodInfo getter = textProp.GetGetMethod();
      MethodInfo setter = textProp.GetSetMethod();

      // To concatenate two strings, get the static Concat method of 
      // the String class:
      MethodInfo concat2 = 
         typeof(string).GetMethod("Concat", 
                                  BindingFlags.Public | BindingFlags.Static, 
                                  Type.DefaultBinder, 
                                  new Type[] { typeof(string), typeof(string) }, 
                                  null);

      // To format the point values, get the String.Format method 
      // overload that takes a format string and two values, which
      // are passed as objects:
      //    String.Format(string, object, object)
      Type[] sfParams = { typeof(string), typeof(object), typeof(object) };
      MethodInfo strFormat = 
         typeof(string).GetMethod("Format", 
                                  BindingFlags.Public | BindingFlags.Static, 
                                  Type.DefaultBinder, 
                                  sfParams, null);
      // The format string.
      string ptFormat = "The value of the Point is: ({0}, {1})\n";

      ILGenerator il = writePtMthd.GetILGenerator();

      // At the very end of the method, the TextBlock instance needs 
      // to be on the execution stack, to call the "set" accessor for
      // the Text property. The TextBlock is the argument passed to
      // WritePoint; load it onto the stack now.
      il.Emit(OpCodes.Ldarg_1);

      // The existing value of the TextBlock.Text property must be on
      // the stack, too, so load the TextBlock instance again. Then 
      // call the "get" accessor for the Text property. The second
      // TextBlock reference is popped off the stack, and the string 
      // value is pushed onto the stack.
      il.Emit(OpCodes.Ldarg_1);
      il.Emit(OpCodes.Callvirt, getter);


      // Now load the arguments for the static String.Format method.
      // There's no need to load an instance, because this is a static
      // method. Instead, load the first argument for String.Format by 
      // pushing the format string onto the stack.
      il.Emit(OpCodes.Ldstr, ptFormat);

      // Since the second argument is an object, and it corresponds to
      // to the value of an integer field, the integer field must be 
      // boxed - stored on the heap as an Object. To load the integer
      // field, push a reference to the current instance of Point, which
      // is always passed as the hidden 0-index parameter of an instance
      // method. Load the field, which pops the Point off the stack.
      il.Emit(OpCodes.Ldarg_0);
      il.Emit(OpCodes.Ldfld, xField);

      // Now execute the box opcode, which pops the value of field 'x'
      // and pushes a reference to the integer value, boxed as an object.
      il.Emit(OpCodes.Box, typeof(int));

      // Repeat the process for 'y'.
      il.Emit(OpCodes.Ldarg_0);
      il.Emit(OpCodes.Ldfld, yField);
      il.Emit(OpCodes.Box, typeof(int));

      // All three arguments for String.Format are on the execution
      // stack. Call the static method, which pops the three arguments
      // off the stack and pushes the return value onto the stack.
      il.Emit(OpCodes.Call, strFormat);

      // Call the static String.Concat method to concatenate the value
      // of the Text property and the formatted string.
      il.Emit(OpCodes.Call, concat2);

      // The stack now has an instance of TextBlock and the concatenated
      // string. Call the "set" accessor, which pops these items off the
      // stack and stores the string in the property. 
      il.Emit(OpCodes.Callvirt, setter);

      // There is nothing left on the stack, so it is safe to return 
      // from the Sub.
      il.Emit(OpCodes.Ret);

      // Create the type, and then create an instance of the type with
      // 'x' and 'y' values of 8 and 19.
      Type ptType = pointTypeBld.CreateType();
      object ptInstance = Activator.CreateInstance(ptType, new object[] { 8, 19 });

      // Invoke WritePoint, to display the values.
      ptType.InvokeMember("WritePoint", 
                          BindingFlags.InvokeMethod, 
                          Type.DefaultBinder, 
                          ptInstance, 
                          new object[] { outputBlock });
   }
}

/* This code example produces the following output:

The value of the Point is: (8, 19)
 */