使用Emit反射建立运行时实体模型

　　做这个功能目的是对旧项目代码分析管理，代码规划。

　　如果重头开发，统一一个框架小框架搞，人、时间到位都不是问题。但是旧应用系统优化，项目更新，就几个人开发加维护，接口层越多，bll层越来越厚，人来人往留下一堆代码，怎么管理呢？我现在方法是：看，仔细看，再仔细看，改，仔细改，再仔细改。一般出问题了，结合数据库，基本可以解决。如果重新搞，还得熟悉原来的代码，再搬进新的项目，费时费力。有没有一种方式最好不用写代码，做个配置界面，将业务SQL和逻辑用工作流的方式以字符串（JSon、描述对象模型（这玩意我自定义了一个对象来描述各类关系，下次讲））的形式先保存起来，形成一个运行时编程环境，配置完善后通过字符串生成自己喜欢的框架呢？找了好久没找到，就自己写个。

　　要解决不要写代码，那么所有层的Model(实体、DTO、其他业务模型)肯定要用运行时模型，传输统一用字符串，哪一层都能接受。这样一想，思路就有了。这里的所有模型只做三个事情：实例化、输入和输出。输入为object或者json，输出为。代码做了简单的封装。直接上代码：

动态生成帮助类：

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

namespace MagicModel
{
    public abstract  class EmitHelper
    {
      
        private static AssemblyName assmblyname;
        private static string DllName;
        private static AssemblyBuilder assemblybuilder;
        private static ModuleBuilder modulebuilder;
        private static TypeBuilder typebuilder;
        private static Type _dymaticType;

        public static Type DymaticType
        {
            get
            {
                return _dymaticType;
            }

            //set
            //{
            //    dymaticType = value;
            //}
        }

        public static void Create(string dllname)
        {
            DllName = dllname;
            assmblyname = new AssemblyName(DllName);
            ///2程序集生成器
            assemblybuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assmblyname, AssemblyBuilderAccess.RunAndSave);

            // For a single-module assembly, the module name is usually
            // the assembly name plus an extension.
            ////3动态创建模块
            modulebuilder = assemblybuilder.DefineDynamicModule(assmblyname.Name, assmblyname.Name + ".dll");
        }
        public static void CreateClass(string NsClassName)
        {
            typebuilder = modulebuilder.DefineType(NsClassName, TypeAttributes.Public);
        }
        public static void CreateMember(string MemberName, Type memberType)
        {
            FieldBuilder fbNumber = typebuilder.DefineField(
              "m_" + MemberName,
             memberType,
              FieldAttributes.Private);


            PropertyBuilder pbNumber = typebuilder.DefineProperty(
                MemberName,
                System.Reflection.PropertyAttributes.HasDefault,
                memberType,
                null);


            MethodAttributes getSetAttr = MethodAttributes.Public |
                MethodAttributes.SpecialName | MethodAttributes.HideBySig;


            MethodBuilder mbNumberGetAccessor = typebuilder.DefineMethod(
                "get_" + MemberName,
                getSetAttr,
                memberType,
                Type.EmptyTypes);

            ILGenerator numberGetIL = mbNumberGetAccessor.GetILGenerator();

            numberGetIL.Emit(OpCodes.Ldarg_0);
            numberGetIL.Emit(OpCodes.Ldfld, fbNumber);
            numberGetIL.Emit(OpCodes.Ret);

            // Define the "set" accessor method for Number, which has no return
            // type and takes one argument of type int (Int32).
            MethodBuilder mbNumberSetAccessor = typebuilder.DefineMethod(
                "set_" + MemberName,
                getSetAttr,
                null,
                new Type[] { memberType });

            ILGenerator numberSetIL = mbNumberSetAccessor.GetILGenerator();
            // Load the instance and then the numeric argument, then store the
            // argument in the field.
            numberSetIL.Emit(OpCodes.Ldarg_0);
            numberSetIL.Emit(OpCodes.Ldarg_1);
            numberSetIL.Emit(OpCodes.Stfld, fbNumber);
            numberSetIL.Emit(OpCodes.Ret);

            // Last, map the "get" and "set" accessor methods to the 
            // PropertyBuilder. The property is now complete. 
            pbNumber.SetGetMethod(mbNumberGetAccessor);
            pbNumber.SetSetMethod(mbNumberSetAccessor);
            ///最重要的是你最后要创建类型

        }
        public static Type SaveClass()
        {
            _dymaticType = typebuilder.CreateType();
            return DymaticType;
        }
        public static void Save()
        {
            assemblybuilder.Save(assmblyname.Name + ".dll");
        }
        ///// <summary>
        ///// 创建一个实体类并保存生成类型
        ///// </summary>
        ///// <param name="NsClassName"></param>
        ///// <param name="propertys"></param>
        //public void Execute(string NsClassName, Dictionary<string, Type> propertys)
        //{
          
