C# 急速深度拷贝

最新推荐文章于 2024-08-26 00:50:27 发布
最新推荐文章于 2024-08-26 00:50:27 发布
阅读量1.2k 收藏 6
点赞数 1
分类专栏： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hotmee/article/details/104468248
版权

怎样深度拷贝最快呢？

假设有这样的俩个对象

    public class People
    {
        public int Age { get; set; }
        public string Name { get; set; }
        public string Sex { get; set; }
    }
    public class Man
    {
        public int ID { get;private set; }
        public int Age { get; set; }
        public string Name { get; set; }
        public string Sex { get; set; }
    }

如果我们将People的所有属性都赋值给Man。如果数量不多，我们一个个手写就好了，但是假设对象属性有成百上千个怎么办？？？一个个手写？那还不累死！

一般情况下有俩种办法

第一种，反射，逐个复制，但是我们都知道，反射是很慢的。性能并不好；

第二种，通过JsonConverter.序列化再反序列化，(⊙o⊙)…。性能比反射还差。

那有什么更好的办法吗？？？

第一种 通过字节缓冲。将成员信息缓冲到字典里面去，读取的时候再去里面查找。但是我们知道，字典是比较耗费时间的。

第二种 泛型缓冲，啥叫泛型缓冲？其实在C#里面 例如类 List<People> 在编译之后和 List<Man> 还有关系吗？ 其实编译器是将其编译成为了俩单独的类。如果我们将我们的数据 存在类里面那么性能便是最高最快的。

废话说多了，贴代码。

public class DictionaryExpressionMapper
    {
        private static Dictionary<string, object> keyValuePairs = new Dictionary<string, object>();
        public static TOut Copy<Tin, TOut>(Tin tin)
        {
            var key = $"funckey_{typeof(Tin).FullName}_{typeof(TOut).FullName}";
            if (!keyValuePairs.ContainsKey(key))
            {
                var parameter = Expression.Parameter(typeof(Tin), "p");
                List<MemberBinding> memberBindings = new List<MemberBinding>();
                Copy<Tin>(typeof(TOut).GetProperties(), memberBindings, parameter);
                var init = Expression.MemberInit(Expression.New(typeof(TOut)),memberBindings.ToArray());
                var lambda = Expression.Lambda<Func<Tin, TOut>>(init, parameter);
                keyValuePairs[key] = lambda.Compile();
            }
            return ((Func<Tin, TOut>)keyValuePairs[key]).Invoke(tin);
        }
        /// <summary>
        /// 复制信息
        /// </summary>
        /// <typeparam name="Tin"></typeparam>
        /// <param name="memberInfos">对象成员列表</param>
        /// <param name="memberBindings">成员绑定表</param>
        /// <param name="parameter">表达式参数</param>
        private static void Copy<Tin>(IEnumerable<MemberInfo> memberInfos, List<MemberBinding> memberBindings, ParameterExpression parameter)
        {
            var propertys = typeof(Tin);
            foreach (var item in memberInfos)
            {
                if (item is PropertyInfo property1 && property1.CanWrite == false)
                {
                    continue;
                }
                var gg = propertys.GetProperty(item.Name);
                if (gg == null)
                {
                    continue;
                }
                var property = Expression.Property(parameter, gg);
                var member = Expression.Bind(item, property);
                memberBindings.Add(member);

            }
        }
    }

上面的代码是干啥的？核心就是动态生成LINQ语句。逐个将属性读取出来，然后逐个编写LINQ 属性赋值语句，最后新建初始化TOUT。

