Emit技术使用实例及应用思路

System.Reflection.Emit提供了动态创建类并生成程序集的功能。 适用于.NET Framework 2.0及其以后的版本。

动态生成类在对于O/R Mapping来说有很大的作用，在实际应用中用到的一些场景，比如支持用户自定义字段，自定义公式的解析、动态插件等等。

下面就详细介绍一下Emit的实际应用:

 

Emit动态创建类型

目标：创建类型Employee,两个简单属性：Name（姓名）,BirthDate（生日） ，一个方法void PropertyChanged(string propertyName)

其中Name必填，预设值“新同事”，String类型；BirthDate是日期类型

 

准备工作：定义类型EntityDictionary和DynamicField，用于动态产生实体类型。

 

public class EntityDictionary {
        private string _name;
        /// <summary>
        /// 实体名称
        /// </summary>
        public string Name {
            get { return _name; }
            set { _name = value; }
        }

        private string _caption;
        /// <summary>
        /// 显示值
        /// </summary>
        public string Caption {
            get { return _caption; }
            set { _caption = value; }
        }

        private List<string> _interfaceList;
        /// <summary>
        /// 接口列表
        /// </summary>
        public List<string> InterfaceList {
            get { return _interfaceList; }
            set { _interfaceList = value; }
        }

        private List<DynamicField> _dynamicFieldList;
        /// <summary>
        /// 字段列表
        /// </summary>
        public List<DynamicField> DynamicFieldList {
            get { return _dynamicFieldList; }
            set { _dynamicFieldList = value; }
        }
    }

 

 

public class DynamicField {
        private string _name;
        /// <summary>
        /// 字段名称
        /// </summary>
        public string Name {
            get { return _name; }
            set { _name = value; }
        }

        private string _entityName;
        /// <summary>
        /// 实体名称
        /// </summary>
        public string EntityName {
            get { return _entityName; }
            set { _entityName = value; }
        }

        private string _type;
        /// <summary>
        /// 类型
        /// </summary>
        public string Type {
            get { return _type; }
            set { _type = value; }
        }

        private int _size;
        /// <summary>
        /// 长度
        /// </summary>
        public int Size {
            get { return _size; }
            set { _size = value; }
        }

        private byte _scale;
        /// <summary>
        /// 小数位数
        /// </summary>
        public byte Scale {
            get { return _scale; }
            set { _scale = value; }
        }

        private string _refType;
        /// <summary>
        /// 引用类型
        /// </summary>
        public string RefType {
            get { return _refType; }
            set { _refType = value; }
        }

        private string _control;
        /// <summary>
        /// 显示控件类型
        /// </summary>
        public string Control {
            get { return _control; }
            set { _control = value; }
        }

        private string _caption;
        /// <summary>
        /// 显示值
        /// </summary>
        public string Caption {
            get { return _caption; }
            set { _caption = value; }
        }

        private bool _isRequired;
        /// <summary>
        /// 是否必填
        /// </summary>
        public bool IsRequired {
            get { return _isRequired; }
            set { _isRequired = value; }
        }

        private string _defaultValue;
        /// <summary>
        /// 默认值
        /// </summary>
        public string DefaultValue {
            get { return _defaultValue; }
            set { _defaultValue = value; }
        }

        private string _externInfo;
        /// <summary>
        /// 扩展信息
        /// </summary>
        public string ExternInfo {
            get { return _externInfo; }
            set { _externInfo = value; }
        }

        private object _tempProperty;
        /// <summary>
        /// 保留栏位
        /// </summary>
        public object TempProperty {
            get { return _tempProperty; }
            set { _tempProperty = value; }
        }
    }

 

1.创建类

 

首先我们看下产生dll的代码：

