从上面的概念我们了解了C#深拷贝与浅拷贝(Deep Copy and Shallow Copy)的不同之处。这个也就决定了两者有不同的实现方式。

对于值类型：
    a.浅拷贝： 通过赋值等操作直接实现，将对象中的值类型的字段拷贝到新的对象中。      
    b.深拷贝：通过赋值等操作直接实现，将对象中的值类型的字段拷贝到新的对象中。   和浅拷贝相同

对于引用类型：
    a.浅拷贝： MemberwiseClone 方法创建一个浅副本，方法是创建一个新对象，如果字段是值类型的，则对该字段执行逐位复制。如果字段是引用类型，则复制引用原始对象，与原对象引用同一对象。

b.深拷贝：拷贝对象应用，也拷贝对象实际内容，也就是创建了一个新的改变新对象 不会影响到原始对象的内容  
这种情况需要为其实现ICloneable接口中提供的Clone方法。

差别就是在对于引用类型的实现深拷贝和浅拷贝的时候的机制不同，前者是MemberwiseClone 方法实现，后者是通过继承实现ICloneable接口中提供的Clone方法，实现对象的深拷贝。

3.代码实现和分析：

下面我们来看看具体的代码实现部分，首先介绍的还是值类型的。

a.值类型浅拷贝的实现。代码如下：

/// <summary> 
                ///    数组的=赋值(直接拷贝)，也就是引用传递，指向的是同一个地址： 
                /// </summary> 
                public void MethodShallowCopyDirectly() 
                { 
                        int[] ArrayInt = { 0, 1, 2, 3 }; 
 
                        //所以改变其中任意一个变量的值，另一个也会被改变 
                        int[] NewArrayInt = ArrayInt; 
                        //改变新的数组变量： 
                        NewArrayInt[0] = 8; 
                        Console.WriteLine("数组的复制(直接拷贝)，改变新数组第一值为8，原值{0},新值{1}", ArrayInt[0], NewArrayInt[0]); 
                } 
                /// <summary> 
                /// ArrayInt.CopyTo,创建以个新数组，不影响原来的值 
                /// </summary> 
                public void MethodShallowCopyArrayCopyTo() 
                { 
                        int[] ArrayInt = { 0, 1, 2, 3 };            
 
                        //CopyTo()方法 
                        int[] NewArrayInt = new int[5];//创建以个新数组，按值拷贝，不影响原来的值 
                        ArrayInt.CopyTo(NewArrayInt, 0); 
                        NewArrayInt[0] = 8; 
                        Console.WriteLine("Array.CopyTo，改变新数组第一值为8，原值{0},新值{1}", ArrayInt[0], NewArrayInt[0]); 
                 
                } 
                /// <summary> 
                /// Array.Copy浅拷贝,值类型的浅拷贝,创建以个新数组，按值拷贝，不影响原来的值 
                /// </summary> 
                public void MethodShallowCopyArrayCopy() 
                { 
                        int[] ArrayInt = { 0, 1, 2, 3 }; 
                        //Copy()方法 
                        int[] NewArrayInt = new int[4]; 
                        Array.Copy(ArrayInt, NewArrayInt, 0);//创建以个新数组，按值拷贝，不影响原来的值 
                        NewArrayInt[0] = 8; 
                        Console.WriteLine("Array.Copy，改变新数组第一值为8，原值{0},新值{1}", ArrayInt[0], NewArrayInt[0]); 
 
                } 
                /// <summary> 
                /// Array.Clone()，浅拷贝 
                /// </summary> 
                public void MethodShallowCopyArrayClone() 
                { 
                        int[] ArrayInt = { 0, 1, 2, 3 }; 
                        //Array Clone()方法 
                        int[] NewArrayInt = ArrayInt.Clone() as int[];//按值拷贝，不影响原来的值 
                        NewArrayInt[0] = 8; 
                        Console.WriteLine("Array.Clone()，改变新数组第一值为8，原值{0},新值{1}", ArrayInt[0], NewArrayInt[0]); 
                } 
                /// <summary> 
                /// .浅拷贝：(引用类型)，数组中的元素是引用类型，复制的是它的一个引用，改变新拷贝会改变原对象 
                /// </summary> 
                public void MethodShallowCopyStringArrayCopyTo() 
                { 
                        string[] sArray ={ "string0", "string1", "string2" }; 
                        string[] sNewArray = sArray; 
                        //浅拷贝一个新对象 
                        sArray.CopyTo(sNewArray, 0); 
 
                        //改变新对象的值这个时候源对象中的值也会被改变 
                        sNewArray[0] = "FrankXuLei"; 
                        Console.WriteLine("数组的浅拷贝：(引用类型)，改变第一值为FrankXuLei，原值{0},新值{1}", sArray[0], sNewArray[0]); 
                } 
                /// <summary> 
                ///    //字符串数组的深拷贝，如果需要包含引用类型的数组的深副本，就必须迭代数组，创建新对象 
                /// </summary> 
                public void MethodDeepCopyStringArray() 
                { 
                        string[] sArray = new string[] { "string0", "string1", "string2", "string3" }; 
                        string[] sNewArray = new string[4];//迭代数组，创建新对象 
                        for (int i = 0; i < sArray.Length; i++) 
                        { 
                                string sTemp = string.Empty; 
                                sTemp = sArray[i]; 
                                sNewArray[i] = sTemp; 
                        } 
                        sNewArray[0] = "FrankXuLei"; 
                        Console.WriteLine("数组的复制(直接拷贝)，改变新数组第一值为FrankXuLei，原值{0},新值{1}", sArray[0], sNewArray[0]); 
                } 