我们知道 在字典里查找数据时其实是通过传入KEY的哈希值查找的，速度还是比较慢的。我们再次优化

    public static class GenericExpressionMapper<Tin,TOut>
    {
        private static Func<Tin, TOut> func = null;
        static  GenericExpressionMapper()
        {
            var parameter = Expression.Parameter(typeof(Tin), "p");
            List<MemberBinding> memberBindings = new List<MemberBinding>();
            Copy(typeof(TOut).GetProperties(), memberBindings, parameter);
            var init = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindings.ToArray());
            var lambda = Expression.Lambda<Func<Tin, TOut>>(init, parameter);
            func = lambda.Compile();
        }
        /// <summary>
        /// 深度复制
        /// </summary>
        /// <param name="tin"></param>
        /// <returns></returns>
        public static TOut Copy(Tin tin) => func.Invoke(tin);
        /// <summary>
        /// 复制信息
        /// </summary>
        /// <typeparam name="Tin"></typeparam>
        /// <param name="memberInfos">对象成员列表</param>
        /// <param name="memberBindings">成员绑定表</param>
        /// <param name="parameter">表达式参数</param>
        private static void Copy(IEnumerable<MemberInfo> memberInfos, List<MemberBinding> memberBindings, ParameterExpression parameter)
        {
            var propertys = typeof(Tin);
            foreach (var item in memberInfos)
            {
                if (item is PropertyInfo property1 && property1.CanWrite == false)
                {
                    continue;
                }
                var gg = propertys.GetProperty(item.Name);
                if (gg == null)
                {
                    continue;
                }
                var property = Expression.Property(parameter, gg);
                var member = Expression.Bind(item, property);
                memberBindings.Add(member);

            }
        }
    }

升级后一对TIN和TOUT对应一个新的类。如此相当于我们直接操作类了，性能杠杠的。

调用就简单了。非常简单。如下 

            var peop = new People() {Age=123,Name="李四",Sex="女性" };
            var res = GenericExpressionMapper<People, Man>.Copy(peop);
            var re2 = GenericExpressionMapper<People, Man>.Copy(peop);

第一次调用泛型缓冲时，我们会调用其静态构造器，并生成其静态赋值委托。第二次调用时由于 静态构造器只调用一次，我们就直接调用其泛型委托了，啊哈，一下就赋值完成。

  经过100万次赋值测试，泛型委托深拷贝方式 是 原生硬编码的俩倍。快不快？字典形式深拷贝是原生硬码方式的10倍。反射和序列化方式是原生硬编码的100多倍。

最后我们将上面的代码优化掉，一个扩展方法使用起来可就美滋滋了

    /// <summary>
    /// 克隆扩展
    /// </summary>
    public static class CloneExtension

    {

        private static Dictionary<string, object> keyValuePairs = new Dictionary<string, object>();
        /// <summary>
        /// 克隆复制当前对象
        /// </summary>
        /// <typeparam name="TIn"></typeparam>
        /// <param name="data"></param>
        /// <returns></returns>
        public static TIn Clone<TIn>(this TIn data) => data.Clone<TIn, TIn>();
        /// <summary>
        /// 克隆服务对象
        /// </summary>
        /// <typeparam name="Tin"></typeparam>
        /// <typeparam name="TOut"></typeparam>
        /// <param name="tin"></param>
        /// <returns></returns>
        public static TOut Clone<Tin, TOut>(this Tin tin)

        {

            var key = $"funckey_{typeof(Tin).FullName}_{typeof(TOut).FullName}";

            if (!keyValuePairs.ContainsKey(key))

            {

                var parameter = Expression.Parameter(typeof(Tin), "p");

                List<MemberBinding> memberBindings = new List<MemberBinding>();

                Copy<Tin>(typeof(TOut).GetProperties(), memberBindings, parameter);

                var init = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindings.ToArray());

                var lambda = Expression.Lambda<Func<Tin, TOut>>(init, parameter);

                keyValuePairs[key] = lambda.Compile();

            }

            return ((Func<Tin, TOut>)keyValuePairs[key]).Invoke(tin);

        }

        /// <summary>
        /// 复制信息
        /// </summary>
        /// <typeparam name="Tin"></typeparam>
        /// <param name="memberInfos">对象成员列表</param>
        /// <param name="memberBindings">成员绑定表</param>
        /// <param name="parameter">表达式参数</param>
        private static void Copy<Tin>(IEnumerable<MemberInfo> memberInfos, List<MemberBinding> memberBindings, ParameterExpression parameter)

        {

            var propertys = typeof(Tin);

            foreach (var item in memberInfos)

            {

                if (item is PropertyInfo property1 && property1.CanWrite == false)

                {

                    continue;

                }

                var gg = propertys.GetProperty(item.Name);

                if (gg == null)

                {

                    continue;

                }

                var property = Expression.Property(parameter, gg);

                var member = Expression.Bind(item, property);

                memberBindings.Add(member);



            }

        }

    }

 

