实体类编程的最佳伴侣——高效的实体类复制

在面向对象编程的时代，实体类的操作已经越来越普遍了，从数据库中获取数据，离线存储在实体类集合中，对集合的修改再反馈到数据库中等。对于实体类的修改就意味着对数据库的修改，为了更好的自动化编程，减少编码量，同时也为了提高运行速度，这里发布个代码类——对象的深度拷贝和对象属性的浅拷贝， 利用了Emit操作，执行速度肯定是最快的。

public static class ObjectCopy
{
    struct Identity
    {
        int _hashcode;
        RuntimeTypeHandle _type;

        public Identity(int hashcode, RuntimeTypeHandle type)
        {
            _hashcode = hashcode;
            _type = type;
        }
    }
    //缓存对象复制的方法。
    static Dictionary<Type, Func<object, Dictionary<Identity, object>, object>> methods1 = new Dictionary<Type, Func<object, Dictionary<Identity, object>, object>>();
    static Dictionary<Type, Action<object, Dictionary<Identity, object>, object>> methods2 = new Dictionary<Type, Action<object, Dictionary<Identity, object>, object>>();
        static Dictionary<Type, Action<object, Dictionary<Identity, object>, object>> methods3 = new Dictionary<Type, Action<object, Dictionary<Identity, object>, object>>();

