Emit动态生成代理类用于监控对象的字段修改

利用Emit动态生成代理对象监控对象哪些字段被修改,被修改为什么值

被Register的对象要监控的值必须是Virtual虚类型

必须使用CreateInstance创建对象

必须使用DynamicProxyGenerator.GetChangeProperties 获取改变的值

调用GetChangeProperties 返回的Dictionary.Clear() 重置当前已修改属性

对象赋值时增加变动修改,如果value 和原始值相同则不记录变动

支持注册多个对象到一个代理程序集

核心部分摘自 https://blog.csdn.net/lishuangquan1987/article/details/84312514

测试代码

using System;
using System.Diagnostics;

namespace TestApp
{
    class Program
    {
        static void Main(string[] args)
        {
            DynamicProxyGenerator dpg = new DynamicProxyGenerator("DynamicAssembly");
            //注册类型
            dpg.Register<Person>();
            dpg.Register<Person2>();
            //保存为dll
            dpg.Save();
            Person p = dpg.CreateInstance<Person>();
            p.Name = "tom";
            p.Age = 12345;
            var changes = DynamicProxyGenerator.GetChangeProperties(p);
            Console.WriteLine($"第一次检测改变了{changes.Count}个属性");
            changes.Clear();
            p.Name = "tony";
            p.Age = 12345;
            changes = DynamicProxyGenerator.GetChangeProperties(p);
            Console.WriteLine($"第二次检测改变了{changes.Count}个属性");
            //创建对象测试
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            for (int i = 0; i < 100000; i++)
            {
                var p2 = dpg.CreateInstance<Person2>();
            }
            stopwatch.Stop();
            Console.WriteLine($"创建对象100000个用时{stopwatch.ElapsedMilliseconds}ms");
            Console.ReadKey();
        }
    }

    public class Person
    {
        public virtual String Name { get; set; }
        public virtual Int32 Age { get; set; }
    }
    public class Person2
    {
        public virtual String Name { get; set; }
        public virtual Int32 Age { get; set; }
    }
}