        //    CreateClass(NsClassName);
        //    foreach (var item in propertys)
        //    {
        //        CreateMember(item.Key, item.Value);
        //    }
        //    SaveClass();
        //    Save();
        //}

        //public void Execute(List<M_DefineClass> _classes) {
        
        //    foreach (M_DefineClass _class in _classes)
        //    {
        //        CreateClass(_class.NsClassName);
        //        foreach (var prop in _class.Props)
        //        {
        //            CreateMember(prop.MemberName, prop.MemberType);
        //        }
        //        SaveClass();
        //    }
          
        //}

        //public void Test(string dllname, string NsClassName, string MemberName, Type memberType)
        //{
        //    //1设置程序集名称
        //    assmblyname = new AssemblyName(dllname);
        //    ///2程序集生成器
        //    assemblybuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assmblyname, AssemblyBuilderAccess.RunAndSave);
        //    ////3动态创建模块
        //    modulebuilder = assemblybuilder.DefineDynamicModule(assmblyname.Name, assmblyname.Name + ".dll");
        //    ///4.创建类
        //    typebuilder = modulebuilder.DefineType(NsClassName, TypeAttributes.Public);
        //    ///5.创建私有字段
        //    FieldBuilder fbNumber = typebuilder.DefineField(
        //     "m_" + MemberName,
        //     memberType,
        //     FieldAttributes.Private);

        //    ///6.创建共有属性
        //    PropertyBuilder pbNumber = typebuilder.DefineProperty(
        //        MemberName,
        //        System.Reflection.PropertyAttributes.HasDefault,
        //        memberType,
        //        null);


        //    MethodAttributes getSetAttr = MethodAttributes.Public |
        //        MethodAttributes.SpecialName | MethodAttributes.HideBySig;


        //    MethodBuilder mbNumberGetAccessor = typebuilder.DefineMethod(
        //        "get_" + MemberName,
        //        getSetAttr,
        //        memberType,
        //        Type.EmptyTypes);

        //    ILGenerator numberGetIL = mbNumberGetAccessor.GetILGenerator();

        //    numberGetIL.Emit(OpCodes.Ldarg_0);
        //    numberGetIL.Emit(OpCodes.Ldfld, fbNumber);
        //    numberGetIL.Emit(OpCodes.Ret);

        //    // Define the "set" accessor method for Number, which has no return
        //    // type and takes one argument of type int (Int32).
        //    MethodBuilder mbNumberSetAccessor = typebuilder.DefineMethod(
        //        "set_" + MemberName,
        //        getSetAttr,
        //        null,
        //        new Type[] { typeof(int) });

        //    ILGenerator numberSetIL = mbNumberSetAccessor.GetILGenerator();
        //    // Load the instance and then the numeric argument, then store the
        //    // argument in the field.
        //    numberSetIL.Emit(OpCodes.Ldarg_0);
        //    numberSetIL.Emit(OpCodes.Ldarg_1);
        //    numberSetIL.Emit(OpCodes.Stfld, fbNumber);
        //    numberSetIL.Emit(OpCodes.Ret);

        //    // Last, map the "get" and "set" accessor methods to the 
        //    // PropertyBuilder. The property is now complete. 
        //    pbNumber.SetGetMethod(mbNumberGetAccessor);
        //    pbNumber.SetSetMethod(mbNumberSetAccessor);

        //    ///最重要的是你最后要创建类型
        //    Type t = typebuilder.CreateType();
        //    assemblybuilder.Save(assmblyname.Name + ".dll");

        //}


    }
}

