C#利用静态泛型缓存 和 表达式树实现高效的深拷贝

代码如下：

    /// <summary>
    /// 提供对象或集合的深拷贝（拷贝private/public：实例成员、属性、静态成员）
    /// </summary>
    /// <typeparam name="T">对象类型或集合元素类型</typeparam>
    public class DeepCopyHelper<T> where T : class, new() // 需要无参构造函数，构造表达式树的时候需要利用无参构造函数创建对象
    {
        /// <summary>
        /// 映射表达式，泛型缓存每个类型存一份
        /// </summary>
        private static readonly Func<T, T> s_CopyFunc = null;

        /// <summary>
        /// 静态构造函数，每个泛型类型会且只会执行一次
        /// </summary>
        static DeepCopyHelper()
        {
            BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
            ParameterExpression parameterExpression = Expression.Parameter(typeof(T), "m"); // 参数m :m => 
            List<MemberBinding> memberBindingList = new List<MemberBinding>();
            foreach (var item in typeof(T).GetProperties(bindingFlags))
            {
                if (!item.CanWrite) // 只读属性不拷贝
                {
                    continue;
                }
                MemberExpression property = Expression.Property(parameterExpression, item); // m.Name
                MemberBinding memberBinding = Expression.Bind(item, property); // Name = m.Name
                memberBindingList.Add(memberBinding);
            }
            foreach (var item in typeof(T).GetFields(bindingFlags))
            {
                MemberExpression property = Expression.Field(parameterExpression, item);
                MemberBinding memberBinding = Expression.Bind(item, property);
                memberBindingList.Add(memberBinding);
            }
            MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(T)), memberBindingList.ToArray());// new T() {Name = m.Name}
            Expression<Func<T, T>> lambda = Expression.Lambda<Func<T, T>>(memberInitExpression, new ParameterExpression[]
            {
                    parameterExpression
            }); // m => new T() {Name = m.Name}

            s_CopyFunc = lambda.Compile();
        }

        /// <summary>
        /// 对象拷贝（拷贝private/public：实例成员、属性、静态成员）
        /// </summary>
        /// <param name="data">源</param>
        /// <returns></returns>
        public static T DeepCopy(T data)
        {
            return s_CopyFunc(data);
        }

        /// <summary>
        /// 集合拷贝（拷贝private/public：实例成员、属性、静态成员）
        /// </summary>
        /// <param name="data">源</param>
        /// <returns></returns>
        public static List<T> DeepCopyList(List<T> data)
        {
            if (data == null)
            {
                return null;
            }
            if (data.Count == 0)
            {
                return new List<T>();
            }
            return data.Select(a => DeepCopy(a)).ToList();
        }
    }

有一种深拷贝方式，是利用BinaryFormatter序列化再反序列化，如下：

    public static class ObjectExtension
    {
        /// <summary>
        /// 深拷贝
        /// 注意：必须标识为可序列化[Serializable]
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static T DeepCopy<T>(this T obj)
            where T : class
        {
            try
            {
                if (obj == null)
                {
                    return null;
                }

                BinaryFormatter binaryFormatter = new BinaryFormatter();
                using (MemoryStream stream = new MemoryStream())
                {
                    binaryFormatter.Serialize(stream, obj);
                    stream.Position = 0;
                    return (T)binaryFormatter.Deserialize(stream);
                }
            }
            catch
            {
                return null;
            }
        }
    }

以下面的People类为例

    [Serializable]
    public class People
    {
        public People() { }
        public People(Guid id, int name1, int name2, int name3, int name4, string uniqueName)
        {
            ID = id;
            Name1 = name1;
            Name2 = name2;
            Name3 = name3;
            Name4 = name4;
            UniqueName = uniqueName;
        }

        private Guid ID;

        private string UniqueName;

        private int Name1;

        private int Name2 { get; set; }

        public int Name3;

        public int Name4 { get; set; }
    }

分别对List<People>集合进行深拷贝测试：

            //测试集合拷贝
            // 创建包含一定数量元素的集合
            int count = 100;  // 可设置不同量级的数量进行对比
            List<People> lstSource = new List<People>();
            for (int i = 0; i < count; i++)
            {
                lstSource.Add(new People(Guid.NewGuid(), i, i + 1, i + 2, i + 3, "测试"));
            }
            Console.WriteLine("数据量：" + lstSource.Count);

            // 对比
            Stopwatch watch = new Stopwatch();
            watch.Start();
            List<People> lstCopy = DeepCopyFactory<People>.DeepCopyList(lstSource);
            watch.Stop();
            Console.WriteLine("新的方式：" + watch.ElapsedMilliseconds + "毫秒");

            watch.Restart();
            List<People> lstCopy2 = lstSource.DeepCopy();
            watch.Stop();
            Console.WriteLine("BinaryFormatter序列化方式：" + watch.ElapsedMilliseconds + "毫秒");
            Console.Read();

对比结果如下：

可见，这种方式，数据量越大，效果越明显。

像上边的People类，一千万的数据深拷贝。只需2s

=============================

2020-11-17更新，

深拷贝不拷贝只读属性，更新了代码。

2020-12-9 更新

静态字段不反射，静态字段属于类