最高效率的对象深拷贝通用方法转转

原文：http://blog.csdn.net/qldsrx/article/details/8265985

    using System;  
    using System.Collections.Generic;  
    using System.Linq;  
    using System.Reflection;  
    using System.Reflection.Emit;  
    using System.Text;  
      
      
    namespace Care.Common  
    {  
        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 List<FieldInfo> GetSettableFields(Type t)  
            {  
                return t.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).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("CopyImpl", 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("CopyImpl", 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("CopyImpl", 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("CopyImpl", 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("CopyImpl", 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("CopyImpl", 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>));  
            }  
      
      
            static T CopyImpl<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;  
            }  
      
      
      
      
            /// <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);  
            }  
        }  
    }  

花了不少精力研究的最高效的通用方法，目前能支持任何带无参数的构造函数的类的深拷贝，一元数组的深拷贝，数组和类的循环嵌套深拷贝，双向链表结构 的类型对象深拷贝，进行对象拷贝过程中，未判断任何附加特性，因此可序列化标志对其无效，即使不可序列化的对象，也可以进行深拷贝。

　　该方法是最基础的方法，如果需要高级应用，可以自定义特性(Attribute)进行忽略某些字段。

　　该方法最多用途就是在数据库的实体对象的赋值上面，操作一个临时对象（复制出来），如果中途放弃改动，则直接丢弃对象，不影响原先的对象，否则可将对象复制回去。