c#中实现拷贝对象的案例

C#对象的浅拷贝，深拷贝
C#中有两种类型变量，一种 是值类型变量，一种是引用类型变量,对于值类型变量，深拷贝和前拷贝都是通过赋值操作符号(=)实现，其效果一致，将对象中的值类型的字段拷贝到新的对象中.这个很容易理解。 本文重点讨论引用类型变量的拷贝机制和实现。
　　C#中引用类型对象的copy操作有两种：
　　浅拷贝(影子克隆/shallow copy):只复制对象的值类型字段,对象的引用类型,仍属于原来的引用. 深拷贝(深度克隆):不仅复制对象的值类型字段,同时也复制原对象中的对象.就是说完全是新对象产生的.
　　浅拷贝和深拷贝之间的区别：浅拷贝是指将对象中的数值类型的字段拷贝到新的对象中，而对象中的引用型字段则指复制它的一个引用到目标对象。
　　注意：string类型有点特殊，对于浅拷贝，类值类型对象进行处理。
　　浅拷贝的实现
　　使用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; } }

 赋值操作(=)VS使用Object类MemberwiseClone实现

对于引用类型的变量，我们有种误解，认为赋值操作就是浅拷贝一种，其实不然，两者有区别。
　　浅拷贝(shallow copy)对于引用类型对象中的值类型字段进行了逐位复制。赋值运算符只是把源对象的引用赋值给目的对象，两者引用同一个对象。 浅拷贝后的对象的值类型字段更改不会反映到源对象，而赋值运算后的对象的值类型字段更改会反映到源对象 代码实现如下：

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#中，我们们有三种方法实现深拷贝
　　实现ICloneable接口，自定义拷贝功能。
　　ICloneable 接口，支持克隆，即用与现有实例相同的值创建类的新实例。
　　ICloneable 接口包含一个成员 Clone，它用于支持除 MemberwiseClone 所提供的克隆之外的克隆。Clone 既可作为深层副本实现，也可作为浅表副本实现。在深层副本中，所有的对象都是重复的;而在浅表副本中，只有顶级对象是重复的，并且顶级以下的对象包含引用。 结果克隆必须与原始实例具有相同的类型或是原始实例的兼容类型。
　　代码实现如下：

Code 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方法,这是个简单的类,试想一下,如果你的类有成千上万个引用类型成员(当然太夸张,几十个还是有的)，这是不是份很恐怖的劳力活?
　　序列化/反序列化类实现
　　不知道你有没有注意到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]。
　　通过反射实现
　　通过序列化/反序列化方式我们能比较流畅的实现深拷贝，但是涉及到IO操作，托管的的环境中，IO操作比较消耗资源。 能不能有更优雅的解决方案。CreateInstance，对，利用反射特性。这个方法大家可以参考这篇博客：http://rubenhak.com/?p=70 文章反射类的Attribute，利用Activator.CreateInstance New一个类出来(有点像DataSet.Clone先获得架构)，然后利用PropertyInfo的SetValue和GetValue方法，遍历的方式进行值填充。
　　代码实现如下：

public class Person { private List _friends = new List(); public string Firstname { get; set; } public string Lastname { get; set; } [Cloneable(CloneableState.Exclude)] [Cloneable(CloneableState.Include, “Friends”)] public List Friends { get { return _friends; } } [Cloneable(CloneableState.Exclude)] public PersonManager Manager { get; set; } }
在我们工作中经常会用到对象复制的情况，比如 A对象为原有对象，把A对象赋值给B对象，记录原有数据，然后对A对象开始操作改变值，接着想知道 A都改变了那些值
都会先这样写：

A a = new A();
a.ID = 10;
a.Name = “jacky”;

A b = a;

a.ID = 11;
a.Name = “zhuovi”;
然后 结果并不是我们想要的，a b 两对象的值都被改变了。
有两种对象克隆的方法：浅拷贝和深拷贝。浅拷贝只是复制引用，而不会复制引用的对象。深拷贝会复制引用的对象。
原始对象中的引用和浅拷贝对象中的同一个引用都指向同一个对象。而深拷贝的对象包含了对象的一切直接或间接的引用。
下边给出我经常用的两种方法
1.MemberWiseClone
MemberWiseClone是Object类的受保护方法，能够通过创建一个新对象，并把所有当前对象中的非静态域复制到新对象中，从而创建一 个浅拷贝。对于值类型的域，进行的是按位拷贝。对于引用类型的域，引用会被赋值而引用的对象则不会。因此，原始对象及其克隆都会引用同一个对象。注意，这种方法对派生类都是有效的，也就是说，你只需在基类中定义一次Clone方法。下面是一个简单的例子：