public void Create() {
            AppDomain myDomain = Thread.GetDomain();
            AssemblyName myAsmName = new AssemblyName();
            myAsmName.Name = "TestDynamicAssembly";
            myAsmName.Version = new Version("1.0.0.0");            

         //创建一个永久程序集,设置为AssemblyBuilderAccess.RunAndSave。
              AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(myAsmName,
                                                            AssemblyBuilderAccess.RunAndSave);
            //设置版本号信息
            myAsmBuilder.DefineVersionInfoResource("Test", myAsmName.Version.ToString(), "TestCorp", "Copyright © TestCorp Limited 2014", "");
             //创建一个永久单模程序块。
            ModuleBuilder myModBuilder =
                myAsmBuilder.DefineDynamicModule(myAsmName.Name, myAsmName.Name + ".dll");

            //通常采用Xml读取方式给DynamicField的属性赋值，这里Demo采用简单的直接赋值方式
            List<DynamicField> listDynamicField = new List<DynamicField>();
            DynamicField df = new DynamicField();
            df = new DynamicField();
            df.Name = "Name";
            df.Caption = "姓名";
            df.Type = "System.String";
            df.IsRequired = true;//是否必填
            df.DefaultValue = "新同事";//预设值
            df.Size = 200;//字段长度
            listDynamicField.Add(df);

            df.Name = "BirthDate";
            df.Caption = "生日";
            df.Type = "System.DateTime";
            listDynamicField.Add(df);

            //通常采用Xml读取方式给EntityDictionary的属性赋值，这里Demo采用简单的直接赋值方式
            EntityDictionary ed = new EntityDictionary();
            ed.Name = "Employee";
            ed.Caption = "雇员信息";
            ed.DynamicFieldList = listDynamicField;

        //创建类型
            CreateEntity(myModBuilder, ed);

       //创建方法
          AddMethordToTypeBuilder(myModBuilder);
            //保存程序集。
            myAsmBuilder.Save(myAsmName.Name + ".dll");
        }

 

 

主要代码CreateEntity（创建类型）如下：

 

private void CreateEntity(ModuleBuilder myModBuilder, EntityDictionary ed) {
            //重写命名空间
            string typeName = string.Format("{0}.{1}", "TestDemo.DataEntity", ed.Name);
            //创建TypeBuilder。
            TypeBuilder myTypeBuilder = myModBuilder.DefineType(typeName,
                                                            TypeAttributes.Public);

            #region 类标记
            //序列化
            CustomAttributeBuilder customAttributeBuilder = new CustomAttributeBuilder(typeof(SerializableAttribute).GetConstructor(Type.EmptyTypes), new Type[] { });
            myTypeBuilder.SetCustomAttribute(customAttributeBuilder);

            //这是个相对复杂的类型标记 定义了类型的主键和别名，有兴趣可以研究一下
            //if (!string.IsNullOrEmpty(df.Alias)) {
            //    customAttributeBuilder = new CustomAttributeBuilder(typeof(DataEntityAttribute).GetConstructor(Type.EmptyTypes), new Type[] { }, new PropertyInfo[] { typeof(DataEntityAttribute).GetProperty("PrimaryKey"), typeof(DataEntityAttribute).GetProperty("Alias") }, new object[] { df.PrimaryKey, df.Alias });
            //} else {
            //    customAttributeBuilder = new CustomAttributeBuilder(typeof(DataEntityAttribute).GetConstructor(Type.EmptyTypes), new Type[] { }, new PropertyInfo[] { typeof(DataEntityAttribute).GetProperty("PrimaryKey") }, new object[] { df.PrimaryKey });
            //}
            //myTypeBuilder.SetCustomAttribute(customAttributeBuilder);
            #endregion

            #region 接口
            //对类型添加接口
            //if (df.InterfaceList != null && df.InterfaceList.Count > 0) {
            //    AddInterface(myTypeBuilder, df.InterfaceList);
            //}
            #endregion

            #region 常量和变量
            FieldBuilder fb = myTypeBuilder.DefineField("TYPEKEY", typeof(string), FieldAttributes.Public | FieldAttributes.FamANDAssem | FieldAttributes.Family | FieldAttributes.Static | FieldAttributes.Literal | FieldAttributes.HasDefault);
            fb.SetConstant(ed.Name);
            #endregion

            //添加属性到TypeBuilder。
            AddPropertyToTypeBuilder(myTypeBuilder, ed.DynamicFieldList);

            myTypeBuilder.CreateType();
        }

 

到这里，我们已经创建了dll的版本信息，类型的命名空间、类标记、常量等信息，此时如果排除添加属性的方法，已经可以编译成dll了，反编译的结果如下：

 

 

2.添加属性

属性是实体类型的重要组成部分

 

