Export (0) Print
Expand All
1 out of 1 rated this helpful - Rate this topic

ILGenerator.EmitCall Method

Puts a call or callvirt instruction onto the Microsoft intermediate language (MSIL) stream.

[Visual Basic]
Public Sub EmitCall( _
   ByVal opcode As OpCode, _
   ByVal methodInfo As MethodInfo, _
   ByVal optionalParameterTypes() As Type _
)
[C#]
public void EmitCall(
 OpCode opcode,
 MethodInfo methodInfo,
 Type[] optionalParameterTypes
);
[C++]
public: void EmitCall(
 OpCode opcode,
 MethodInfo* methodInfo,
 Type* optionalParameterTypes[]
);
[JScript]
public function EmitCall(
   opcode : OpCode,
 methodInfo : MethodInfo,
 optionalParameterTypes : Type[]
);

Parameters

opcode
The MSIL instruction to be emitted onto the stream.
methodInfo
The method to be called.
optionalParameterTypes
The types of the optional arguments if the method is a varargs method.

Exceptions

Exception Type Condition
ArgumentNullException methodInfo is a null reference (Nothing in Visual Basic).
InvalidOperationException The calling convention for the method is not varargs but optional parameter types are supplied.

Remarks

This method cannot be used to call a constructor. Instead, use the overloaded Emit method that takes a ConstructorInfo argument.

Example

[Visual Basic, C#, C++] The following code sample demonstrates the contextual usage of the EmitCall method to call a method external to the dynamic class.

[Visual Basic] 
Imports System
Imports System.Text
Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

 _

' The Point class is the class we will reflect on and copy into our
' dynamic assembly. The public static function PointMain() will be used
' as our entry point.
'
' We are constructing the type seen here dynamically, and will write it
' out into a .exe file for later execution from the command-line.
' --- 
' Class Point
'    
'    Private x As Integer
'    Private y As Integer
'    
'    
'    Public Sub New(ix As Integer, iy As Integer)
'       
'       Me.x = ix
'       Me.y = iy
'    End Sub 'New
'     
'    
'    Public Function DotProduct(p As Point) As Integer
'       
'       Return Me.x * p.x + Me.y * p.y
'    End Function 'DotProduct
'     
'    
'    Public Shared Sub Main()
'       
'       Console.Write("Enter the 'x' value for point 1: ")
'       Dim x1 As Integer = Convert.ToInt32(Console.ReadLine())
'       
'       Console.Write("Enter the 'y' value for point 1: ")
'       Dim y1 As Integer = Convert.ToInt32(Console.ReadLine())
'       
'       Console.Write("Enter the 'x' value for point 2: ")
'       Dim x2 As Integer = Convert.ToInt32(Console.ReadLine())
'       
'       Console.Write("Enter the 'y' value for point 2: ")
'       Dim y2 As Integer = Convert.ToInt32(Console.ReadLine())
'       
'       Dim p1 As New Point(x1, y1)
'       Dim p2 As New Point(x2, y2)
'       
'       Console.WriteLine("({0}, {1}) . ({2}, {3}) = {4}.", x1, y1, x2, y2, p1.DotProduct(p2))
'    End Sub 'Main
' End Class 'Point 
' ---
Class AssemblyBuilderDemo
   
   
   Public Shared Function BuildDynAssembly() As Type
      
      Dim pointType As Type = Nothing
      
      Dim currentDom As AppDomain = Thread.GetDomain()
      
      Console.Write("Please enter a name for your new assembly: ")
      Dim asmFileNameBldr As New StringBuilder()
      asmFileNameBldr.Append(Console.ReadLine())
      asmFileNameBldr.Append(".exe")
      Dim asmFileName As String = asmFileNameBldr.ToString()
      
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "MyDynamicAssembly"
      
      Dim myAsmBldr As AssemblyBuilder = currentDom.DefineDynamicAssembly(myAsmName, _
                     AssemblyBuilderAccess.RunAndSave)
      
      ' We've created a dynamic assembly space - now, we need to create a module
      ' within it to reflect the type Point into.
      Dim myModuleBldr As ModuleBuilder = myAsmBldr.DefineDynamicModule(asmFileName, _
                                    asmFileName)
      
      Dim myTypeBldr As TypeBuilder = myModuleBldr.DefineType("Point")
      
      Dim xField As FieldBuilder = myTypeBldr.DefineField("x", GetType(Integer), _
                                  FieldAttributes.Private)
      Dim yField As FieldBuilder = myTypeBldr.DefineField("y", GetType(Integer), _
                               FieldAttributes.Private)
      
      ' Build the 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 = myTypeBldr.DefineConstructor( _
                        MethodAttributes.Public, _
                        CallingConventions.Standard, _
                        ctorParams)
      Dim ctorIL As ILGenerator = pointCtor.GetILGenerator()
      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 the DotProduct method.
      Console.WriteLine("Constructor built.")
      
      Dim pointDPBldr As MethodBuilder = myTypeBldr.DefineMethod("DotProduct", _
                                 MethodAttributes.Public, _
                                 GetType(Integer), _
                                 New Type(0) {myTypeBldr})
      
      Dim dpIL As ILGenerator = pointDPBldr.GetILGenerator()
      dpIL.Emit(OpCodes.Ldarg_0)
      dpIL.Emit(OpCodes.Ldfld, xField)
      dpIL.Emit(OpCodes.Ldarg_1)
      dpIL.Emit(OpCodes.Ldfld, xField)
      dpIL.Emit(OpCodes.Mul_Ovf_Un)
      dpIL.Emit(OpCodes.Ldarg_0)
      dpIL.Emit(OpCodes.Ldfld, yField)
      dpIL.Emit(OpCodes.Ldarg_1)
      dpIL.Emit(OpCodes.Ldfld, yField)
      dpIL.Emit(OpCodes.Mul_Ovf_Un)
      dpIL.Emit(OpCodes.Add_Ovf_Un)
      dpIL.Emit(OpCodes.Ret)
      
      ' Build the PointMain method.
      Console.WriteLine("DotProduct built.")
      
      Dim pointMainBldr As MethodBuilder = myTypeBldr.DefineMethod("PointMain", _
                              MethodAttributes.Public Or _
                              MethodAttributes.Static, _
                              Nothing, Nothing)
      pointMainBldr.InitLocals = True
      Dim pmIL As ILGenerator = pointMainBldr.GetILGenerator()
      
      ' We have four methods that we wish to call, and must represent as
      ' MethodInfo tokens:
      ' - Sub Console.WriteLine(string)
      ' - Function Console.ReadLine() As String
      ' - Function Convert.Int32(string) As Int
      ' - Sub Console.WriteLine(string, object[])

      Dim writeMI As MethodInfo = GetType(Console).GetMethod("Write", _
                               New Type(0) {GetType(String)}) 
                                     
      Dim readLineMI As MethodInfo = GetType(Console).GetMethod("ReadLine", _
                              New Type() {})
      Dim convertInt32MI As MethodInfo = GetType(Convert).GetMethod("ToInt32", _
                              New Type(0) {GetType(String)})
      Dim wlParams() As Type = {GetType(String), GetType(Object())}
      Dim writeLineMI As MethodInfo = GetType(Console).GetMethod("WriteLine", wlParams)
      
      ' Although we could just refer to the local variables by
      ' index (short ints for Ldloc/Stloc, bytes for LdLoc_S/Stloc_S),
      ' this time, we'll use LocalBuilders for clarity and to
      ' demonstrate their usage and syntax.

      Dim x1LB As LocalBuilder = pmIL.DeclareLocal(GetType(Integer))
      Dim y1LB As LocalBuilder = pmIL.DeclareLocal(GetType(Integer))
      Dim x2LB As LocalBuilder = pmIL.DeclareLocal(GetType(Integer))
      Dim y2LB As LocalBuilder = pmIL.DeclareLocal(GetType(Integer))
      Dim point1LB As LocalBuilder = pmIL.DeclareLocal(myTypeBldr)
      Dim point2LB As LocalBuilder = pmIL.DeclareLocal(myTypeBldr)
      Dim tempObjArrLB As LocalBuilder = pmIL.DeclareLocal(GetType(Object()))
      
      pmIL.Emit(OpCodes.Ldstr, "Enter the 'x' value for point 1: ")
      pmIL.EmitCall(OpCodes.Call, writeMI, Nothing)
      pmIL.EmitCall(OpCodes.Call, readLineMI, Nothing)
      pmIL.EmitCall(OpCodes.Call, convertInt32MI, Nothing)
      pmIL.Emit(OpCodes.Stloc, x1LB)
      
      pmIL.Emit(OpCodes.Ldstr, "Enter the 'y' value for point 1: ")
      pmIL.EmitCall(OpCodes.Call, writeMI, Nothing)
      pmIL.EmitCall(OpCodes.Call, readLineMI, Nothing)
      pmIL.EmitCall(OpCodes.Call, convertInt32MI, Nothing)
      pmIL.Emit(OpCodes.Stloc, y1LB)
      
      pmIL.Emit(OpCodes.Ldstr, "Enter the 'x' value for point 2: ")
      pmIL.EmitCall(OpCodes.Call, writeMI, Nothing)
      pmIL.EmitCall(OpCodes.Call, readLineMI, Nothing)
      pmIL.EmitCall(OpCodes.Call, convertInt32MI, Nothing)
      pmIL.Emit(OpCodes.Stloc, x2LB)
      
      pmIL.Emit(OpCodes.Ldstr, "Enter the 'y' value for point 2: ")
      pmIL.EmitCall(OpCodes.Call, writeMI, Nothing)
      pmIL.EmitCall(OpCodes.Call, readLineMI, Nothing)
      pmIL.EmitCall(OpCodes.Call, convertInt32MI, Nothing)
      pmIL.Emit(OpCodes.Stloc, y2LB)
      
      pmIL.Emit(OpCodes.Ldloc, x1LB)
      pmIL.Emit(OpCodes.Ldloc, y1LB)
      pmIL.Emit(OpCodes.Newobj, pointCtor)
      pmIL.Emit(OpCodes.Stloc, point1LB)
      
      pmIL.Emit(OpCodes.Ldloc, x2LB)
      pmIL.Emit(OpCodes.Ldloc, y2LB)
      pmIL.Emit(OpCodes.Newobj, pointCtor)
      pmIL.Emit(OpCodes.Stloc, point2LB)
      
      pmIL.Emit(OpCodes.Ldstr, "({0}, {1}) . ({2}, {3}) = {4}.")
      pmIL.Emit(OpCodes.Ldc_I4_5)
      pmIL.Emit(OpCodes.Newarr, GetType([Object]))
      pmIL.Emit(OpCodes.Stloc, tempObjArrLB)
      
      pmIL.Emit(OpCodes.Ldloc, tempObjArrLB)
      pmIL.Emit(OpCodes.Ldc_I4_0)
      pmIL.Emit(OpCodes.Ldloc, x1LB)
      pmIL.Emit(OpCodes.Box, GetType(Integer))
      pmIL.Emit(OpCodes.Stelem_Ref)
      
      pmIL.Emit(OpCodes.Ldloc, tempObjArrLB)
      pmIL.Emit(OpCodes.Ldc_I4_1)
      pmIL.Emit(OpCodes.Ldloc, y1LB)
      pmIL.Emit(OpCodes.Box, GetType(Integer))
      pmIL.Emit(OpCodes.Stelem_Ref)
      
      pmIL.Emit(OpCodes.Ldloc, tempObjArrLB)
      pmIL.Emit(OpCodes.Ldc_I4_2)
      pmIL.Emit(OpCodes.Ldloc, x2LB)
      pmIL.Emit(OpCodes.Box, GetType(Integer))
      pmIL.Emit(OpCodes.Stelem_Ref)
      
      pmIL.Emit(OpCodes.Ldloc, tempObjArrLB)
      pmIL.Emit(OpCodes.Ldc_I4_3)
      pmIL.Emit(OpCodes.Ldloc, y2LB)
      pmIL.Emit(OpCodes.Box, GetType(Integer))
      pmIL.Emit(OpCodes.Stelem_Ref)
      
      pmIL.Emit(OpCodes.Ldloc, tempObjArrLB)
      pmIL.Emit(OpCodes.Ldc_I4_4)
      pmIL.Emit(OpCodes.Ldloc, point1LB)
      pmIL.Emit(OpCodes.Ldloc, point2LB)
      pmIL.EmitCall(OpCodes.Callvirt, pointDPBldr, Nothing)
      
      pmIL.Emit(OpCodes.Box, GetType(Integer))
      pmIL.Emit(OpCodes.Stelem_Ref)
      pmIL.Emit(OpCodes.Ldloc, tempObjArrLB)
      pmIL.EmitCall(OpCodes.Call, writeLineMI, Nothing)
      
      pmIL.Emit(OpCodes.Ret)
      
      Console.WriteLine("PointMain (entry point) built.")
      
      pointType = myTypeBldr.CreateType()
      
      Console.WriteLine("Type completed.")
      
      myAsmBldr.SetEntryPoint(pointMainBldr)
      
      myAsmBldr.Save(asmFileName)
      
      Console.WriteLine("Assembly saved as '{0}'.", asmFileName)
      Console.WriteLine("Type '{0}' at the prompt to run your new " + "dynamically generated dot product calculator.", asmFileName)
      
      ' After execution, this program will have generated and written to disk,
      ' in the directory you executed it from, a program named 
      ' <name_you_entered_here>.exe. You can run it by typing
      ' the name you gave it during execution, in the same directory where
      ' you executed this program.

      Return pointType

   End Function 'BuildDynAssembly
    
   
   Public Shared Sub Main()
      
      Dim myType As Type = BuildDynAssembly()
      Console.WriteLine("---")
      
      ' Let's invoke the type 'Point' created in our dynamic assembly. 
      Dim ptInstance As Object = Activator.CreateInstance(myType, New Object(1) {0, 0})
      
      myType.InvokeMember("PointMain", BindingFlags.InvokeMethod, _
              Nothing, ptInstance, New Object() {})

   End Sub 'Main

End Class 'AssemblyBuilderDemo






[C#] 

using System;
using System.Text;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;

// The Point class is the class we will reflect on and copy into our
// dynamic assembly. The public static function PointMain() will be used
// as our entry point.
//
// We are constructing the type seen here dynamically, and will write it
// out into a .exe file for later execution from the command-line.
// --- 
// class Point {
//   
//   private int x;
//   private int y;
//
//   public Point(int ix, int iy) {
//
//       this.x = ix;
//        this.y = iy;
//
//   }
//
//   public int DotProduct (Point p) {
//   
//       return ((this.x * p.x) + (this.y * p.y));
//
//   }
//
//   public static void PointMain() {
//     
//     Console.Write("Enter the 'x' value for point 1: "); 
//     int x1 = Convert.ToInt32(Console.ReadLine());
//     
//     Console.Write("Enter the 'y' value for point 1: ");
//     int y1 = Convert.ToInt32(Console.ReadLine());
//
//     Console.Write("Enter the 'x' value for point 2: "); 
//     int x2 = Convert.ToInt32(Console.ReadLine());
//     
//     Console.Write("Enter the 'y' value for point 2: ");
//     int y2 = Convert.ToInt32(Console.ReadLine());
//
//     Point p1 = new Point(x1, y1);
//     Point p2 = new Point(x2, y2);
//
//     Console.WriteLine("({0}, {1}) . ({2}, {3}) = {4}.",
//               x1, y1, x2, y2, p1.DotProduct(p2));
//   
//   }
//
// }
// ---

class AssemblyBuilderDemo {

   public static Type BuildDynAssembly() {

        Type pointType = null;

        AppDomain currentDom = Thread.GetDomain();

    Console.Write("Please enter a name for your new assembly: ");
    StringBuilder asmFileNameBldr = new StringBuilder();
        asmFileNameBldr.Append(Console.ReadLine());
    asmFileNameBldr.Append(".exe");
    string asmFileName = asmFileNameBldr.ToString();    

        AssemblyName myAsmName = new AssemblyName();
    myAsmName.Name = "MyDynamicAssembly";

        AssemblyBuilder myAsmBldr = currentDom.DefineDynamicAssembly(
                           myAsmName,
                           AssemblyBuilderAccess.RunAndSave);

        // We've created a dynamic assembly space - now, we need to create a module
        // within it to reflect the type Point into.

    ModuleBuilder myModuleBldr = myAsmBldr.DefineDynamicModule(asmFileName,
                                       asmFileName);
      
    TypeBuilder myTypeBldr =  myModuleBldr.DefineType("Point");
    
        FieldBuilder xField = myTypeBldr.DefineField("x", typeof(int),
                                                     FieldAttributes.Private);
        FieldBuilder yField = myTypeBldr.DefineField("y", typeof(int), 
                                                     FieldAttributes.Private); 

        // Build the constructor.

        Type objType = Type.GetType("System.Object"); 
        ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);

        Type[] ctorParams = new Type[] {typeof(int), typeof(int)};
        ConstructorBuilder pointCtor = myTypeBldr.DefineConstructor(
                                   MethodAttributes.Public,
                                  CallingConventions.Standard,
                                  ctorParams);
        ILGenerator ctorIL = pointCtor.GetILGenerator();
        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 the DotProduct method.

        Console.WriteLine("Constructor built.");

    MethodBuilder pointDPBldr = myTypeBldr.DefineMethod("DotProduct",
                                MethodAttributes.Public,
                                typeof(int),
                                new Type[] {myTypeBldr});
                               
    ILGenerator dpIL = pointDPBldr.GetILGenerator();
    dpIL.Emit(OpCodes.Ldarg_0);
    dpIL.Emit(OpCodes.Ldfld, xField);
    dpIL.Emit(OpCodes.Ldarg_1);
    dpIL.Emit(OpCodes.Ldfld, xField);
    dpIL.Emit(OpCodes.Mul_Ovf_Un);
    dpIL.Emit(OpCodes.Ldarg_0);
    dpIL.Emit(OpCodes.Ldfld, yField);
    dpIL.Emit(OpCodes.Ldarg_1);
    dpIL.Emit(OpCodes.Ldfld, yField);
    dpIL.Emit(OpCodes.Mul_Ovf_Un);
    dpIL.Emit(OpCodes.Add_Ovf_Un);
    dpIL.Emit(OpCodes.Ret);

      // Build the PointMain method.

        Console.WriteLine("DotProduct built.");

    MethodBuilder pointMainBldr = myTypeBldr.DefineMethod("PointMain",
                                MethodAttributes.Public |
                                MethodAttributes.Static,
                                typeof(void),
                                null);
        pointMainBldr.InitLocals = true;
    ILGenerator pmIL = pointMainBldr.GetILGenerator();

    // We have four methods that we wish to call, and must represent as
    // MethodInfo tokens:
    // - void Console.WriteLine(string)
    // - string Console.ReadLine()
    // - int Convert.Int32(string)
    // - void Console.WriteLine(string, object[])

    MethodInfo writeMI = typeof(Console).GetMethod(
                         "Write",
                         new Type[] {typeof(string)});
    MethodInfo readLineMI = typeof(Console).GetMethod(
                            "ReadLine",
                            new Type[0]);
    MethodInfo convertInt32MI = typeof(Convert).GetMethod(
                            "ToInt32",
                                new Type[] {typeof(string)});
    Type[] wlParams = new Type[] {typeof(string), typeof(object[])};
    MethodInfo writeLineMI = typeof(Console).GetMethod(
                         "WriteLine",
                         wlParams);

    // Although we could just refer to the local variables by
    // index (short ints for Ldloc/Stloc, bytes for LdLoc_S/Stloc_S),
    // this time, we'll use LocalBuilders for clarity and to
    // demonstrate their usage and syntax.

    LocalBuilder x1LB = pmIL.DeclareLocal(typeof(int));                
    LocalBuilder y1LB = pmIL.DeclareLocal(typeof(int));                
    LocalBuilder x2LB = pmIL.DeclareLocal(typeof(int));                
    LocalBuilder y2LB = pmIL.DeclareLocal(typeof(int));                
    LocalBuilder point1LB = pmIL.DeclareLocal(myTypeBldr);                
    LocalBuilder point2LB = pmIL.DeclareLocal(myTypeBldr);                
    LocalBuilder tempObjArrLB = pmIL.DeclareLocal(typeof(object[]));                

    pmIL.Emit(OpCodes.Ldstr, "Enter the 'x' value for point 1: ");    
    pmIL.EmitCall(OpCodes.Call, writeMI, null);
    pmIL.EmitCall(OpCodes.Call, readLineMI, null);
    pmIL.EmitCall(OpCodes.Call, convertInt32MI, null);
    pmIL.Emit(OpCodes.Stloc, x1LB);

    pmIL.Emit(OpCodes.Ldstr, "Enter the 'y' value for point 1: ");    
    pmIL.EmitCall(OpCodes.Call, writeMI, null);
    pmIL.EmitCall(OpCodes.Call, readLineMI, null);
    pmIL.EmitCall(OpCodes.Call, convertInt32MI, null);
    pmIL.Emit(OpCodes.Stloc, y1LB);

    pmIL.Emit(OpCodes.Ldstr, "Enter the 'x' value for point 2: ");    
    pmIL.EmitCall(OpCodes.Call, writeMI, null);
    pmIL.EmitCall(OpCodes.Call, readLineMI, null);
    pmIL.EmitCall(OpCodes.Call, convertInt32MI, null);
    pmIL.Emit(OpCodes.Stloc, x2LB);

    pmIL.Emit(OpCodes.Ldstr, "Enter the 'y' value for point 2: ");    
    pmIL.EmitCall(OpCodes.Call, writeMI, null);
    pmIL.EmitCall(OpCodes.Call, readLineMI, null);
    pmIL.EmitCall(OpCodes.Call, convertInt32MI, null);
    pmIL.Emit(OpCodes.Stloc, y2LB);

    pmIL.Emit(OpCodes.Ldloc, x1LB);
    pmIL.Emit(OpCodes.Ldloc, y1LB);
    pmIL.Emit(OpCodes.Newobj, pointCtor);
    pmIL.Emit(OpCodes.Stloc, point1LB);

    pmIL.Emit(OpCodes.Ldloc, x2LB);
    pmIL.Emit(OpCodes.Ldloc, y2LB);
    pmIL.Emit(OpCodes.Newobj, pointCtor);
    pmIL.Emit(OpCodes.Stloc, point2LB);

    pmIL.Emit(OpCodes.Ldstr, "({0}, {1}) . ({2}, {3}) = {4}.");
    pmIL.Emit(OpCodes.Ldc_I4_5);
    pmIL.Emit(OpCodes.Newarr, typeof(Object));
    pmIL.Emit(OpCodes.Stloc, tempObjArrLB);

    pmIL.Emit(OpCodes.Ldloc, tempObjArrLB);
    pmIL.Emit(OpCodes.Ldc_I4_0);
    pmIL.Emit(OpCodes.Ldloc, x1LB);
    pmIL.Emit(OpCodes.Box, typeof(int));
    pmIL.Emit(OpCodes.Stelem_Ref);

    pmIL.Emit(OpCodes.Ldloc, tempObjArrLB);
    pmIL.Emit(OpCodes.Ldc_I4_1);
    pmIL.Emit(OpCodes.Ldloc, y1LB);
    pmIL.Emit(OpCodes.Box, typeof(int));
    pmIL.Emit(OpCodes.Stelem_Ref);

    pmIL.Emit(OpCodes.Ldloc, tempObjArrLB);
    pmIL.Emit(OpCodes.Ldc_I4_2);
    pmIL.Emit(OpCodes.Ldloc, x2LB);
    pmIL.Emit(OpCodes.Box, typeof(int));
    pmIL.Emit(OpCodes.Stelem_Ref);

    pmIL.Emit(OpCodes.Ldloc, tempObjArrLB);
    pmIL.Emit(OpCodes.Ldc_I4_3);
    pmIL.Emit(OpCodes.Ldloc, y2LB);
    pmIL.Emit(OpCodes.Box, typeof(int));
    pmIL.Emit(OpCodes.Stelem_Ref);

    pmIL.Emit(OpCodes.Ldloc, tempObjArrLB);
    pmIL.Emit(OpCodes.Ldc_I4_4);
    pmIL.Emit(OpCodes.Ldloc, point1LB);
    pmIL.Emit(OpCodes.Ldloc, point2LB);
    pmIL.EmitCall(OpCodes.Callvirt, pointDPBldr, null);

    pmIL.Emit(OpCodes.Box, typeof(int));
    pmIL.Emit(OpCodes.Stelem_Ref);
    pmIL.Emit(OpCodes.Ldloc, tempObjArrLB);
    pmIL.EmitCall(OpCodes.Call, writeLineMI, null);

    pmIL.Emit(OpCodes.Ret);

        Console.WriteLine("PointMain (entry point) built.");

        pointType = myTypeBldr.CreateType();

        Console.WriteLine("Type completed.");

    myAsmBldr.SetEntryPoint(pointMainBldr);

        myAsmBldr.Save(asmFileName);

        Console.WriteLine("Assembly saved as '{0}'.", asmFileName);
        Console.WriteLine("Type '{0}' at the prompt to run your new " +
                  "dynamically generated dot product calculator.",
               asmFileName);

    // After execution, this program will have generated and written to disk,
        // in the directory you executed it from, a program named 
    // <name_you_entered_here>.exe. You can run it by typing
    // the name you gave it during execution, in the same directory where
    // you executed this program.

    return pointType;
   
   }

   public static void Main() {

     Type myType = BuildDynAssembly(); 
     Console.WriteLine("---");

     // Let's invoke the type 'Point' created in our dynamic assembly. 
   
     object ptInstance = Activator.CreateInstance(myType, new object[] {0,0}); 
                          
     myType.InvokeMember("PointMain",
              BindingFlags.InvokeMethod,
              null,
              ptInstance,
              new object[0]); 

            
   }
}




[C++] 
#using <mscorlib.dll>

using namespace System;
using namespace System::Text;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

// The Point class is the class we will reflect on and copy into our
// dynamic assembly. The public static function PointMain() will be used
// as our entry point.
//
// We are constructing the type seen here dynamically, and will write it
// out into a .exe file for later execution from the command-line.
// ---
// __gc class Point {
// 
// private:
//    int  x;
//    int  y;
// 
// public:
//    Point(int ix, int iy) {
// 
//       this->x = ix;
//       this->y = iy;
// 
//    }
// 
//    int DotProduct (Point* p) {
// 
//       return ((this->x * p->x) + (this->y * p->y));
// 
//   }
// 
//    static void PointMain() {
// 
//       Console::Write(S"Enter the 'x' value for point 1: ");
//       int x1 = Convert::ToInt32(Console::ReadLine());
// 
//       Console::Write(S"Enter the 'y' value for point 1: ");
//       int y1 = Convert::ToInt32(Console::ReadLine());
// 
//       Console::Write(S"Enter the 'x' value for point 2: ");
//       int x2 = Convert::ToInt32(Console::ReadLine());
// 
//       Console::Write(S"Enter the 'y' value for point 2: ");
//       int y2 = Convert::ToInt32(Console::ReadLine());
// 
//       Point* p1 = new Point(x1, y1);
//       Point* p2 = new Point(x2, y2);
// 
//       Console::WriteLine(S"( {0}, {1}) . ( {2}, {3}) = {4}.",
//          __box(x1), __box(y1), __box(x2), __box(y2), p1->DotProduct(p2));
// 
//    }
// 
// };
// ---

Type* BuildDynAssembly() {

   Type* pointType = 0;

   AppDomain*  currentDom = Thread::GetDomain();

   Console::Write(S"Please enter a name for your new assembly: ");
   StringBuilder* asmFileNameBldr = new StringBuilder();
   asmFileNameBldr->Append(Console::ReadLine());
   asmFileNameBldr->Append(S".exe");
   String* asmFileName = asmFileNameBldr->ToString();

   AssemblyName* myAsmName = new AssemblyName();
   myAsmName->Name = S"MyDynamicAssembly";

   AssemblyBuilder*  myAsmBldr = currentDom->DefineDynamicAssembly(myAsmName,
      AssemblyBuilderAccess::RunAndSave);

   // We've created a dynamic assembly space - now, we need to create a module
   // within it to reflect the type Point into.

   ModuleBuilder*  myModuleBldr = myAsmBldr->DefineDynamicModule(asmFileName,
      asmFileName);

   TypeBuilder*  myTypeBldr =  myModuleBldr->DefineType(S"Point");

   FieldBuilder*  xField = myTypeBldr->DefineField(S"x", __typeof(int),
      FieldAttributes::Private);
   FieldBuilder*  yField = myTypeBldr->DefineField(S"y", __typeof(int),
      FieldAttributes::Private);

   // Build the constructor.

   Type*  objType = Type::GetType(S"System.Object");
   ConstructorInfo*  objCtor = objType->GetConstructor(new Type*[0]);

   Type* temp4 [] = {__typeof(int), __typeof(int)};
   Type* ctorParams[] = temp4;
   ConstructorBuilder*  pointCtor = myTypeBldr->DefineConstructor(MethodAttributes::Public,
      CallingConventions::Standard,
      ctorParams);
   ILGenerator*  ctorIL = pointCtor->GetILGenerator();
   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 the DotProduct method.

   Console::WriteLine(S"Constructor built.");

   Type* temp0 [] = {myTypeBldr};
   MethodBuilder*  pointDPBldr = myTypeBldr->DefineMethod(S"DotProduct",
      MethodAttributes::Public,
      __typeof(int),
      temp0);

   ILGenerator*  dpIL = pointDPBldr->GetILGenerator();
   dpIL->Emit(OpCodes::Ldarg_0);
   dpIL->Emit(OpCodes::Ldfld, xField);
   dpIL->Emit(OpCodes::Ldarg_1);
   dpIL->Emit(OpCodes::Ldfld, xField);
   dpIL->Emit(OpCodes::Mul_Ovf_Un);
   dpIL->Emit(OpCodes::Ldarg_0);
   dpIL->Emit(OpCodes::Ldfld, yField);
   dpIL->Emit(OpCodes::Ldarg_1);
   dpIL->Emit(OpCodes::Ldfld, yField);
   dpIL->Emit(OpCodes::Mul_Ovf_Un);
   dpIL->Emit(OpCodes::Add_Ovf_Un);
   dpIL->Emit(OpCodes::Ret);

   // Build the PointMain method.

   Console::WriteLine(S"DotProduct built.");

   MethodBuilder*  pointMainBldr = myTypeBldr->DefineMethod(
      S"PointMain",
      static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::Static),
      __typeof(void),
      0);
   pointMainBldr->InitLocals = true;
   ILGenerator*  pmIL = pointMainBldr->GetILGenerator();

   // We have four methods that we wish to call, and must represent as
   // MethodInfo tokens:
   // - void Console::WriteLine(String*)
   // - String* Console::ReadLine()
   // - int Convert::Int32(String*)
   // - void Console::WriteLine(String*, Object*[])


   Type* temp1 [] = {__typeof(String)};
   MethodInfo*  writeMI = __typeof(Console)->GetMethod(S"Write", temp1);
   MethodInfo*  readLineMI = __typeof(Console)->GetMethod(S"ReadLine", new Type*[0]);
   Type* temp2 [] = {__typeof(String)};
   MethodInfo*  convertInt32MI = __typeof(Convert)->GetMethod(S"ToInt32", temp2);
   Type* temp5 [] = {__typeof(String), __typeof(Object*[])};
   Type* wlParams[] = temp5;
   MethodInfo*  writeLineMI = __typeof(Console)->GetMethod(S"WriteLine", wlParams);

   // Although we could just refer to the local variables by
   // index (short ints for Ldloc/Stloc, bytes for LdLoc_S/Stloc_S),
   // this time, we'll use LocalBuilders for clarity and to
   // demonstrate their usage and syntax.

   LocalBuilder*  x1LB = pmIL->DeclareLocal(__typeof(int));
   LocalBuilder*  y1LB = pmIL->DeclareLocal(__typeof(int));
   LocalBuilder*  x2LB = pmIL->DeclareLocal(__typeof(int));
   LocalBuilder*  y2LB = pmIL->DeclareLocal(__typeof(int));
   LocalBuilder*  point1LB = pmIL->DeclareLocal(myTypeBldr);
   LocalBuilder*  point2LB = pmIL->DeclareLocal(myTypeBldr);
   LocalBuilder*  tempObjArrLB = pmIL->DeclareLocal(__typeof(Object*[]));

   pmIL->Emit(OpCodes::Ldstr, S"Enter the 'x' value for point 1: ");
   pmIL->EmitCall(OpCodes::Call, writeMI, 0);
   pmIL->EmitCall(OpCodes::Call, readLineMI, 0);
   pmIL->EmitCall(OpCodes::Call, convertInt32MI, 0);
   pmIL->Emit(OpCodes::Stloc, x1LB);

   pmIL->Emit(OpCodes::Ldstr, S"Enter the 'y' value for point 1: ");
   pmIL->EmitCall(OpCodes::Call, writeMI, 0);
   pmIL->EmitCall(OpCodes::Call, readLineMI, 0);
   pmIL->EmitCall(OpCodes::Call, convertInt32MI, 0);
   pmIL->Emit(OpCodes::Stloc, y1LB);

   pmIL->Emit(OpCodes::Ldstr, S"Enter the 'x' value for point 2: ");
   pmIL->EmitCall(OpCodes::Call, writeMI, 0);
   pmIL->EmitCall(OpCodes::Call, readLineMI, 0);
   pmIL->EmitCall(OpCodes::Call, convertInt32MI, 0);
   pmIL->Emit(OpCodes::Stloc, x2LB);

   pmIL->Emit(OpCodes::Ldstr, S"Enter the 'y' value for point 2: ");
   pmIL->EmitCall(OpCodes::Call, writeMI, 0);
   pmIL->EmitCall(OpCodes::Call, readLineMI, 0);
   pmIL->EmitCall(OpCodes::Call, convertInt32MI, 0);
   pmIL->Emit(OpCodes::Stloc, y2LB);

   pmIL->Emit(OpCodes::Ldloc, x1LB);
   pmIL->Emit(OpCodes::Ldloc, y1LB);
   pmIL->Emit(OpCodes::Newobj, pointCtor);
   pmIL->Emit(OpCodes::Stloc, point1LB);

   pmIL->Emit(OpCodes::Ldloc, x2LB);
   pmIL->Emit(OpCodes::Ldloc, y2LB);
   pmIL->Emit(OpCodes::Newobj, pointCtor);
   pmIL->Emit(OpCodes::Stloc, point2LB);

   pmIL->Emit(OpCodes::Ldstr, S"( {0}, {1}) . ( {2}, {3}) = {4}.");
   pmIL->Emit(OpCodes::Ldc_I4_5);
   pmIL->Emit(OpCodes::Newarr, __typeof(Object));
   pmIL->Emit(OpCodes::Stloc, tempObjArrLB);

   pmIL->Emit(OpCodes::Ldloc, tempObjArrLB);
   pmIL->Emit(OpCodes::Ldc_I4_0);
   pmIL->Emit(OpCodes::Ldloc, x1LB);
   pmIL->Emit(OpCodes::Box, __typeof(int));
   pmIL->Emit(OpCodes::Stelem_Ref);

   pmIL->Emit(OpCodes::Ldloc, tempObjArrLB);
   pmIL->Emit(OpCodes::Ldc_I4_1);
   pmIL->Emit(OpCodes::Ldloc, y1LB);
   pmIL->Emit(OpCodes::Box, __typeof(int));
   pmIL->Emit(OpCodes::Stelem_Ref);

   pmIL->Emit(OpCodes::Ldloc, tempObjArrLB);
   pmIL->Emit(OpCodes::Ldc_I4_2);
   pmIL->Emit(OpCodes::Ldloc, x2LB);
   pmIL->Emit(OpCodes::Box, __typeof(int));
   pmIL->Emit(OpCodes::Stelem_Ref);

   pmIL->Emit(OpCodes::Ldloc, tempObjArrLB);
   pmIL->Emit(OpCodes::Ldc_I4_3);
   pmIL->Emit(OpCodes::Ldloc, y2LB);
   pmIL->Emit(OpCodes::Box, __typeof(int));
   pmIL->Emit(OpCodes::Stelem_Ref);

   pmIL->Emit(OpCodes::Ldloc, tempObjArrLB);
   pmIL->Emit(OpCodes::Ldc_I4_4);
   pmIL->Emit(OpCodes::Ldloc, point1LB);
   pmIL->Emit(OpCodes::Ldloc, point2LB);
   pmIL->EmitCall(OpCodes::Callvirt, pointDPBldr, 0);

   pmIL->Emit(OpCodes::Box, __typeof(int));
   pmIL->Emit(OpCodes::Stelem_Ref);
   pmIL->Emit(OpCodes::Ldloc, tempObjArrLB);
   pmIL->EmitCall(OpCodes::Call, writeLineMI, 0);

   pmIL->Emit(OpCodes::Ret);

   Console::WriteLine(S"PointMain (entry point) built.");

   pointType = myTypeBldr->CreateType();

   Console::WriteLine(S"Type completed.");

   myAsmBldr->SetEntryPoint(pointMainBldr);

   myAsmBldr->Save(asmFileName);

   Console::WriteLine(S"Assembly saved as ' {0}'.", asmFileName);
   Console::WriteLine(S"Type ' {0}' at the prompt to run your new dynamically generated dot product calculator.",
      asmFileName);

   // After execution, this program will have generated and written to disk,
   // in the directory you executed it from, a program named
   // <name_you_entered_here>.exe. You can run it by typing
   // the name you gave it during execution, in the same directory where
   // you executed this program.

   return pointType;
}

int main() {

   Type*  myType = BuildDynAssembly();
   Console::WriteLine(S"---");

   // Let's invoke the type 'Point' created in our dynamic assembly.

   Object* temp3 [] = {0, 0};
   Object* ptInstance = Activator::CreateInstance(myType, temp3);

   myType->InvokeMember(S"PointMain",
      BindingFlags::InvokeMethod,
      0,
      ptInstance,
      new Object*[0]);
}

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family

See Also

ILGenerator Class | ILGenerator Members | System.Reflection.Emit Namespace

Did you find this helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft. All rights reserved.