代码改变世界

正确实现浅拷贝和深拷贝

2012-03-24 10:16  starlet  阅读(194)  评论(0)    收藏  举报

为对象创建副本的技术称为拷贝（也叫克隆）。我们将拷贝分为浅拷贝和深拷贝。

浅拷贝 将对象中的所有字段复制到新的对象（副本）中。其中，值类型字段的值被复制到副本中后，在副本中的修改不会影响到源对象对应的值。而引用类型的字段被复制到副本中的是引用类型的引用，而不是引用的对象，在副本中对引用类型的字段值做修改会影响到源对象本身。

深拷贝 同样，将对象中的所有字段复制到新的对象中。不过，无论是对象的值类型字段，还是引用类型字段，都会被重新创建并赋值，对于副本的修改，不会影响到源对象本身。

无论是浅拷贝还是深拷贝，微软都建议用类型继承ICloneable接口的方式明确告诉调用者：该类型可以被拷贝。当然，ICloneable接口只提供了一个声明为Clone的方法，我们可以根据需求在Clone方法内实现浅拷贝或深拷贝。一个简单的浅拷贝的实现代码如下所示：

  1. class Employee : ICloneable  
  2. {  
  3.     public string IDCode { get; set; }  
  4.     public int Age { get; set; }  
  5.     public Department Department { get; set; }  
  6.  
  7.     #region ICloneable 成员  
  8.  
  9.     public object Clone()  
  10.     {  
  11.         return this.MemberwiseClone();  
  12.     }  
  13.  
  14.     #endregion  
  15. }  
  16.  
  17. class Department  
  18. {  
  19.     public string Name { get; set; }  
  20.     public override string ToString()  
  21.     {  
  22.         return this.Name;  
  23.     }  
  24. }

调用方代码如下所示：

  1. Employee mike = new Employee() { IDCode = "NB123", Age = 30,  
  2.     Department = new Department() { Name = "Dep1" } };  
  3. Employee rose = mike.Clone() as Employee;  
  4. Console.WriteLine(rose.IDCode);  
  5. Console.WriteLine(rose.Age);  
  6. Console.WriteLine(rose.Department);  
  7. Console.WriteLine("开始改变mike的值：");  
  8. mike.IDCode = "NB456";  
  9. mike.Age = 60;  
  10. mike.Department.Name = "Dep2";  
  11. Console.WriteLine(rose.IDCode);  
  12. Console.WriteLine(rose.Age);  
  13. Console.WriteLine(rose.Department);

输出为：

  1. NB123  
  2. 30  
  3. Dep1

开始改变mike的值：

  1. NB123  
  2. 30  
  3. Dep2

注意到Employee的IDCode属性是string类型。理论上string类型是引用类型，但是由于该引用类型的特殊性（无论是实现还是语义），Object.MemberwiseClone方法仍旧为其创建了副本。也就是说，在浅拷贝过程，我们应该将字符串看成是值类型。 Employee的Department属性是一个引用类型，所以，如果改变了源对象mike中的值，副本rose中的值也会随之一起变动。 Employee的深拷贝有多种实现方法，最简单的方法是手动对字段逐个进行赋值。但这种方法容易出错，也就是说，如果类型的字段发生变化或有增减，那么该拷贝方法也要发生相应的变化，所以，建议使用序列化的形式来进行深拷贝。Employee深拷贝的一个简单实现代码如下所示： 

  1. class Employee : ICloneable  
  2. {  
  3.     public string IDCode { get; set; }  
  4.     public int Age { get; set; }  
  5.     public Department Department { get; set; }  
  6.  
  7.     #region ICloneable 成员  
  8.  
  9.     public object Clone()  
  10.     {  
  11.         using (Stream objectStream = new MemoryStream())  
  12.         {  
  13.             IFormatter formatter = new BinaryFormatter();  
  14.             formatter.Serialize(objectStream, this);  
  15.             objectStream.Seek(0, SeekOrigin.Begin);  
  16.             return formatter.Deserialize(objectStream) as Employee;  
  17.         }  
  18.     }  
  19.     #endregion  
  20. }

使用浅拷贝中的调用者代码，输出为：

  1. NB123  
  2. 30  
  3. Dep1

开始改变mike的值：

  1. NB123  
  2. 30  
  3. Dep1

可以发现，再次更改mike的值已经不会影响副本rose的值了。 由于接口ICloneable只有一个模棱两可的Clone方法，所以，如果要在一个类中同时实现深拷贝和浅拷贝，只能由我们自己实现两个额外的方法，声明为DeepClone和Shallow。Employee的最终版本看起来应该像如下的形式：

  1. [Serializable]
  2. class Employee : ICloneable
  3. {
  4. public string IDCode { get; set; }
  5. public int Age { get; set; }
  6. public Department Department { get; set; }
  8. #region ICloneable 成员
  10. public object Clone()
  11. {
  12. return this.MemberwiseClone();
  13. }
  15. #endregion
  17. public Employee DeepClone()
  18. {
  19. using (Stream objectStream = new MemoryStream())
  20. {
  21. IFormatter formatter = new BinaryFormatter();
  22. formatter.Serialize(objectStream, this);
  23. objectStream.Seek(0, SeekOrigin.Begin);
  24. return formatter.Deserialize(objectStream) as Employee;
  25. }
  26. }
  28. public Employee ShallowClone()
  29. {
  30. return Clone() as Employee;
  31. }
  32. }

转自：编写高质量代码：改善C#程序的157个建议 建议14： 正确实现浅拷贝和深拷贝  陆敏技