private void AddPropertyToTypeBuilder(TypeBuilder myTypeBuilder, List<DynamicField> dfList) {
            PropertyBuilder custNamePropBldr;
            MethodBuilder custNameGetPropMthdBldr;
            MethodBuilder custNameSetPropMthdBldr;
            MethodAttributes getSetAttr;
            ILGenerator custNameGetIL;
            ILGenerator custNameSetIL;

            // 属性Set和Get方法要一个专门的属性。这里设置为Public。
            getSetAttr =
                MethodAttributes.Public | MethodAttributes.SpecialName |
                    MethodAttributes.HideBySig;

            foreach (DynamicField df in dfList) {
                try {
                    string fieldPrivateName = "_" + df.Name.Substring(0, 1).ToLower() + df.Name.Substring(1);
                    //定义字段。
                    FieldBuilder customerNameBldr = myTypeBuilder.DefineField(fieldPrivateName,Type.GetType(df.Type),
                                                                              FieldAttributes.Private);
                    //定义属性。
                    custNamePropBldr = myTypeBuilder.DefineProperty(df.Name,
                                                                     System.Reflection.PropertyAttributes.RTSpecialName,
                                                                     Type.GetType(df.Type),
                                                                     null);

                    CustomAttributeBuilder customAttributeBuilder = new CustomAttributeBuilder(typeof(DescriptionAttribute).GetConstructor(new Type[] { typeof(string) }), new object[] { df.Caption });
                    custNamePropBldr.SetCustomAttribute(customAttributeBuilder);//字段描述

                    #region 增加必填字段属性和特殊默认值属性
                    if (df.IsRequired) {
                        customAttributeBuilder = new CustomAttributeBuilder(typeof(System.ComponentModel.DataAnnotations.RequiredAttribute).GetConstructor(Type.EmptyTypes), new object[] { });
                        custNamePropBldr.SetCustomAttribute(customAttributeBuilder);//是否必填
                    }
                    if (!string.IsNullOrEmpty(df.DefaultValue)) {
                        customAttributeBuilder = new CustomAttributeBuilder(typeof(DefaultValueAttribute).GetConstructor(new Type[] { typeof(string) }), new object[] { df.DefaultValue });
                        custNamePropBldr.SetCustomAttribute(customAttributeBuilder);//特殊默认值
                    }
                    #endregion

                    //定义Get方法。
                    custNameGetPropMthdBldr =
                        myTypeBuilder.DefineMethod("get_" + df.Name,
                                                   getSetAttr,
                                                   Type.GetType(df.Type),
                                                   Type.EmptyTypes);

                    custNameGetIL = custNameGetPropMthdBldr.GetILGenerator();
                    custNameGetIL.Emit(OpCodes.Ldarg_0);
                    custNameGetIL.Emit(OpCodes.Ldfld, customerNameBldr);
                    custNameGetIL.Emit(OpCodes.Ret);

                    //把创建的两个方法(Get,Set)加入到PropertyBuilder中。
                    custNamePropBldr.SetGetMethod(custNameGetPropMthdBldr);

                    //定义Set方法。
                    custNameSetPropMthdBldr =
                        myTypeBuilder.DefineMethod("set_" + df.Name,
                                                   getSetAttr,
                                                   null,
                                                   new Type[] { Type.GetType(df.Type) });

                    custNameSetIL = custNameSetPropMthdBldr.GetILGenerator();

                    custNameSetIL.Emit(OpCodes.Ldarg_0);
                    custNameSetIL.Emit(OpCodes.Ldarg_1);
                    custNameSetIL.Emit(OpCodes.Stfld, customerNameBldr);
                    custNameSetIL.Emit(OpCodes.Ret);
                    //把创建的两个方法(Get,Set)加入到PropertyBuilder中。
                    custNamePropBldr.SetSetMethod(custNameSetPropMthdBldr);
                } catch (Exception ex) {
                    throw new Exception("AddPropertyToTypeBuilder Error:" + ex.Message);
                }
            }
        }

 

再生成dll反编译，结果如下：

 

 

 

3.添加方法

 

在添加属性的代码中，有一部分是IL语言的反射，估计是Emit中让人觉得难以理解的代码，添加方法的时候就更需要深入理解IL语言的转换，从而实现对方法的动态添加。

例如方法void PropertyChanged(string propertyName)，先另外用C#写好代码：

 

    public void PropertyChanged(string propertyName) {
            if (propertyName != null) {//判断语句
                Console.WriteLine(propertyName + " Changed!");
            }
        }

 

然后生成dll，利用反编译工具得到这段代码的IL语言

 

 

了解一些IL语言的基本指令，就会很容易得到这段代码：

 