    static List<FieldInfo> GetSettableFields(Type t)
    {
        return t.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).ToList();
    }

    class PropInfo
    {
        public string Name { get; set; }
        public MethodInfo Getter { get; set; }
        public MethodInfo Setter { get; set; }
        public Type Type { get; set; }
    }

    static List<PropInfo> GetPublicProps(Type t)
    {
        return t
                .GetProperties()
                .Select(p => new PropInfo
                {
                    Name = p.Name,
                    Getter = p.DeclaringType == t ? p.GetGetMethod(true) : p.DeclaringType.GetProperty(p.Name).GetGetMethod(true),
                    Setter = p.DeclaringType == t ? p.GetSetMethod(true) : p.DeclaringType.GetProperty(p.Name).GetSetMethod(true),
                    Type = p.PropertyType
                })
                .Where(info => info.Getter != null && info.Setter != null)
                .ToList();
    }

    static Func<object, Dictionary<Identity, object>, object> CreateCloneMethod1(Type type, Dictionary<Identity, object> objects)
    {
        Type tmptype;
        var fields = GetSettableFields(type);
        var dm = new DynamicMethod(string.Format("Clone{0}", Guid.NewGuid()), typeof(object), new[] { typeof(object), typeof(Dictionary<Identity, object>) }, true);
        var il = dm.GetILGenerator();
        il.DeclareLocal(type);
        il.DeclareLocal(type);
        il.DeclareLocal(typeof(Identity));
        if (!type.IsArray)
        {
            il.Emit(OpCodes.Newobj, type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null));
            il.Emit(OpCodes.Dup);
            il.Emit(OpCodes.Stloc_1);
            il.Emit(OpCodes.Ldloca_S, 2);
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Castclass, type);
            il.Emit(OpCodes.Dup);
            il.Emit(OpCodes.Stloc_0);
            il.Emit(OpCodes.Callvirt, typeof(object).GetMethod("GetHashCode"));
            il.Emit(OpCodes.Ldtoken, type);
            il.Emit(OpCodes.Call, typeof(Identity).GetConstructor(BindingFlags.Instance | BindingFlags.Public, null, new[] { typeof(int), typeof(RuntimeTypeHandle) }, null));
            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Ldloc_2);
            il.Emit(OpCodes.Ldloc_1);
            il.Emit(OpCodes.Callvirt, typeof(Dictionary<Identity, object>).GetMethod("Add"));
            foreach (var field in fields)
            {
                if (!field.FieldType.IsValueType && field.FieldType != typeof(String))
                {
                    //不符合条件的字段，直接忽略，避免报错。
                    if ((field.FieldType.IsArray && (field.FieldType.GetArrayRank() > 1 || (!(tmptype = field.FieldType.GetElementType()).IsValueType && tmptype != typeof(String) && tmptype.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null) == null))) ||
                        (!field.FieldType.IsArray && field.FieldType.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null) == null))
                        break;
                    il.Emit(OpCodes.Ldloc_1);
                    il.Emit(OpCodes.Ldloc_0);
                    il.Emit(OpCodes.Ldfld, field);
                    il.Emit(OpCodes.Ldarg_1);
                    il.EmitCall(OpCodes.Call, typeof(ObjectCopy).GetMethod("CopyImpl1", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(field.FieldType), null);
                    il.Emit(OpCodes.Stfld, field);
                }
                else
                {
                    il.Emit(OpCodes.Ldloc_1);
                    il.Emit(OpCodes.Ldloc_0);
                    il.Emit(OpCodes.Ldfld, field);
                    il.Emit(OpCodes.Stfld, field);
                }
            }
            for (type = type.BaseType; type != null && type != typeof(object); type = type.BaseType)
            {
                //只需要查找基类的私有成员，共有或受保护的在派生类中直接被复制过了。
                fields = type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance).ToList();
                foreach (var field in fields)
                {
                    if (!field.FieldType.IsValueType && field.FieldType != typeof(String))
                    {
                        //不符合条件的字段，直接忽略，避免报错。
                        if ((field.FieldType.IsArray && (field.FieldType.GetArrayRank() > 1 || (!(tmptype = field.FieldType.GetElementType()).IsValueType && tmptype != typeof(String) && tmptype.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null) == null))) ||
                            (!field.FieldType.IsArray && field.FieldType.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null) == null))
                            break;
                        il.Emit(OpCodes.Ldloc_1);
                        il.Emit(OpCodes.Ldloc_0);
                        il.Emit(OpCodes.Ldfld, field);
                        il.Emit(OpCodes.Ldarg_1);
                        il.EmitCall(OpCodes.Call, typeof(ObjectCopy).GetMethod("CopyImpl1", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(field.FieldType), null);
                        il.Emit(OpCodes.Stfld, field);
                    }
                    else
                    {
                        il.Emit(OpCodes.Ldloc_1);
                        il.Emit(OpCodes.Ldloc_0);
                        il.Emit(OpCodes.Ldfld, field);
                        il.Emit(OpCodes.Stfld, field);
                    }
                }
            }
        }
        else
        {
            Type arraytype = type.GetElementType();
            var i = il.DeclareLocal(typeof(int));
            var lb1 = il.DefineLabel();
            var lb2 = il.DefineLabel();
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Castclass, type);
            il.Emit(OpCodes.Dup);
            il.Emit(OpCodes.Stloc_0);
            il.Emit(OpCodes.Ldlen);
            il.Emit(OpCodes.Dup);
            il.Emit(OpCodes.Ldc_I4_1);
            il.Emit(OpCodes.Sub);
            il.Emit(OpCodes.Stloc, i);
            il.Emit(OpCodes.Newarr, arraytype);
            il.Emit(OpCodes.Dup);
            il.Emit(OpCodes.Stloc_1);
            il.Emit(OpCodes.Ldloca_S, 2);
            il.Emit(OpCodes.Ldloc_0);
            il.Emit(OpCodes.Callvirt, typeof(object).GetMethod("GetHashCode"));
            il.Emit(OpCodes.Ldtoken, type);
            il.Emit(OpCodes.Call, typeof(Identity).GetConstructor(BindingFlags.Instance | BindingFlags.Public, null, new[] { typeof(int), typeof(RuntimeTypeHandle) }, null));
            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Ldloc_2);
            il.Emit(OpCodes.Ldloc_1);
            il.Emit(OpCodes.Callvirt, typeof(Dictionary<Identity, object>).GetMethod("Add"));
            il.Emit(OpCodes.Ldloc, i);
            il.Emit(OpCodes.Br, lb1);
            il.MarkLabel(lb2);
            il.Emit(OpCodes.Dup);
            il.Emit(OpCodes.Ldloc, i);
            il.Emit(OpCodes.Ldloc_0);
            il.Emit(OpCodes.Ldloc, i);
            il.Emit(OpCodes.Ldelem, arraytype);
            if (!arraytype.IsValueType && arraytype != typeof(String))
            {
                il.EmitCall(OpCodes.Call, typeof(ObjectCopy).GetMethod("CopyImpl1", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(arraytype), null);
            }
            il.Emit(OpCodes.Stelem, arraytype);
            il.Emit(OpCodes.Ldloc, i);
            il.Emit(OpCodes.Ldc_I4_1);
            il.Emit(OpCodes.Sub);
            il.Emit(OpCodes.Dup);
            il.Emit(OpCodes.Stloc, i);
            il.MarkLabel(lb1);
            il.Emit(OpCodes.Ldc_I4_0);
            il.Emit(OpCodes.Clt);
            il.Emit(OpCodes.Brfalse, lb2);
        }
        il.Emit(OpCodes.Ret);

        return (Func<object, Dictionary<Identity, object>, object>)dm.CreateDelegate(typeof(Func<object, Dictionary<Identity, object>, object>));
    }
    
    static Action<object, Dictionary<Identity, object>, object> CreateCloneMethod2(Type type, Dictionary<Identity, object> objects)
    {
        Type tmptype;
        var fields = GetSettableFields(type);
        var dm = new DynamicMethod(string.Format("Copy{0}", Guid.NewGuid()), null, new[] { typeof(object), typeof(Dictionary<Identity, object>), typeof(object) }, true);
        var il = dm.GetILGenerator();
        il.DeclareLocal(type);
        il.DeclareLocal(type);
        il.DeclareLocal(typeof(Identity));
        if (!type.IsArray)
        {
            il.Emit(OpCodes.Ldarg_2);
            il.Emit(OpCodes.Castclass, type);
            il.Emit(OpCodes.Stloc_1);
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Castclass, type);
            il.Emit(OpCodes.Stloc_0);
            foreach (var field in fields)
            {
                if (!field.FieldType.IsValueType && field.FieldType != typeof(String))
                {
                    //不符合条件的字段，直接忽略，避免报错。
                    if ((field.FieldType.IsArray && (field.FieldType.GetArrayRank() > 1 || (!(tmptype = field.FieldType.GetElementType()).IsValueType && tmptype != typeof(String) && tmptype.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null) == null))) ||
                        (!field.FieldType.IsArray && field.FieldType.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null) == null))
                        break;
                    il.Emit(OpCodes.Ldloc_1);
                    il.Emit(OpCodes.Ldloc_0);
                    il.Emit(OpCodes.Ldfld, field);
                    il.Emit(OpCodes.Ldarg_1);
                    il.EmitCall(OpCodes.Call, typeof(ObjectCopy).GetMethod("CopyImpl1", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(field.FieldType), null);
                    il.Emit(OpCodes.Stfld, field);
                }
                else
                {
                    il.Emit(OpCodes.Ldloc_1);
                    il.Emit(OpCodes.Ldloc_0);
                    il.Emit(OpCodes.Ldfld, field);
                    il.Emit(OpCodes.Stfld, field);
                }
            }
            for (type = type.BaseType; type != null && type != typeof(object); type = type.BaseType)
            {
                //只需要查找基类的私有成员，共有或受保护的在派生类中直接被复制过了。
                fields = type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance).ToList();
                foreach (var field in fields)
                {
                    if (!field.FieldType.IsValueType && field.FieldType != typeof(String))
                    {
                        //不符合条件的字段，直接忽略，避免报错。
                        if ((field.FieldType.IsArray && (field.FieldType.GetArrayRank() > 1 || (!(tmptype = field.FieldType.GetElementType()).IsValueType && tmptype != typeof(String) && tmptype.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null) == null))) ||
                            (!field.FieldType.IsArray && field.FieldType.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null) == null))
                            break;
                        il.Emit(OpCodes.Ldloc_1);
                        il.Emit(OpCodes.Ldloc_0);
                        il.Emit(OpCodes.Ldfld, field);
                        il.Emit(OpCodes.Ldarg_1);
                        il.EmitCall(OpCodes.Call, typeof(ObjectCopy).GetMethod("CopyImpl1", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(field.FieldType), null);
                        il.Emit(OpCodes.Stfld, field);
                    }
                    else
                    {
                        il.Emit(OpCodes.Ldloc_1);
                        il.Emit(OpCodes.Ldloc_0);
                        il.Emit(OpCodes.Ldfld, field);
                        il.Emit(OpCodes.Stfld, field);
                    }
                }
            }
        }
        else
        {
            Type arraytype = type.GetElementType();
            var i = il.DeclareLocal(typeof(int));
            var lb1 = il.DefineLabel();
            var lb2 = il.DefineLabel();
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Castclass, type);
            il.Emit(OpCodes.Dup);
            il.Emit(OpCodes.Stloc_0);
            il.Emit(OpCodes.Ldlen);
            il.Emit(OpCodes.Dup);
            il.Emit(OpCodes.Ldc_I4_1);
            il.Emit(OpCodes.Sub);
            il.Emit(OpCodes.Stloc, i);
            il.Emit(OpCodes.Ldarg_2);
            il.Emit(OpCodes.Castclass, type);
            il.Emit(OpCodes.Dup);
            il.Emit(OpCodes.Stloc_1);
            il.Emit(OpCodes.Ldloc, i);
            il.Emit(OpCodes.Br, lb1);
            il.MarkLabel(lb2);
            il.Emit(OpCodes.Dup);
            il.Emit(OpCodes.Ldloc, i);
            il.Emit(OpCodes.Ldloc_0);
            il.Emit(OpCodes.Ldloc, i);
            il.Emit(OpCodes.Ldelem, arraytype);
            if (!arraytype.IsValueType && arraytype != typeof(String))
            {
                il.EmitCall(OpCodes.Call, typeof(ObjectCopy).GetMethod("CopyImpl1", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(arraytype), null);
            }
            il.Emit(OpCodes.Stelem, arraytype);
            il.Emit(OpCodes.Ldloc, i);
            il.Emit(OpCodes.Ldc_I4_1);
            il.Emit(OpCodes.Sub);
            il.Emit(OpCodes.Dup);
            il.Emit(OpCodes.Stloc, i);
            il.MarkLabel(lb1);
            il.Emit(OpCodes.Ldc_I4_0);
            il.Emit(OpCodes.Clt);
            il.Emit(OpCodes.Brfalse, lb2);
        }
        il.Emit(OpCodes.Ret);

        return (Action<object, Dictionary<Identity, object>, object>)dm.CreateDelegate(typeof(Action<object, Dictionary<Identity, object>, object>));
    }

    /// <summary>
    /// 对属性进行复制，不查找父类，用于当前实体对象的属性拷贝。
    /// </summary>
    /// <param name="type">实体类型</param>
    /// <param name="objects">复制链</param>
    /// <returns></returns>
    static Action<object, Dictionary<Identity, object>, object> CreateCloneMethod3(Type type, Dictionary<Identity, object> objects)
    {
        var props = GetPublicProps(type);
        var dm = new DynamicMethod(string.Format("Copy{0}", Guid.NewGuid()), null, new[] { typeof(object), typeof(Dictionary<Identity, object>), typeof(object) }, true);
        var il = dm.GetILGenerator();
        il.DeclareLocal(type);//存放源对象
        il.DeclareLocal(type);//存放目标对象
        il.DeclareLocal(typeof(Identity));//存放标识
        if (!type.IsArray)
        {
            il.Emit(OpCodes.Ldarg_2);
            il.Emit(OpCodes.Castclass, type);
            il.Emit(OpCodes.Stloc_1);//将参数中获取的目标对象存放到局部变量1中
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Castclass, type);
            il.Emit(OpCodes.Stloc_0);//将参数中获取的源对象存放到局部变量0中
            foreach (var prop in props)
            {
                if (!prop.Type.IsValueType && prop.Type != typeof(String))
                {
                    //不符合条件的属性，直接忽略。
                    if (prop.Type.IsArray)
                        break;
                    il.Emit(OpCodes.Ldloc_0);
                    il.Emit(OpCodes.Call, prop.Getter);//获取局部变量0中暂存的源对象的属性
                    il.Emit(OpCodes.Ldarg_1);//加载参数中的复制链对象
                    il.Emit(OpCodes.Ldloc_1);
                    il.Emit(OpCodes.Call, prop.Getter);//获取局部变量1中暂存的目标对象的属性
                    il.EmitCall(OpCodes.Call, typeof(ObjectCopy).GetMethod("CopyImpl2", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(prop.Type), null);
                        
                }
                else
                {
                    il.Emit(OpCodes.Ldloc_1);
                    il.Emit(OpCodes.Ldloc_0);
                    il.Emit(OpCodes.Call, prop.Getter);
                    il.Emit(OpCodes.Call, prop.Setter);
                }
            }                
        }
        il.Emit(OpCodes.Ret);

        return (Action<object, Dictionary<Identity, object>, object>)dm.CreateDelegate(typeof(Action<object, Dictionary<Identity, object>, object>));
    }

    static T CopyImpl1<T>(T source, Dictionary<Identity, object> objects) where T : class
    {
        //为空则直接返回null
        if (source == null)
            return null;

        Type type = source.GetType();
        Identity id = new Identity(source.GetHashCode(), type.TypeHandle);
        object result;
        //如果发现曾经复制过，用之前的，从而停止递归复制。
        if (!objects.TryGetValue(id, out result))
        {
            //最后查找对象的复制方法，如果不存在，创建新的。
            Func<object, Dictionary<Identity, object>, object> method;
            if (!methods1.TryGetValue(type, out method))
            {
                method = CreateCloneMethod1(type, objects);
                methods1.Add(type, method);
            }
            result = method(source, objects);
        }
        return (T)result;
    }

    static void CopyImpl2<T>(T source, T target, Dictionary<Identity, object> objects) where T : class
    {
        Type type = typeof(T);
        Identity id = new Identity(source.GetHashCode(), type.TypeHandle);
        object result;
        //如果发现曾经复制过，用之前的，从而停止递归复制。
        if (!objects.TryGetValue(id, out result))
        {
            objects.Add(new Identity(source.GetHashCode(), type.TypeHandle), source);
            //最后查找对象的复制方法，如果不存在，创建新的。
            Action<object, Dictionary<Identity, object>, object> method;
            if (!methods3.TryGetValue(type, out method))
            {
                method = CreateCloneMethod3(type, objects);
                methods3.Add(type, method);
            }
            method(source, objects, target);
        }
    }


    /// <summary>
    /// 创建对象深度复制的副本
    /// </summary>
    public static T ToObjectCopy<T>(this T source) where T : class

    {
        Type type = source.GetType();
        Dictionary<Identity, object> objects = new Dictionary<Identity, object>();//存放内嵌引用类型的复制链，避免构成一个环。
        Func<object, Dictionary<Identity, object>, object> method;
        if (!methods1.TryGetValue(type, out method))
        {
            method = CreateCloneMethod1(type, objects);
            methods1.Add(type, method);
        }
        return (T)method(source, objects);
    }


    /// <summary>
    /// 将source对象的所有属性复制到target对象中，深度复制
    /// </summary>
    public static void ObjectCopyTo<T>(this T source, T target) where T : class
    {
        if (target == null)
            throw new Exception("将要复制的目标未初始化");
        Type type = source.GetType();
        if (type != target.GetType())
            throw new Exception("要复制的对象类型不同，无法复制");
        Dictionary<Identity, object> objects = new Dictionary<Identity, object>();//存放内嵌引用类型的复制链，避免构成一个环。
        objects.Add(new Identity(source.GetHashCode(), type.TypeHandle), source);
        Action<object, Dictionary<Identity, object>, object> method;
        if (!methods2.TryGetValue(type, out method))
        {
            method = CreateCloneMethod2(type, objects);
            methods2.Add(type, method);
        }
        method(source, objects, target);
    }

    /// <summary>
    /// 将source对象的所有属性复制到target对象中，仅对公有属性复制，不查找父类，不创建引用属性，但复制引用属性内部的属性。
    /// </summary>
    public static void PropCopyTo<T>(this T source, T target) where T : class
    {
        if (target == null)
            throw new Exception("将要复制的目标未初始化");
        Type type = typeof(T);
        Dictionary<Identity, object> objects = new Dictionary<Identity, object>();//存放内嵌引用类型的复制链，避免构成一个环。
        objects.Add(new Identity(source.GetHashCode(), type.TypeHandle), source);
        Action<object, Dictionary<Identity, object>, object> method;
        if (!methods3.TryGetValue(type, out method))
        {
            method = CreateCloneMethod3(type, objects);
            methods3.Add(type, method);
        }
        method(source, objects, target);
    }
}

