浅析C#深拷贝与浅拷贝

from： http://blog.csdn.net/lai123wei/article/details/7217365

 

 

1.深拷贝与浅拷贝

  拷贝即是通常所说的复制(Copy)或克隆(Clone)，对象的拷贝也就是从现有对象复制一个“一模一样”的新对象出来。虽然都是复制对象，但是不同的 复制方法，复制出来的新对象却并非完全一模一样，对象内部存在着一些差异。通常的拷贝方法有两种，即深拷贝和浅拷贝，那二者之间有何区别呢？MSDN里对 IClone接口的Clone方法有这样的说明：在深层副本中，所有的对象都是重复的；而在浅表副本中，只有顶级对象是重复的，并且顶级以下的对象包含引 用。可以看出，深拷贝和浅拷贝之间的 区别在于是否复制了子对象。这如何理解呢？下面我通过带有子对象的代码来验证二者的区别。

首先定义两个类型：Student和ClassRoom，其中Student类型里包含ClassRoom，并使这两个类型都分别实现自定义的深拷贝接口(IDeepCopy)和浅拷贝接口(IShallowCopy)。

类图如下：

定义代码如下：

 

View Code

///   <summary>
     ///  深拷贝接口
     ///   </summary>
     interface IDeepCopy
    {
         object DeepCopy();
    }

     ///   <summary>
     ///  浅拷贝接口
     ///   </summary>
     interface IShallowCopy
    {
         object ShallowCopy();
    }

     ///   <summary>
     ///  教室信息
     ///   </summary>
     class ClassRoom : IDeepCopy, IShallowCopy
    {
         public  int RoomID =  1;
         public  string RoomName =  " Room1 ";

         public  override  string ToString()
        {
             return  " RoomID= " + RoomID +  " \tRoomName= " + RoomName;
        }
         public  object DeepCopy()
        {
            ClassRoom r =  new ClassRoom();
            r.RoomID =  this.RoomID;
            r.RoomName =  this.RoomName;
             return r;
        }
         public  object ShallowCopy()
        {
             // 直接使用内置的浅拷贝方法返回
             return  this.MemberwiseClone();
        }
    }

     class Student : IDeepCopy, IShallowCopy
    {
         // 为了简化，使用public 字段
         public  string Name;
         public  int Age;
         // 自定义类型，假设每个Student只拥有一个ClassRoom
         public ClassRoom Room =  new ClassRoom();

         public Student()
        {
        }
         public Student( string name,  int age)
        {
             this.Name = name;
             this.Age = age;
        }
         public  object DeepCopy()
        {
            Student s =  new Student();
            s.Name =  this.Name;
            s.Age =  this.Age;
            s.Room = (ClassRoom) this.Room.DeepCopy();
             return s;
        }
         public  object ShallowCopy()
        {
             return  this.MemberwiseClone();
        }

         public  override  string ToString()
        {
             return  " Name: " + Name +  " \tAge: " + Age +  " \t " + Room.ToString();
        }

    }

pasting

pasting

测试代码：

 

View Code

Student s1 =  new Student( " Vivi ",  28); 
Console.WriteLine( " s1=[ " + s1 +  " ] "); 
Student s2 = (Student)s1.ShallowCopy(); 
// Student s2 = (Student)s1.DeepCopy(); 
Console.WriteLine( " s2=[ " + s2 +  " ] ");  // 此处s2和s1内容相同 
Console.WriteLine( " ----------------------------- "); 
// 修改s2的内容 
s2.Name =  " tianyue "; 
s2.Age =  25; 
s2.Room.RoomID =  2; 
s2.Room.RoomName =  " Room2 "; 
Console.WriteLine( " s1=[ " + s1 +  " ] "); 
Console.WriteLine( " s2=[ " + s2 +  " ] "); 
// 再次打印两个对象以比较 
Console.ReadLine();

 

运行结果：

a.ShallowCopy

s1=[Name:Vivi   Age:28  RoomID=1        RoomName=Room1]
s2=[Name:Vivi   Age:28  RoomID=1        RoomName=Room1]
-------------------------------------------------------------

s1=[Name:Vivi   Age:28  RoomID=2        RoomName=Room2]
s2=[Name:tianyue        Age:25  RoomID=2        RoomName=Room2]

b.DeepCopy

s1=[Name:Vivi   Age:28  RoomID=1        RoomName=Room1]
s2=[Name:Vivi   Age:28  RoomID=1        RoomName=Room1]
-----------------------------
s1=[Name:Vivi   Age:28  RoomID=1        RoomName=Room1]
s2=[Name:tianyue        Age:25  RoomID=2        RoomName=Room2]

从以上结果可以看出，深拷贝时两个对象是完全“分离”的，改变其中一个，不会影响到另一个对象；

