高性能反射初体验3

动态生成

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading;

namespace Reflx_Method
{
    public class Class1
    {
        public Class1()
        { }
        /// <summary>
        /// 
        /// </summary>
        public void CreateDynamicType()
        {
            Type[] ctorParams = new Type[] {typeof(int),
                   typeof(int)};

            AppDomain myDomain = Thread.GetDomain();
            AssemblyName myAsmName = new AssemblyName();
            myAsmName.Name = "MyDynamicAssembly";

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

            ModuleBuilder pointModule = myAsmBuilder.DefineDynamicModule("PointModule",
                                         "Point.dll");

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

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


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

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


            // First, you build the constructor. 首先，你建立的构造
            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);

            //  Now, you'll build a method to output some information on the
            // inside your dynamic class. This method will have the following
            // definition in C#:
            //  public void WritePoint()
            //现在，你将建立一个方法来输出一些信息
            //内部动态类。这种方法将有以下
            //在C＃中定义：
            //公共的无效WritePoint （ ）

            MethodBuilder writeStrMthd = pointTypeBld.DefineMethod(
                                          "WritePoint",
                                  MethodAttributes.Public,
                                                  typeof(void),
                                                  null);


            ILGenerator writeStrIL = writeStrMthd.GetILGenerator();

            // The below ILGenerator created demonstrates a few ways to create
            // string output through STDIN. 
            // ILGenerator.EmitWriteLine(string) will generate a ldstr and a 
            // call to WriteLine for you.
            //创建下面的ILGenerator演示了几种方法来创建
            //字符串通过标准输入输出。
            // ILGenerator.EmitWriteLine的（字符串）将生成一个ldstr与一个
            //调用你的WriteLine 。

            writeStrIL.EmitWriteLine("这个当前实例的值是：");

            // Here, you will do the hard work yourself. First, you need to create
            // the string we will be passing and obtain the correct WriteLine overload
            // for said string. In the below case, you are substituting in two values,
            // so the chosen overload is Console.WriteLine(string, object, object).
            //这里，你会做自己的辛勤工作。首先，你需要创建
            //字符串，我们将通过并获得正确的WriteLine超载
            //表示字符串。在下面的情况下，你是在两个值代

            String inStr = "({0}, {1})";
            Type[] wlParams = new Type[] {typeof(string),
                     typeof(object),
                     typeof(object)};

            // We need the MethodInfo to pass into EmitCall later.
            //我们的MethodInfo ，到EmitCall通过后的。

            MethodInfo writeLineMI = typeof(Console).GetMethod(
                                 "WriteLine",
                             wlParams);

            // Push the string with the substitutions onto the stack.
            // This is the first argument for WriteLine - the string one. 
            //推到堆栈上替换的字符串。
            //这是第一个参数的WriteLine - 一个字符串。

            writeStrIL.Emit(OpCodes.Ldstr, inStr);

            // Since the second argument is an object, and it corresponds to
            // to the substitution for the value of our integer field, you 
            // need to box that field to an object. First, push a reference
            // to the current instance, and then push the value stored in
            // field 'x'. We need the reference to the current instance (stored
            // in local argument index 0) so Ldfld can load from the correct
            // instance (this one).
            //由于第二个参数是一个对象，它对应于
            //我们的整数字段的值替代，你
            //需要框字段对象。首先，推动一个参考
            //当前实例，然后推值存储在
            //字段'X' 。我们需要对当前实例的引用（存储
            //本地参数索引0 ），因此Ldfld可以从正确的加载
            //实例（一） 。

            writeStrIL.Emit(OpCodes.Ldarg_0);
            writeStrIL.Emit(OpCodes.Ldfld, xField);

            // Now, we execute the box opcode, which pops the value of field 'x',
            // returning a reference to the integer value boxed as an object.
            //现在，我们执行操作码框，弹出领域的'X'的价值，
            //返回一个整型值作为一个对象盒装的参考。

            writeStrIL.Emit(OpCodes.Box, typeof(int));

            // Atop the stack, you'll find our string inStr, followed by a reference
            // to the boxed value of 'x'. Now, you need to likewise box field 'y'.
            //堆栈上面，你会发现我们的字符串INSTR ，其次是参考
            // 'x'的装箱值。现在，你需要同样框场'Y' 。

            writeStrIL.Emit(OpCodes.Ldarg_0);
            writeStrIL.Emit(OpCodes.Ldfld, yField);
            writeStrIL.Emit(OpCodes.Box, typeof(int));

            // Now, you have all of the arguments for your call to
            // Console.WriteLine(string, object, object) atop the stack:
            // the string InStr, a reference to the boxed value of 'x', and
            // a reference to the boxed value of 'y'.

            // Call Console.WriteLine(string, object, object) with EmitCall.
            //现在，你有你的电话所有的参数
            // Console.WriteLine （字符串，对象，对象）之上的堆栈：
            //字符串INSTR ， 'x'的装箱值的引用，
            //装箱的值'Y'的参考。

            //调用Console.WriteLine与EmitCall （字符串，对象，对象） 。

            writeStrIL.EmitCall(OpCodes.Call, writeLineMI, null);

            // Lastly, EmitWriteLine can also output the value of a field
            // using the overload EmitWriteLine(FieldInfo).
            //最后， EmitWriteLine也可以输出字段值
            //使用的超载EmitWriteLine （的FieldInfo ） 。

            writeStrIL.EmitWriteLine("The value of 'x' is:");
            writeStrIL.EmitWriteLine(xField);
            writeStrIL.EmitWriteLine("The value of 'y' is:");
            writeStrIL.EmitWriteLine(yField);

            // Since we return no value (void), the the ret opcode will not
            // return the top stack value.
            //由于我们没有返回值（无效） ， ret操作码不会
            //返回栈顶值。

            writeStrIL.Emit(OpCodes.Ret);
 

            Type type1 = pointTypeBld.CreateType();
            object[] ctorParams1 = new object[2];

            Console.Write("Enter a integer value for X: ");
            string myX = Console.ReadLine();
            Console.Write("Enter a integer value for Y: ");
            string myY = Console.ReadLine();

            Console.WriteLine("---");

            ctorParams1[0] = Convert.ToInt32(myX);
            ctorParams1[1] = Convert.ToInt32(myY);

            Type ptType = type1;

            object ptInstance = Activator.CreateInstance(ptType, ctorParams1);
            ptType.InvokeMember("WritePoint",
                    BindingFlags.InvokeMethod,
                    null,
                    ptInstance,
                    new object[0]);

            myAsmBuilder.Save("Point.dll");
            //return type1;

        }
    }
}

调用

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Reflection.Emit;

namespace Reflx_Method
{
   
    class Program
    {
       
        static void Main(string[] args)
        {
            new Class1().CreateDynamicType();
        }
         
    } 

}
 

等价于

public class Point1
{
    // Fields
    public int x;
    public int y;

    // Methods
    public Point1(int num1, int num2)
    {
        this.x = num1;
        this.y = num2;
    }  
    public void WritePoint()
    {
        Console.WriteLine("这个当前实例的值是：");
        Console.WriteLine("({0}, {1})", this.x, this.y);
        Console.WriteLine("The value of 'x' is:");
        Console.Out.WriteLine(this.x);
        Console.WriteLine("The value of 'y' is:");
        Console.Out.WriteLine(this.y);
    }
}

 

Demo