private void AddMethordToTypeBuilder(TypeBuilder myTypeBuilder) {
            MethodBuilder methodBuilder = myTypeBuilder.DefineMethod("PropertyChanged", MethodAttributes.Public, null, new Type[] { typeof(string) });
            ILGenerator il = methodBuilder.GetILGenerator();
            Label lb_001 = il.DefineLabel();//lable
            il.Emit(OpCodes.Nop);
            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Ldnull);
            il.Emit(OpCodes.Ceq);
            il.Emit(OpCodes.Stloc_0);
            il.Emit(OpCodes.Ldloc_0);
            il.Emit(OpCodes.Brtrue_S, lb_001);

            il.Emit(OpCodes.Nop);
            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Ldstr, " Changed!");
            il.Emit(OpCodes.Call, typeof(string).GetMethod("Concat", new Type[] { typeof(string), typeof(string) }));

            il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("WriteLine", new Type[] { typeof(string)}));
            il.Emit(OpCodes.Nop);
            il.MarkLabel(lb_001);
            il.Emit(OpCodes.Nop);
            il.Emit(OpCodes.Ret);
        }

 

再生成dll，反编译看看结果：

 

 

 

这样，一个简单的类就产生了，有了类标记、字段、属性、方法。

但是，现实需求不仅如此，我们还有可能需要有继承、接口等，来完善我们的类型。

 

继承和接口添加

      //创建TypeBuilder。
            TypeBuilder myTypeBuilder = myModBuilder.DefineType(typeName,
                                                            TypeAttributes.Public);

          myTypeBuilder.SetParent(type);//继承

       myTypeBuilder.AddInterfaceImplementation(typeInterface);//接口

 

需要注意的是，添加接口必须要添加接口实现的方法或者属性，否则编译会失败。

 

Emit应用场景的开发思路

 

一开始提到的Emit应用场景，实现用户级自定义字段。

步骤1.新增用户自定义字段的工具，其实就是维护一份或多份Xml，记录基类实体的Key和新增的字段等信息。并提供按钮生成dll。

      上述Demo中的字段都是可以通过Xml来读取相关信息，包括类标记、属性、属性标记、基类、接口等，还可以在工具上新增字段对应的控件布局的编辑器，用于保存控件布局。

 

步骤2.在程序中通过反射引用生成的dll，并在注册实体和类型的关系字典时增加特殊判断。

     拿上面的Employee举例，首先我们的程序中需要继承EmployeeEx：Employee，在O\R Mapping中，

实体的增删改查通常是封装好的方法，例如Create("Employee") 后台会通过"Employee"找到类型Employee做实例化,

这就需要一开始对实体和实体的Key放到一个字典中，如"Employee"对应Employee,"Job"对应Job。如果我们在建立对应关系的字典时发现有Emit动态产生的dll，将相应的对应关系做修改，

如"Employee"对应EmployeeEx，那个在Create("Employee")的时候，后台会通过"Employee"找到类型EmployeeEx做实例化。这样的话不管有没有用户自定义列，代码都不用修改。

 

步骤3.在客户端界面自动生成维护控件并绑定，以便用户维护。

        客户端可以新增一个面板控件，用于动态加入控件和绑定字段，如果在步骤1中添加了自定义布局，还可以导入控件布局，再进行绑定。

 

这样，用户就可以不用改到代码就新增自己需要的字段。这对于一个标准产品来说，解决了不同客户的一些简单并且常用的客制需求。

 

一开始提到的Emit应用场景，实现自定义公式解析。

举例：用户可以自定义公式，改公式应用于不同员工会得到不同的值。公式内容如下：

公式名称：请假扣款
    返回类型：数字型
    公式内容：  if 请假次数==0
                return 0;
              else if 请假次数<10
                return 请假扣款系数*请假次数;    

           else        

             return 函数A（请假次数）;

 

步骤1.定义系统级参数if，else，return等，

步骤2.定义自定义函数，并提供固定解析方法。（如 decimal 函数A（int）、日期函数等）

步骤3.提供一系列参数，可动态产生。（如  请假次数） 动态编译类型类型请假次数，继承int

步骤4.（最难的一步）将公式解析成动态方法，里面的参数作为方法的变量，遇到函数则使用Emit中的Call。

步骤5.解析公式最后的结果，如员工A，程序运行到公式时，首先通过员工A得到参数的值，即请假扣款系数和请假次数，再把值传入动态方法，最终得到公式的值。

 

当然，具体实做会遇到很多细节上的困难，这里的步骤只是简单的介绍。

 

总结

面对形形色色的用户需求，我们需要做出一些灵活多变的功能，Emit技术为我们解决问题提供了思路。