C#进阶之路（三）：深拷贝和浅拷贝

一、前言

　　本文主要讨论深浅拷贝的区别，如果实现。浅拷贝日常的应用比较懂，这里不做深入讨论，那么深拷贝如何实现？目前我知道的方式有三种：反射，反序列化和表达树的方式。这里需要注意如果用反射来实现深拷贝的话，需要解决互相引用对象的问题。当然，反序列化就不存在这种问题了。

二、深拷贝 Vs 浅拷贝

首先，讲到深浅拷贝，自然就有一个问题来了？什么是深拷贝，什么又是浅拷贝呢？下面就具体介绍下它们的定义。

深拷贝：指的是拷贝一个对象时，不仅仅把对象的引用进行复制，还把该对象引用的值也一起拷贝。这样进行深拷贝后的拷贝对象就和源对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。举个例子，一个人叫张三，然后使用克隆技术以张三来克隆另外一个人叫李四，这样张三和李四就是相互独立的，不管张三缺胳膊还是李四少腿了都不会影响另外一个人。在.NET领域，值对象就是典型的例子，如int, Double以及结构体和枚举等。具体例子如下所示：

int source = 123;

// 值类型赋值内部执行深拷贝

int copy = source;

// 对拷贝对象进行赋值不会改变源对象的值

copy = 234;

// 同样对源对象赋值也不会改变拷贝对象的值

source = 345;

浅拷贝：指的是拷贝一个对象时，仅仅拷贝对象的引用进行拷贝，但是拷贝对象和源对象还是引用同一份实体。此时，其中一个对象的改变都会影响到另一个对象。例如，一个人一开始叫张三，后来改名字为张老三了，可是他们还是同一个人，不管张三缺胳膊还是张老三少腿，都反应在同一个人身上。在.NET中引用类型就是一个例子。如类类型。具体例子如下所示：

public class Person

{

    public string Name { get; set; }

}

class Program

{

    static void Main(string[] args)

    {

        Person sourceP = new Person() { Name = "张三" };

        Person copyP = sourceP; // 浅拷贝

        copyP.Name = "张老三"; // 拷贝对象改变Name值

        // 结果都是"张老三",因为实现的是浅拷贝，一个对象的改变都会影响到另一个对象

        Console.WriteLine("Person.Name: [SourceP: {0}] [CopyP:{1}]", sourceP.Name, copyP.Name);

        Console.Read();

    }

}

三、深拷贝的几种实现方式

这里浅拷贝的实现比较容易，所以就不做介绍了。主要讨论下实现深拷贝的方式

1、序列化实现深拷贝

我比较常用的方式是使用Newtonsoft的json。

T ss= JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(s));

当然还有很多其他的方式，比如下面

// 利用XML序列化和反序列化实现

public static T DeepCopyWithXmlSerializer<T>(T obj)

{

    object retval;

    using (MemoryStream ms = new MemoryStream())

    {

        XmlSerializer xml = new XmlSerializer(typeof(T));

        xml.Serialize(ms, obj);

        ms.Seek(, SeekOrigin.Begin);

        retval = xml.Deserialize(ms);

        ms.Close();

    }

    return (T)retval;

}

// 利用二进制序列化和反序列实现

public static T DeepCopyWithBinarySerialize<T>(T obj)

{

    object retval;

    using (MemoryStream ms = new MemoryStream())

    {

        BinaryFormatter bf = new BinaryFormatter();

        // 序列化成流

        bf.Serialize(ms, obj);

        ms.Seek(, SeekOrigin.Begin);

        // 反序列化成对象

        retval = bf.Deserialize(ms);

        ms.Close();

    }

    return (T)retval;

}

// 利用DataContractSerializer序列化和反序列化实现

public static T DeepCopy<T>(T obj)

{

    object retval;

    using (MemoryStream ms = new MemoryStream())

    {

        DataContractSerializer ser = new DataContractSerializer(typeof(T));

        ser.WriteObject(ms, obj);

        ms.Seek(, SeekOrigin.Begin);

        retval = ser.ReadObject(ms);

        ms.Close();

    }

    return (T)retval;

}

2、反射实现深拷贝

废话不多说，直接上代码

public static T DeepCopyWithReflection<T>(T obj)

{

    Type type = obj.GetType();

    // 如果是字符串或值类型则直接返回

    if (obj is string || type.IsValueType) return obj;

    if (type.IsArray)

    {

        Type elementType = Type.GetType(type.FullName.Replace("[]", string.Empty));

//把传入的obj转换成Array类型

        var array = obj as Array;

        Array copied = Array.CreateInstance(elementType, array.Length);

        for (int i = ; i < array.Length; i++)

        {

            copied.SetValue(DeepCopyWithReflection(array.GetValue(i)), i);

        }

        return (T)Convert.ChangeType(copied, obj.GetType());

    }

//获取返回值实例

    object retval = Activator.CreateInstance(obj.GetType());

//获取所有类型的属性

    PropertyInfo[] properties = obj.GetType().GetProperties(

        BindingFlags.Public | BindingFlags.NonPublic

        | BindingFlags.Instance | BindingFlags.Static);

//赋值

    foreach (var property in properties)

    {

        var propertyValue = property.GetValue(obj, null);

        if (propertyValue == null)

            continue;

        property.SetValue(retval, DeepCopyWithReflection(propertyValue), null);

    }

    return (T)retval;

}

上面反射的实现方式，对于相互引用的对象会出现StackOverflower的错误，由于对象的相互引用，会导致方法循环调用。至于如何解决，大家可以去找相关资料，这里我就不做过多介绍了。

3、表达式树实现深拷贝

这个会在后面的一篇专门介绍表达式树的文章里详细介绍。

巴特西