编程实现动态生成程序技术

 动态程序集生成技术 也就是说序在运行时动态生成IL代码并被编译执行

ms-help://MS.VSCC.2003/MS.MSDNQTR.2003FEB.2052/cpguide/html/cpconemittingdynamicassemblies.htm

动态程序集 System.Reflection.Emit 命名空间中的一组托管类型，它们允许编译器或工具在运行时发出元数据和 Microsoft 中间语言 (MSIL)，或者也可以允许它们在磁盘上生成可移植可执行 (PE) 文件。脚本引擎和编译器是此命名空间的主要用户。在本节中，由 System.Reflection.Emit 命名空间提供的功能称为反射发出。

反射发出提供下列服务：

• 在运行时定义程序集，然后运行这些程序集并/或将它们保存到磁盘。
• 在运行时定义新程序集中的模块，然后运行这些模块并/或将它们保存到磁盘。
• 在运行时定义类型，创建这些类型的实例，并调用这些类型的方法。
• 为定义的模块定义可由调试器和代码分析器这样的工具使用的符号信息。

如果你想了解更多内容：见System.Reflection.Emit下面

 改例子来自msdn，有兴趣大家运行下

下面是一个运行的代码示例： 见文件夹TypeResolve

 

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

//  手动写的类和程序  与动态的程序集相同的功能

// --- 
// 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);

        // 
        // 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); 
        //定义构造函数
        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);

        // 定义 DotProduct 方法

        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);

        // 定义 PointMain()方法

        Console.WriteLine("DotProduct built.");

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

        // 我们调用四个方法
        // 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[]));                
        
        //完成
        //     Console.Write("Enter the 'x' value for point 1: "); 
        //     int x1 = Convert.ToInt32(Console.ReadLine());
        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);


        //完成
        //     Console.Write("Enter the 'y' value for point 1: ");
        //     int y1 = Convert.ToInt32(Console.ReadLine());
        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);

        //     Console.Write("Enter the 'x' value for point 2: "); 
        //     int x2 = Convert.ToInt32(Console.ReadLine());
        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);


        //     Console.Write("Enter the 'y' value for point 2: ");
        //     int y2 = Convert.ToInt32(Console.ReadLine());
        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);

        //   Point p1 = new Point(x1, y1);
        pmIL.Emit(OpCodes.Ldloc, x1LB);
        pmIL.Emit(OpCodes.Ldloc, y1LB);
        pmIL.Emit(OpCodes.Newobj, pointCtor);
        pmIL.Emit(OpCodes.Stloc, point1LB);

        //Point p2 = new Point(x2, y2);
        pmIL.Emit(OpCodes.Ldloc, x2LB);
        pmIL.Emit(OpCodes.Ldloc, y2LB);
        pmIL.Emit(OpCodes.Newobj, pointCtor);
        pmIL.Emit(OpCodes.Stloc, point2LB);

        完成计算#region  完成计算
        //     Console.WriteLine("({0}, {1}) . ({2}, {3}) = {4}.",
        //               x1, y1, x2, y2, p1.DotProduct(p2));
        //   
        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);

        #endregion

        //结束
        pmIL.Emit(OpCodes.Ret);

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

        pointType = myTypeBldr.CreateType();

        Console.WriteLine("Type baked.");

        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]); 

        Console.ReadLine();

            
    }
}

查看本文来源