hotmee
关注
专栏目录
C# 实现Dictionary数据对象的深度拷贝
weixin_30892763的博客
08-06 1997
最近由于在做聊天调度服务，场景是这样的，集群聊天服务器，每台服务通过socket按照一定的频率发送UDP数据包给调度服务器，调度服务器接收各台聊天服务器发来的数据包，然后进行相应的数据分析，最后裁定目前最空闲的聊天服务器，以供聊天用户实时快速连接最优服务器，我考虑使用Dictionary数据结构来缓存收集到的服务器汇总数据，开发的过程中遇到几个比较棘手的问题： 1、收集的数据是通过多线程进行的，...
C# 深入解析深拷贝和浅拷贝
weixin_37619833的博客
01-31 422
一、前言 这个星期参加了一个面试，面试中问到深浅拷贝的区别，然后我就简单了讲述了它们的之间的区别，然后面试官又继续问，如何实现一个深拷贝呢？当时只回答回答了一种方式，就是使用反射，然后面试官提示还可以通过反序列化和表达树的方式。然后又继续问，如果用反射来实现深拷贝的话，如何解决互相引用对象的问题呢？ 当时我给出的答案是说那就不用反射去实现呗，用反序列化实现呗，或者直接避免使两个对象互相引用呗。然后...
浅谈C#深拷贝和浅拷贝
最新发布
R3333355726856的博客
08-26 664
浅谈C#深拷贝和浅拷贝
设计模式-原型模式
weixin_30455067的博客
02-21 74
原型模式核心就是，深拷贝和浅拷贝。 原型模式是创建模式中的一种，用于特点是通过一个已存在的实例复制一个新实例，而不是创建新实例（值类型用浅拷贝，而引用类型必须是深拷贝）。被复制的对象我们称作原型，这个原型是可定制的。 .net实现深拷贝 public class DeepCope { /// <summary> ...
C#对于任意对象进行深拷贝(DeepCopy)
butyesbutno的专栏
02-26 4275
说明： 本文使用VS2010，C# 对于任意对象，任意类型进行深拷贝 1. DeepCopyArray  由于Array自身提供的Copy仅仅是浅拷贝，要做到深拷贝，需要对Array中 每一个item进行深拷贝（DeepCopy）。 private static Array DeepCopyArray(Array srcArray) {
C#深拷贝效率对比
故里2130
12-17 971
本篇说一下，深拷贝的效率问题，效率一直是程序追求的，效率越高肯定越好，有时候功能是实现了，但是运行以及处理数据的效率非常低，此时就让人很头疼，当你知道了如何提高效率的时候，在你实现功能的时候，就已经考虑进去了，而不是先把功能做好，后期再优化（当然这种模式覆盖大部分人的开发习惯）。总结：总的来说，数据量在100W的时候，差距还是很明显的，建议使用表达式树，在10W数量的时候，表达式树和AutoMapper差距已经不是很大了，数据量再小的话，预计差别就更少了，具体使用，还是看程序的数据在什么量级。
浅谈C#中List<T>对象的深度拷贝问题
08-31
在C#编程中，深度拷贝是一个重要的概念，尤其是在处理复杂数据结构时。深度拷贝是指创建一个新对象，不仅复制原始对象的属性，还复制了嵌套对象的引用，确保新旧对象之间的独立性。本文将探讨C#中List对象的深度拷贝...
浅谈C#中ListT对象的深度拷贝问题
12-25
一、List对象中的T是值类型的情况（int 类型等） 对于值类型的List直接用以下方法就可以复制： List<T> oldList = new List(); oldList.Add(..); List<T> newList = new List(oldList); 二、List对象中的T是引用...
C# Lambda快速深度拷贝
06-19
今天上班在班车上和一个同事讨论有关C#拷贝效率的问题，聊到了多种深度拷贝方法，其中就提到了一种Lambda表达式拷贝的方法，这位同事说这种深度拷贝快是快但是如果对象里面再嵌入对象就不能深度拷贝了，只进行浅拷贝...
C#深度拷贝克隆源码
10-19
在编程领域，特别是使用.NET框架的C#语言中，"深度拷贝"是一个重要的概念，主要涉及对象复制。本文将详细解析"深度拷贝"的概念、实现方式以及如何在C#中实现一个自定义类的深度拷贝。 深度拷贝是指创建一个新对象，...
克隆的艺术：C#对象深度复制全解析，浅拷贝与深拷贝的终极对决
java专栏
06-02 783
浅拷贝仅复制对象的顶层结构，不复制对象内部的引用类型的值，可能导致两个对象共享同一份数据。深拷贝不仅复制对象本身，还会递归复制其所有嵌套的对象，确保新旧对象完全独立。手动实现深拷贝适合对象结构简单的情况，复杂结构时容易出错且维护困难。序列化与反序列化是一种灵活且通用的深拷贝方法，但性能开销相对较大，且在不同.NET版本中有不同的推荐序列化工具。理解并正确应用克隆技术对管理对象状态和避免不必要的副作用至关重要。希望以上示例能帮助你掌握C#中的对象克隆技巧。
深复制，浅复制区别c#代码
03-20
c#的代码写的深复制，浅复制区别，用一段小代码说明他们之间的区别，虽然不是很详尽，但是希望对大家有帮助
C#深拷贝 C#深拷贝
04-08
C#深拷贝；C#深拷贝；C#深拷贝；C#深拷贝；C#深拷贝；C#深拷贝；
C#复制和深度复制的实现方法
08-31
下面小编就为大家带来一篇C#复制和深度复制的实现方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
C# 快速高效率复制对象（表达式树）
08-30
在代码中经常会遇到需要把对象复制一遍，或者把属性名相同的值复制一遍。本文将对其解决方法进行详细介绍。下面跟着小编一起来看下吧
在C#中，如何用最装逼的代码和最快的速度拷贝数组？
A_nanda的博客
01-10 447
C# 里多维数组拷贝有没有什么比较优雅的写法？首先介绍一下c#数据写法：C# 里的多维数组 (Multi-dimensional Array) 是这样的 byte[,] arr = new byte[10, 10];下面这种写法是交错数组 (Jagged Array)，就是数组里面套着数组 byte[][] arr = new byte[10][];接下来介绍几种拷贝数组的方法，然后再比较一下不同实现的性能定义一下常量，SIZE表示数组大小，COUNT表示等会要做拷贝测试的循环次数。
字典的深拷贝与浅拷贝
weixin_30867015的博客
09-17 384
以前只知道用dict2 = dict1 来进行复制（备份），结果发现对dict2做增删改等操作时，dict1也会随之变化，反过来也这样。没有好好学习基础的我，自然在这里面吃了不少的亏。。。 下面我们来介绍一下python的深拷贝与浅拷贝： 1 #!/usr/bin/python 2 # -*- coding: UTF-8 -*- 3 4 dict1 = {'...
C#对象深拷贝
fucun1984686003的专栏
08-10 678
public static T DeepCopy(this T obj) { //如果是字符串或值类型则直接返回 if (obj is string || obj.GetType().IsValueType) return obj; object retval = Activator.CreateInstance(obj.GetType()); FieldInfo[] fiel
C# 最简单的深拷贝写法
weixin_37778355的博客
04-27 414
只反射了对象下的第一层属性，没有写递归，如果有简单的自定义类需要深拷贝，可以迅速拿来用。 public static T DeepCopy<T>(T obj) { object retval = Activator.CreateInstance(obj.GetType()); FieldInfo[] fields = obj.GetType().GetFields(BindingFlags.Public | BindingFlags
C# list深度拷贝
06-07
在 C# 中，可以使用以下方法来实现 List 的深度拷贝： 1.使用 Linq： ```csharp List<T> newList = originalList.Select(item => (T)item.Clone()).ToList(); ``` 这种方法假定 T 实现了 ICloneable 接口，并且 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值