初始动态模型：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MagicModel.BLL
{
    public class DynamicInitBLL
    {
        static M_Base _m_base;

        /// <summary>
        /// 3.设置和获取，生成结果放入Base里
        /// </summary>
        public static M_Base M_Base
        {
            get
            {
                return _m_base;
            }

            set
            {
                _m_base = value;
            }
        }
        /// <summary>
        /// 初始化,实现步骤为三步
        /// </summary>
        /// <param name="m_base"></param>
        public DynamicInitBLL(M_Base m_base) {
            _m_base = m_base;
            EmitHelper.Create(_m_base._AssamblyName);
          
        }
        /// <summary>
        /// 1创建单个Class
        /// </summary>
        /// <param name="_class"></param>
        public void Exequte(M_DefineClass _class)
        {

                EmitHelper.CreateClass(_class.NsClassName);
                foreach (var prop in _class.Props)
                {
                EmitHelper.CreateMember(prop.MemberName, prop.MemberType);
                }
            _m_base.DymaticType.Add(new M_DymaticType() {TypeName=_class.NsClassName,DType= EmitHelper.SaveClass() });
        }
        /// <summary>
        /// 1创建多个Class
        /// </summary>
        /// <param name="_classes"></param>
        public void Exequte(List<M_DefineClass> _classes) {
            foreach (var item in _classes)
            {
                Exequte(item);
            }
        }
        /// <summary>
        /// 2保存
        /// </summary>
        public void SaveAssembly() {
            EmitHelper.Save();
        }


    }
}

模型赋值：

using MagicModel;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;

namespace MagicModel.BLL
{
    public class DynamicEmulateBLL
    {
        M_Base _m_base;
        public DynamicEmulateBLL(M_Base _mbase) {
            _m_base = _mbase;
        }
        public object ObjectEmulate(string nsclassName,object data) {
            Type _classType = _m_base.DymaticType.Where(a => a.TypeName == nsclassName).FirstOrDefault().DType;
            var obj = Activator.CreateInstance(_classType);

            foreach (PropertyInfo pi in _classType.GetProperties())
            {
                if (data.GetType().GetProperty(pi.Name)!=null)
                {
                    Console.WriteLine("有相同的值");
                    pi.SetValue(obj, data.GetType().GetProperty(pi.Name).GetValue(data));
                } 
            }
            return obj;
        }

        public object JsonEmulate(string nsclassName, string jsonstring) {
            Type _classType = _m_base.DymaticType.Where(a => a.TypeName == nsclassName).FirstOrDefault().DType;
           return    Newtonsoft.Json.JsonConvert.DeserializeObject(jsonstring, _classType);
        }

    }
}

交互模型：

using System;
using System.Collections.Generic;

namespace MagicModel
{
    public class M_Base {
        public string _AssamblyName { get; set; }
        public List<M_DymaticType> DymaticType { get; set; } = new List<M_DymaticType>();
    }
    public class M_DymaticType
    {
        public string TypeName { get; set; }
        public Type DType { get; set; }
    }
    public class M_DefineClass
    {
        public string NsClassName { get;  set; }
        public IEnumerable<M_ClassMember> Props { get;  set; }
    }
    public class M_ClassMember 
    {
        public string MemberName { get;  set; }
        public Type MemberType { get;  set; }
    }

}

下面来测试下效果，先定义10个类：

打开vs里面的cmd开发人员命令提示”，输入ildasm，然后把生成的dll拖进去，有了。

赋值检验：

有效果了

　　到了这一步，动态模型生成完成，它的调用位置不仅限于运行时代码，也可以在其他环境中使用了。

　　疑问：

　　1.运行时环境下处理引用问题是个麻烦事，所以干脆静态一个AssemblyName，项目间交叉引用该怎么解决？

       2.我开始用Assembly去取dll，发现两个问题。1，交叉引用出问题。2，赋值取值出问题。

       3.这个RunAndSave参数直接加载进来了，所以就在这上面static保存在内存等待以后调用，有没有更好的方法调用？或者说我生成的dll文件想什么时候用什么时候用，在哪里用都由我决定。

 

      以上资料全参考msdn。

     模型层可以存库，做生成对比，做db对比等等，后面再优化！