C#系列——记一次业务需求：对象的深拷贝

　　这篇随笔着实在意料之外，主要是源于上周开发BS的一个业务，需要用到对象的深拷贝。说的直白一点，就是将对象内存分配区和引用完全拷贝一份新的。这种需求以前就遇到过，怎么解决的已经记不清了。这次趁着这个机会将对象的深拷贝这个知识点记录下。

　　先来说说业务场景，直接上代码：

　　　　　　　//0.反射得到工厂属性
            var lstRes = new List<List<DragElementProp>>();
            var oType = typeof(Ewin.CommonLib.DtoModel.DTO_TM_PLANT);
            var lstAttr = ReflectorAttribute(oType);

            //1.给每个工厂对象的属性赋值，构造前台需要的数据结构
            var lstPropModel = oType.GetProperties();
            foreach (var oModel in lstModel)
            {
                var lstResTmp = new List<DragElementProp>();
                foreach (var oAttr in lstAttr)
                {
                    var oPropModel = lstPropModel.FirstOrDefault(x => x.Name == oAttr.Name);
                    if (oPropModel == null)
                    {
                        continue;
                    }
                    oAttr.Value = oPropModel.GetValue(oModel);
　　　　　　　　　　　 lstResTmp.Add(oAttr);
                }
                lstRes.Add(lstResTmp);
            }

需求就是lstAttr变量保存的是一个List<DragElementProp>类型的集合，需要遍历lstModel，需要将每一个的oModel的Name属性的值赋给lstAttr实例的Value属性。然后保存多个lstAttr的集合，形如List<List<DragElementProp>>。通过上面的代码在foreach (var oModel in lstModel)里面每次new一个新的var lstResTmp = new List<DragElementProp>();来保存赋值后lstAttr，明眼人一看就知道这种方式肯定不行，因为C#里面class是引用类型，每次改变的都是唯一的一个lstAttr实例，通过上面代码的方式得到的lstRes肯定会是几个相同的lstAttr，即最后一次赋值的lstAttr。

　　怎么办？各种百度、各种博客园。查了多篇博文，发现答案千篇一律，深拷贝对象的三种解决方案：

• 实现ICloneable接口，自定义拷贝功能
• 序列化/反序列化类实现
• 通过反射实现

我们逐一看看这几种方式

（1）实现ICloneable接口的方式，贴上园子里面的代码

public class Person:ICloneable 
{ 
　　　　public int Age { get; set; } 
　　　　public string Address { get; set; } 
　　　　public Name Name { get; set; } 
　　　　public object Clone() 
　　　　{ 
　　　　　　Person tem = new Person(); 
　　　　　　tem.Address = this.Address; 
　　　　　　tem.Age = this.Age; 
　　　　　　tem.Name = new Name(this.Name.FristName, this.Name.LastName); 
　　　　　　return tem; 
　　　　} 
} 

很显然，这种方式不可取。如果一个类里面有多个其他类成员，那不是每个都要去定义这样一个clone方法。太low。

（2）序列化反序列化方式。贴上园子里面的代码

[Serializable] 
public class Person : ICloneable 
{ 
　　public object Clone() 
　　{ 
　　　　using (MemoryStream ms = new MemoryStream(1000)) 
　　　　{ 
　　　　　　object CloneObject; 
　　　　　　BinaryFormatter bf = new BinaryFormatter(null, new StreamingContext(StreamingContextStates.Clone)); 
　　　　　　bf.Serialize(ms, this); 
　　　　　　ms.Seek(0, SeekOrigin.Begin); 
　　　　　　// 反序列化至另一个对象(即创建了一个原对象的深表副本) 
　　　　　　CloneObject = bf.Deserialize(ms); 
　　　　　　// 关闭流 
　　　　　　ms.Close(); 
　　　　　　return CloneObject; 
　　　　} 
　　} 
}

这种方式比上面方式好一点，但是需要对象是可序列化的，即要加上[Serializable]特性标签，博主试过如果一个普通的类调用这个方法会报异常。

博主用Newtonsoft.Json重新写了个：

　　　　　　　foreach (var oModel in lstModel)
            {
                var lstResTmp = new List<DragElementProp>();
                foreach (var oAttr in lstAttr)
                {
                    var oPropModel = lstPropModel.FirstOrDefault(x => x.Name == oAttr.Name);
                    if (oPropModel == null)
                    {
                        continue;
                    }
                    oAttr.Value = oPropModel.GetValue(oModel);
                }
                //深拷贝一个集合到另一个集合
                var oJsonValue = Newtonsoft.Json.JsonConvert.SerializeObject(lstAttr);
                lstResTmp.AddRange(Newtonsoft.Json.JsonConvert.DeserializeObject<List<DragElementProp>>(oJsonValue));
                lstRes.Add(lstResTmp);
            }

这种方式对对象没什么太特殊的要求。

（3）反射的方式，博主自己简单写了一个：

　　　　 public static T CloneModel<T>(T oModel)
        {
            var oRes = default(T);
            var oType = typeof(T);

            //得到新的对象对象
            oRes = (T)Activator.CreateInstance(oType);

            //给新的对象复制
            var lstPro = oType.GetProperties();
            foreach (var oPro in lstPro)
            {
                //从旧对象里面取值
                var oValue = oPro.GetValue(oModel);

                //复制给新的对象
                oPro.SetValue(oRes, oValue);
            }

            return oRes;
        }

这种方式也比较简单，但考虑到反射得性能问题，而且如果是clone集合，需要遍历去反射这样效率就更低。

　　综上所述：要深拷贝一个对象，其实上述无论哪种方式都是新产生一个对象，然后给新的对象依次赋值来实现。方案一一般不可取，方案二在集合的序列化方便可能效率稍微高点，方案三如果只是简单的拷贝一个对象我觉得也是不错的选择。反正博主更加偏好方案二，用起来简单。

　　

　　反正找了好久说的都这三种方式，这次先记录下，如果没有更好的方式就用这些方案先解决吧，当然，如果以后知道了更好的方式也可以拿出来和大家分享。也不知道.Net是否预留了某些特殊的通道来处理这种深拷贝。希望知道的大侠多多指教~~