浅拷贝时两个对象并未完全“分离”，改变顶级对象的内容，不会对另一个对象产生影响，但改变子对象的内容，则两个对象同时被改变。

这种差异的产生，即是取决于拷贝子对象时复制内存还是复制指针。深拷贝为子对象重新分配了一段内存空间，并复制其中的内容；

浅拷贝仅仅将指针指向原来的子对象。

示意图如下：

2.浅拷贝与赋值操作

大多数面向对象语言中的赋值操作都是传递引用，即改变对象的指针地址，而并没有复制内存，也没有做任何复制操作。

由此可知，浅拷贝与赋值操作的区别是 顶级对象的复制与否。当然，也有一些例外情况，比如类型定义中重载赋值操作符（assignment operator），

或者某些类型约定按值传递，就像C＃中的结构体和枚举类型。

赋值操作示意图如下：

3.C++拷贝构造函数

与其它面向对象语言不同，C++允许用户选择自定义对象的传递方式：值传递和引用传递。在值传递时就要使用对象拷贝，比如说按值传递参数，编译 器需要拷贝一个对象以避免原对象在函数体内被破坏。为此，C++提供了拷贝构造函数用来实现这种拷贝行为，拷贝构造函数是一种特殊的构造函数，用来完成一 些基于同一类的其它对象的构造和初始化。它唯一的参数是引用类型的，而且不可改变，通常的定义为X(const X&)。在拷贝构造函数里，用户可以定义对象的拷贝行为是深拷贝还是浅拷贝，如果用户没有实现自己的拷贝构造函数，那么编译器会提供一个默认实 现，该实现使用的是按位拷贝(bitwise copy)，也即本文所说的浅拷贝。构造函数何时被调用呢？通常以下三种情况需要拷贝对象，此时拷贝构造函数将会被调用。
1.一个对象以值传递的方式传入函数体
2.一个对象以值传递的方式从函数返回
3.一个对象需要通过另外一个对象进行初始化

4.C# MemberwiseClone与ICloneable接口

和C++里的拷贝构造函数一样，C#也为每个对象提供了浅拷贝的默认实现，不过C#里没有拷贝构造函数，而是通过顶级类型Object里的 MemberwiseClone方法。MemberwiseClone 方法创建一个浅表副本，方法是创建一个新对象，然后将当前对象的非静态字段复制到该新对象。有没有默认的深拷贝实现呢？当然是没有，因为需要所有参与拷贝 的对象定义自己的深拷贝行为。C++里需要用户实现拷贝构造函数，重写默认的浅拷贝；C#则不同，C#(确切的说是.NET Framework，而非C#语言)提供了ICloneable 接口，包含一个成员 Clone，它用于支持除 MemberwiseClone 所提供的克隆之外的克隆。C++通过拷贝构造函数无法确定子对象实现的是深拷贝还是浅拷贝，而C#在“强制”实现浅拷贝的基础上，提供 ICloneable 接口由用户定义深拷贝行为，通过接口来强制约束所有参与拷贝的对象，个人觉得，这也算是一小点C#对C++的改进。

 

5.深拷贝策略与实现

深拷贝的要点就是确保所有参与拷贝的对象都要提供自己的深拷贝实现，不管是C++拷贝构造函数还是C#的ICloneable 接口，事实上都是一种拷贝的约定。有了事先的约定，才能约束实现上的统一，所以关键在于设计。

但偶尔也会在后期才想到要深拷贝，怎么办？总不能修改所有之前的实现吧。有没有办法能够通过顶级类而不关心内部的子对象直接进行深拷贝呢？能不 能搞个万能的深拷贝方法，在想用的时候立即用，而不考虑前期的设计。这样“大包大揽”的方法，难点在于实现时必须自动获取子对象的信息，分别为子对象实现 深拷贝。C++里比较困难，.NET的反射机制使得实现容易一些。不过这样的方法虽然通用，实则破坏了封装，也不符合“每个类对自己负责”的设计原则。

 

基于.NET的反射机制，以前写了一个通用的序列化方法，现在可以拿过来，先序列化，然后再反序列化回来，也即是一个深拷贝，示例代码如下：

深拷贝示例代码：

 

 

View Code

         #region ICloneable Members

         ///   <summary>
         ///  此处的复制为深拷贝，在实现上，为了简化，采用序列化和反序列化。
         ///   </summary>
         ///   <returns> 深拷贝对象 </returns>
         public  object Clone()
        {
            Student stu =  new Student();
            XmlStorageHelper helper =  new XmlStorageHelper();
             string strXml = helper.ConvertToString( this);
            helper.LoadFromString(stu, strXml);    // 从XML字符串来赋值

             return stu;
        }

         #endregion