```

核心代码
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;

namespace TestApp
{
    /// <summary>
    /// 动态代理类生成器
    /// </summary>
    public class DynamicProxyGenerator
    {
        private const string ModifiedPropertyNamesFieldName = "ChangePropertys";

        private const MethodAttributes GetSetMethodAttributes = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.CheckAccessOnOverride | MethodAttributes.Virtual | MethodAttributes.HideBySig;
        /// <summary>
        /// 程序集名称
        /// </summary>
        private AssemblyName assemblyName { get; set; }
        /// <summary>
        /// 程序集构建器
        /// </summary>
        private AssemblyBuilder assemblyBuilder { get; set; }

        /// <summary>
        /// 程序集模块
        /// </summary>
        private ModuleBuilder moduleBuilder { get; set; }

        /// <summary>
        /// 保存修改属性的集合类型
        /// </summary>
        private Type modifiedPropertyNamesType { get; set; }

        /// <summary>
        /// 构造一个动态代理生成器
        /// </summary>
        /// <param name="AssemblyName"></param>
        /// <param name="isSaveDynamicModule"></param>
        public DynamicProxyGenerator(String DynamicAssemblyName)
        {
            //创建程序集
            assemblyName = new AssemblyName(DynamicAssemblyName);
            assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);
            //动态创建模块
            moduleBuilder = assemblyBuilder.DefineDynamicModule(String.Format("{0}Module", DynamicAssemblyName), String.Format("{0}.dll", DynamicAssemblyName));
            //修改的属性集合类型
            modifiedPropertyNamesType = typeof(Dictionary<String, Object>);
        }

        /// <summary>
        /// 注册类型到代理生成器(只注册Virtual属性)
        /// </summary>
        /// <typeparam name="T">类</typeparam>
        /// <returns></returns>
        public void Register<T>()
        {
            Type typeNeedProxy = typeof(T);

            //创建动态类代理,这里名字不变 继承自T
            TypeBuilder typeBuilderProxy = moduleBuilder.DefineType(typeNeedProxy.Name, TypeAttributes.Public, typeNeedProxy);
            //定义一个Dictionary变量存放属性变更名
            FieldBuilder fbModifiedPropertyNames = typeBuilderProxy.DefineField(ModifiedPropertyNamesFieldName, modifiedPropertyNamesType, FieldAttributes.Public);

            /*
             * 构造函数 实例化 ModifiedPropertyNames,生成类似于下面的代码
               ModifiedPropertyNames = new List<string>();
            */
            ConstructorBuilder constructorBuilder = typeBuilderProxy.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null);
            ILGenerator ilgCtor = constructorBuilder.GetILGenerator();
            ilgCtor.Emit(OpCodes.Ldarg_0);//加载当前类
            ilgCtor.Emit(OpCodes.Newobj, modifiedPropertyNamesType.GetConstructor(new Type[0]));//实例化对象入栈
            ilgCtor.Emit(OpCodes.Stfld, fbModifiedPropertyNames);//设置fbModifiedPropertyNames值,为刚入栈的实例化对象
            ilgCtor.Emit(OpCodes.Ret);//返回

            //获取被代理对象的所有属性,循环属性进行重写
            PropertyInfo[] properties = typeNeedProxy.GetProperties();
            foreach (PropertyInfo propertyInfo in properties)
            {
                string propertyName = propertyInfo.Name;
                Type typePepropertyInfo = propertyInfo.PropertyType;
                //动态创建字段和属性
                FieldBuilder fieldBuilder = typeBuilderProxy.DefineField("_" + propertyName.ToLower(), typePepropertyInfo, FieldAttributes.Private);
                PropertyBuilder propertyBuilder = typeBuilderProxy.DefineProperty(propertyName, PropertyAttributes.SpecialName, typePepropertyInfo, null);
                //重写属性的Get Set方法
                var methodGet = typeBuilderProxy.DefineMethod("get_" + propertyName, GetSetMethodAttributes, typePepropertyInfo, Type.EmptyTypes);
                var methodSet = typeBuilderProxy.DefineMethod("set_" + propertyName, GetSetMethodAttributes, null, new Type[] { typePepropertyInfo });
                //il of get method
                var ilGetMethod = methodGet.GetILGenerator();
                ilGetMethod.Emit(OpCodes.Ldarg_0);
                ilGetMethod.Emit(OpCodes.Ldfld, fieldBuilder);
                ilGetMethod.Emit(OpCodes.Ret);
                //il of set method
                ILGenerator ilSetMethod = methodSet.GetILGenerator();
                //声明布尔类型
                ilSetMethod.DeclareLocal(typeof(Boolean));
                //声明一个标签,标记到ret
                Label label = ilSetMethod.DefineLabel();
                //判断值是否改变
                ilSetMethod.Emit(OpCodes.Nop);
                ilSetMethod.Emit(OpCodes.Ldarg_0);
                ilSetMethod.Emit(OpCodes.Ldfld, fieldBuilder);
                ilSetMethod.Emit(OpCodes.Ldarg_1);
                ilSetMethod.Emit(OpCodes.Ceq);
                ilSetMethod.Emit(OpCodes.Ldc_I4_0);
                ilSetMethod.Emit(OpCodes.Ceq);
                ilSetMethod.Emit(OpCodes.Stloc_0);
                ilSetMethod.Emit(OpCodes.Ldloc_0);
                //如果未改变,调到结束return
                ilSetMethod.Emit(OpCodes.Brfalse_S, label);
                //赋值
                ilSetMethod.Emit(OpCodes.Nop);
                ilSetMethod.Emit(OpCodes.Ldarg_0);
                ilSetMethod.Emit(OpCodes.Ldarg_1);
                ilSetMethod.Emit(OpCodes.Stfld, fieldBuilder);
                //保存到 Dictionary
                ilSetMethod.Emit(OpCodes.Ldarg_0);
                ilSetMethod.Emit(OpCodes.Ldfld, fbModifiedPropertyNames);
                ilSetMethod.Emit(OpCodes.Ldstr, propertyInfo.Name);
                ilSetMethod.Emit(OpCodes.Ldarg_1);
                ilSetMethod.Emit(OpCodes.Box, propertyInfo.PropertyType);
                ilSetMethod.Emit(OpCodes.Callvirt, modifiedPropertyNamesType.GetMethod("set_Item", new Type[] { typeof(string), typeof(Object) }));
                ilSetMethod.Emit(OpCodes.Nop);
                ilSetMethod.Emit(OpCodes.Nop);
                ilSetMethod.MarkLabel(label);
                ilSetMethod.Emit(OpCodes.Ret);
                //设置属性的Get Set方法
                propertyBuilder.SetGetMethod(methodGet);
                propertyBuilder.SetSetMethod(methodSet);
            }
            //引用下, 要不无法生成
            Type proxyClassType = typeBuilderProxy.CreateType();
        }

        /// <summary>
        /// 保存程序集到dll文件
        /// </summary>
        public void Save()
        {
            assemblyBuilder.Save($"{assemblyName.Name}.dll");
        }

        /// <summary>
        /// 创建实例
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public T CreateInstance<T>()
        {
            Type typeNeedProxy = typeof(T);
            return (T)assemblyBuilder.CreateInstance(typeNeedProxy.Name);
        }

        /// <summary>
        /// 获取属性的变更名称,
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static Dictionary<String, Object> GetChangeProperties<T>(T obj)
        {
            FieldInfo fieldInfo = obj.GetType().GetField(ModifiedPropertyNamesFieldName);
            if (fieldInfo == null) return null;
            object value = fieldInfo.GetValue(obj);
            return value as Dictionary<String, Object>;
        }
    }
}

```

来源：https://blog.csdn.net/Vblegend_2013/article/details/85228041