数组的=赋值(直接拷贝)，也就是引用传递，指向的是同一个地址，所以改变其中任意一个变量的值，另一个也会被改变。ArrayInt.CopyTo,创建以个新数组，改变新的数组变量不影响原来的值。Array.Copy浅拷贝,值类型的浅拷贝,创建以个新数组，按值拷贝，不影响原来的值。 .浅拷贝：(引用类型)，数组中的元素是引用类型，复制的是它的一个引用，改变新拷贝会改变原对象.

b.引用类型的深拷贝实现：

定义了以个汽车类,继承接口继承接口ICloneable。

public class CarDeepClone : ICloneable 
        { 
                //名称，引用类型 
                public string _name = string.Empty; 
                //价格，值得类型 
                public int _price = 0; 
                //构造函数 
                public CarDeepClone() 
                { 
                } 
                //重载构造函数 
                public    CarDeepClone(string name, int price) 
                { 
                        _name = name; 
                        _price = price; 
                } 
                //深拷贝，需要重新生成对象，返回的新对象的实例 
                public object Clone() 
                { 
 
                        //深复制     
                        CarDeepClone obj = new CarDeepClone();//重新创建 CarDeepClone的对象 
                        //obj.Member=     (ClassA)Member.Clone();     
                        return obj; 
                } 
        } 

c.引用类型的浅拷贝实现：

浅拷贝实现的方法是this.MemberwiseClone();创建当前对象的浅副本 ，返回相同的对象引用。而深拷贝的实现代码是通过 CarDeepClone obj = new CarDeepClone();重新创建 CarDeepClone的对象。这个是两者在实现上不同的地方。

public class CarShallowClone : ICloneable 
        { 
                //名称，引用类型 
                public string _name = string.Empty; 
                //价格，值得类型 
                public int _price = 0; 
                //构造函数 
                public    CarShallowClone(string name, int price) 
                { 
                        _name = name; 
                        _price = price; 
                } 
                //浅拷贝，MemberwiseClone方式返回对象的浅副本 
                public object Clone() 
                { 
                        return this.MemberwiseClone();//创建当前对象的浅副本 ，返回相同的对象引用 
                } 
        }

d.客户端测试代码实现：

包括值类型的浅拷贝和string类型数组的深拷贝的实现测试。以及对象的深拷贝和浅拷贝的测试。具体代码如下：

