浅拷贝和深拷贝深入理解(shallow copy VS deep copy)

引言
c#中有两种类型变量，一种 是值类型变量，一种是引用类型变量,对于值类型变量，深拷贝和前拷贝都是通过赋值操作符号(=)实现，其效果一致，将对象中的值类型的字段拷贝到新的对象中.这个很容易理解。 本文重点讨论引用类型变量的拷贝机制和实现。

c#中引用类型对象的copy操作有两种：

•浅拷贝(影子克隆/shallow copy):只复制对象的值类型字段,对象的引用类型,仍属于原来的引用.
•深拷贝(深度克隆):不仅复制对象的值类型字段,同时也复制原对象中的对象.就是说完全是新对象产生的.

浅拷贝和深拷贝之间的区别：浅拷贝是指将对象中的数值类型的字段拷贝到新的对象中，而对象中的引用型字段则指复制它的一个引用到目标对象。

注意：string类型有点特殊，对于浅拷贝，类值类型对象进行处理。

浅拷贝的实现
1.使用object类memberwiseclone实现
memberwiseclone:创建当前 object 的浅表副本。
memberwiseclone 方法创建一个浅表副本，方法是创建一个新对象，然后将当前对象的非静态字段复制到该新对象。如果字段是值类型的，则对该字段执行逐位复制。如果字段是引用类型，则复制引用但不复制引用的对象；因此，原始对象及其复本引用同一对象。

代码实现如下：

public class person
    {
        public int age { get; set; }
        public string address { get; set; }
        public name name { get; set; }

        public object clone()
        {
           return   this.memberwiseclone();   
        }

       
    }

    public class name
    {
        public name(string frisname,string lastname)
        {
            fristname = frisname;
            lastname = lastname;
        }
        public string fristname { get; set; }
        public string lastname { get; set; }
    }

2.赋值操作(=)vs使用object类memberwiseclone实现
对于引用类型的变量，我们有种误解，认为赋值操作就是浅拷贝一种，其实不然，两者有区别。

1.浅拷贝(shallow copy)对于引用类型对象中的值类型字段进行了逐位复制。赋值运算符只是把源对象的引用赋值给目的对象，两者引用同一个对象。

2.浅拷贝后的对象的值类型字段更改不会反映到源对象，而赋值运算后的对象的值类型字段更改会反映到源对象

代码实现如下：

public class person
    {
        public int age { get; set; }
        public string address { get; set; }
        public name name { get; set; }
    }

    public class name
    {
        public name(string frisname,string lastname)
        {
            fristname = frisname;
            lastname = lastname;
        }
        public string fristname { get; set; }
        public string lastname { get; set; }
    }

深拷贝实现
相对于浅拷贝,是指依照源对象为原型，创建一个新对象，将当前对象的所有字段进行执行逐位复制并支持递归，不管是是值类型还是引用类型，不管是静态字段还是非静态字段。
在c#中，我们们有三种方法实现深拷贝

1.实现icloneable接口，自定义拷贝功能。

icloneable 接口，支持克隆，即用与现有实例相同的值创建类的新实例。

icloneable 接口包含一个成员 clone，它用于支持除 memberwiseclone 所提供的克隆之外的克隆。clone 既可作为深层副本实现，也可作为浅表副本实现。在深层副本中，所有的对象都是重复的；而在浅表副本中，只有*对象是重复的，并且*以下的对象包含引用。 结果克隆必须与原始实例具有相同的类型或是原始实例的兼容类型。

代码实现如下：

 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;
        }
    }

    public class name
    {
        public name(string frisname, string lastname)
        {
            fristname = frisname;
            lastname = lastname;
        }
        public string fristname { get; set; }
        public string lastname { get; set; }
    }

大家可以看到,person类继承了接口icloneable并手动实现了其clone方法,这是个简单的类,试想一下,如果你的类有成千上万个引用类型成员(当然太夸张,几十个还是有的)，这是不是份很恐怖的劳力活？

2.序列化/反序列化类实现

不知道你有没有注意到dataset对象,对于他提供的两个方法:

dataset.clone 方法，复制 dataset 的结构，包括所有 datatable 架构、关系和约束。不要复制任何数据。

新 dataset，其架构与当前 dataset 的架构相同，但是不包含任何数据。注意 如果已创建这些类的子类，则复本也将属于相同的子类。

dataset.copy 方法复制该 dataset 的结构和数据.

新的 dataset，具有与该 dataset 相同的结构（表架构、关系和约束）和数据。注意如果已创建这些类的子类，则副本也将属于相同的子类。

好像既不是浅拷贝,又不是深拷贝，是不是很失望？但是两个结合起来不是我们要的深拷贝吗？看看dataset的实现，注意序列化接口：iserializable

序列化是将对象或对象图形转换为线性字节序列，以存储或传输到另一个位置的过程。反序列化是接受存储的信息并利用它重新创建对象的过程。

通过 iserializable 接口，类可以执行其自己的序列化行为。

转换为线性字节序列后并利用其重新创建对象的过程是不是和我们的深拷贝的语意“逐位复制”很相像？

代码实现如下：

[serializable]
    public class person : icloneable
    {
        public int age { get; set; }
        public string address { get; set; }
        public name name { get; set; }

        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]
    public class name
    {
        public name(string frisname, string lastname)
        {
            fristname = frisname;
            lastname = lastname;
        }
        public string fristname { get; set; }
        public string lastname { get; set; }
    }

}

注意：通过序列化和反序列化实现深拷贝，其和其字段类型必须标记为可序列化类型，既添加特性(attribute)[serializable]。

3.通过反射实现
通过序列化/反序列化方式我们能比较流畅的实现深拷贝，但是涉及到io操作，托管的的环境中，io操作比较消耗资源。 能不能有更优雅的解决方案。createinstance，对，利用反射特性。这个方法大家可以参考这篇博客：http://rubenhak.com/?p=70 文章反射类的attribute，利用activator.createinstance new一个类出来(有点像dataset.clone先获得架构)，然后利用propertyinfo的setvalue和getvalue方法，遍历的方式进行值填充。

代码实现如下：

public class person
{
    private list<person> _friends = new list<person>();

    public string firstname { get; set; }
    public string lastname { get; set; }

    [cloneable(cloneablestate.exclude)]
    [cloneable(cloneablestate.include, "friends")]
    public list<person> friends { get { return _friends; } }

    [cloneable(cloneablestate.exclude)]
    public personmanager manager { get; set; }
}

c#为什么要设计深拷贝和浅拷贝？
这个我也一直也找不到一个合适的答案，希望有人来讨论下！点击下载代码