public class A{
public int ID{get;set;}
public string Name{get;set;}
public A Clone(){
return this.MemberWiseClone() as A;
}
}
2.用反射进行克隆
直接上代码

System.Reflection.PropertyInfo[] pA = A.GetType().GetProperties();
System.Reflection.PropertyInfo[] pB = A.GetType().GetProperties();
for (int i = 0; i < pA.Length; i++)
{
if(pB[i].CanWrite)
pB[i].SetValue(this, pA[i].GetValue(A, null));
}
当前了 还有一种 就是手动赋值 这个就不在这里说了 大家都知道

大家都知道，在C#中变量的存储分为值类型和引用类型两种，而值类型和引用类型在数值变化是产生的后果是不一样的，值类型我们可以轻松实现数值的拷贝，那么引用类型呢，在对象拷贝上存在着一定的难度。
下面我么从一个经典的例子谈起。
private void doChange(string a)
{
int b = a;
b = “2”;
System.Console.WriteLine(b);
System.Console.WriteLine(a);
}
当我么调用上面的函数doChange(“1”)以后，输出的结果是多少呢？很多大哥开到我提问这个问题，一定气得要骂街了，呵呵，很简单，输出结果是：
2
1
那么我们再看看下面的一个例子
public class data
{
pubic string key =“1”
}
private void doChange( data a)
{
data b = a;
b.key = “2”;
System.Console.WriteLine(b.key.ToString());
System.Console.WriteLine(a.key.ToString());
}
我们再次调用doChange(new data)，它的输出结果又是怎么样的呢？
有些人说：
2
1
如果你也是这么想的，那你就错了，呵呵！正确结果是……
2
2
为什么会是这样呢？很多人一定很奇怪，之所以会出现这样的问题，就和值类型和引用类型有关，第一个值函数的 string 本身是个值类型，他在存储的时候，是直接开辟了一个存储空间，而第二个data类型的在存储的时候，其实是通过指针将变量和其存储空间链接在了一起，当声明data b=a时，就将b的指针指向了a的指针所指向的存储位置，而当将b.key=“2"赋值后，其实是将b.key所指向的存储空间赋值"2”，这个时候因为a和b的指针是指向同一个存储空间的，所以a.key和b.key的值同时变成了2。
那么问题出现了，怎么才能使b和a不同时改变呢？有人会告诉我，你可以这样写呀！
private void doChange(data a)
{
data b = new data();
b = a;
b.key = “2”;
System.Console.WriteLine(b.key.ToString());
System.Console.WriteLine(a.key.ToString());
}
正样，在new的时候，系统会为a和b开辟不同的两个存储空间，这样就不会出现上面的问题了。其实并不是这样的，当你new的时候，确实a和b是有不同的存储位置的，可以当你b=a的时候，其实又是将b的指针指向了a的存储位置上，而将b的存储位置进行了空闲，过不了多久，C#的垃圾回收机制会将b的存储空间进行回收。
这下岂不坏了，当我么使用一个复杂的对象时候，怎么才能够使一个对象等于另一个对象，而在其中一个对象的属性值改变后，另一个对象的属性不会跟着改变呢？
在C#中，有写系统对象提供了克隆方法，但是，对于用户自定义的对象是不存在这个方法的，我们要想实现克隆操作，必须手动去便利每一个属性，然后对属性进行赋值，也就是下面的方法。
private void doChange(data a)
{
data b = new data();
b.key = a.key;
b.key =“2”;
System.Console.WriteLine(b.key.ToString());
System.Console.WriteLine(a.key.ToString());
}
这样对于属性很少的对象操作起来还算可以，但是对于属性很多的对象操作起来却相当麻烦，所以可以采用反射的机制，对每一个属性进行赋值，具体代码如下。
public static void CopyValue(object origin,object target)
{
System.Reflection.PropertyInfo[] properties = (target.GetType()).GetProperties();
System.Reflection.FieldInfo[] fields = (origin.GetType()).GetFields();
for ( int i=0; i< fields.Length; i++)
{
for ( int j=0; j< properties.Length; j++)
{
if (fields[i].Name == properties[j].Name && properties[j].CanWrite)
{
properties[j].SetValue(target,fields[i].GetValue(origin),null);
}
}
}
}
哈哈，到此为止，问题终于解决了。