ValueTypeCopy _ShallowCopy = new ValueTypeCopy(); 
                        Console.WriteLine("Value Type Shallow Copy Demo 值类型浅拷贝。。。。。。。。。。。。。。。。。。"); 
                        _ShallowCopy.MethodShallowCopyDirectly();//直接赋值 
                        _ShallowCopy.MethodShallowCopyArrayClone();//调用数组的Clone()方法，浅副本 
                        _ShallowCopy.MethodShallowCopyArrayCopy();//ArrayCopy方法 
                        _ShallowCopy.MethodShallowCopyArrayCopyTo();//ArrayCopyTo()方法 
                        _ShallowCopy.MethodShallowCopyStringArrayCopyTo();//ArrayCopyTo()方法 
    
                        _ShallowCopy.MethodDeepCopyStringArray();//深拷贝字符数组 
 
    
 
                        //DeepCopy Test深拷贝，重新生成对象，对新对象的修改不会改变原来对象的值 
                        Console.WriteLine("Object Deep        Copy Demo    对象深拷贝。。。。。。。。。。。。。。。。。。。。。"); 
                        CarDeepClone _CarDeepClone1 = new CarDeepClone("Benz700",700); 
                        //深拷贝 
                        Console.WriteLine("DeepCopy Test深拷贝,原对象名字{0}", _CarDeepClone1._name); 
                        CarDeepClone _CarDeepClone2 = _CarDeepClone1.Clone() as CarDeepClone; 
 
                        Console.WriteLine("DeepCopy Test深拷贝,新对象名字{0}", _CarDeepClone2._name); 
                        //修改新对象的名字 
                        _CarDeepClone2._name = "Benz800"; 
                        Console.WriteLine("DeepCopy Test深拷贝,新对象名字修改为{0}", _CarDeepClone2._name); 
                        //输出对象信息 
                        Console.WriteLine("DeepCopy Test深拷贝,原对象名字为{0}，新对象名字为{1}", _CarDeepClone1._name, _CarDeepClone2._name); 
 
                        //ShallowCopy Test浅拷贝，新对象的修改会改变原来对象的值得 
                        Console.WriteLine("Object Shallow Copy Demo    对象浅拷贝。。。。。。。。。。。。。。。。。。。。。"); 
                        CarShallowClone _CarShallowClone1 = new CarShallowClone("BMW3", 300); 
                        Console.WriteLine("ShallowCopy Test浅拷贝,原对象名字{0}", _CarShallowClone1._name); 
                        //浅拷贝对象 
                        CarShallowClone _CarShallowClone2 = _CarShallowClone1.Clone() as CarShallowClone; 
                        Console.WriteLine("ShallowCopy Test浅拷贝,新对象名字{0}", _CarShallowClone2._name); 
                        //修改新对象名字 
                        _CarShallowClone2._name = "BMW7"; 
                        Console.WriteLine("ShallowCopy Test浅拷贝,新对象名字修改为{0}", _CarShallowClone2._name); 
                        //输出对象信息 
                        Console.WriteLine("ShallowCopy Test浅拷贝,原对象名字{0}，新对象名字{1}", _CarShallowClone1._name, _CarShallowClone2._name); 

首先测试的值类型的不同的浅拷贝方法，实例化类ValueTypeCopy _ShallowCopy = new ValueTypeCopy();
    进行 值类型浅拷测试贝。分别包括：   _ShallowCopy.MethodShallowCopyDirectly();直接赋值拷贝，
            _ShallowCopy.MethodShallowCopyArrayClone();调用数组的Clone()方法，浅副本
            _ShallowCopy.MethodShallowCopyArrayCopy();ArrayCopy方法
            _ShallowCopy.MethodShallowCopyArrayCopyTo();ArrayCopyTo()方法
            _ShallowCopy.MethodShallowCopyStringArrayCopyTo();ArrayCopyTo()方法
             _ShallowCopy.MethodDeepCopyStringArray();深拷贝字符数组后面代码主要是对对象深浅拷贝的不同测试。

运行结果如下图：

4.总结

通过以上内容的学习，希望大家对C#中的深拷贝与浅拷贝(Deep Copy and Shallow Copy)的机制能有更深入的了解。我在总结这个文章的时候也查阅了MSDN及C#书籍等资料。与大家一起分享。有问题的也可以留言一起交流~共同学习进步~（最后附上本次实现的代码。下载地址

/Files/frank_xl/CloneDemoFrankXuLei.zip 。前几天忙硕士论文的事情，没时间更新blog，现在抓紧时间继续准备WSE3.0安全开发的文章，应该最近会写出来。主要是涉及到的知识点很多，需要时间学习，而且开发环境配置比较复杂。代码插入出了问题，有js错误，请大家下载代码）

本文转自 frankxulei 51CTO博客，原文链接：http://blog.51cto.com/frankxulei/318538，如需转载请自行联系原作者