代码中，ToObjectCopy是为了创建一个新的实体对象，ObjectCopyTo是为了将实体对象深度复制到另一个实体对象上面，PropCopyTo则是为了将对象属性浅拷贝另一个对象中。

一、为什么要深度复制实体？
如果实体类中某个属性是byte[]类型的，一般的赋值是传递地址，显然不深度拷贝就不能完成类似引用类型属性的真正拷贝。

二、如果实体类中某个实体的属性是另一个实体类，是否会被复制？
会，因此设计实体类的时候，不要将引用关系直接设计到类的属性中，虽然可以清晰的访问父子关系，但是实体类在创建时难度就会增加，不利于自动化编程，实体就应该如实反映数据库的表结构。

三、为什么要属性的浅拷贝？
因为对象的深度拷贝是通过字段的直接赋值实现的，那样效率最高，但是跳过了属性访问器，无法触发属性变化的事件，而对于实体类集合特别是ObservableCollection<T>需要通知UI刷新，需要触发属性变化的事件，一些数据库自动更新也是通过属性改变事件来触发的。

四、什么时候要复制实体？
当我们需要一个对实体修改的临时副本，不直接对数据源操作的时候，就需要用到它，这样可以提供一个取消操作的可能——放弃被修改的实体对象即可。

曾在CSDN上发布过一个类似版本，这是改进版，都是本人原创。