引用浅拷贝深拷贝

因为使用引用和拷贝的方法不对，尤其是在类的拷贝中，完全没有意识到这一点，结果花了很长时间来检查这个问题。最终发现这是浅拷贝和深拷贝的问题，而且这也是陈老师课上很重要的一部分，还是忘记了。。。！现在把这部分内容整理一下，而且在CSDN上看到一篇不错的文章，结合陈老师讲的，把这部分内容归纳一下。

 

概念：

• 引用：用赋值运算符将对象a复制为对象b。此时a和b其实是同一个对象，只是名字不同而已，a的变化会立即影响到b，反之亦然。
• 浅拷贝：用从object继承下来的MemberwiseClone方法，将对象a复制为对象b。此时，a和b的值类型字段是完全隔离的，一方的变化不会影响到另一方；a和b的引用类型字段则是同一个子对象，a中子对象的变化会立即影响到b中相应的子对象，反之亦然。string类型的子对象在浅拷贝中的行为与值类型子对象相同。
• 深拷贝：用序列化和反序列化等方法将对象a复制为对象b，两个对象中的子对象完全隔离，一方的变化不会影响到另一方。深拷贝时不必知道对象内部有哪些数据。

引用的例子：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;


namespace Test
{
    public class MyData
    {
        static void Main(string[] args)
        {
            Person p1 = new Person(1, "Alan", new Car("宝马"));
            Person p2 = p1;//赋值仅是对引用的操作

            Console.Write("P1对象原始的值:");
            Console.WriteLine("id:{0}  name:{1}  car:{2}", p1.id, p1.name, p1.car.name);
            Console.Write("P2对象原始的值:");
            Console.WriteLine("id:{0}  name:{1}  car:{2}", p2.id, p2.name, p2.car.name);

            Console.WriteLine("\n改变P2的值后:");
            p2.id = 2;
            p2.name = "Charlie";
            p2.car.name = "红旗";

            Console.Write("P1对象现在的值:");
            Console.WriteLine("id:{0}  name:{1}  car:{2}", p1.id, p1.name, p1.car.name);
            Console.Write("P2对象现在的值:");
            Console.WriteLine("id:{0}  name:{1}  car:{2}", p2.id, p2.name, p2.car.name);
        }
    }

    class Car
    {
        public string name;
        public Car(string name)
        {
            this.name = name;
        }
    }

    class Person
    {
        public int id;
        public string name;
        public Car car;
        public Person(int id, string name, Car car)
        {
            this.id = id;
            this.name = name;
            this.car = car;
        }
    }
}

P1和P2其实是一个对象，输出结果：

浅拷贝的例子：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;


namespace Test
{

    public class MyData
    {
        static void Main(string[] args)
        {
            Person p1 = new Person(1, "Alan", new Car("宝马"));
            Person p2 = p1.Clone() as Person;//浅拷贝调用

            Console.Write("P1对象原始的值:");
            Console.WriteLine("id:{0}  name:{1}  car:{2}", p1.id, p1.name, p1.car.name);
            Console.Write("P2对象原始的值:");
            Console.WriteLine("id:{0}  name:{1}  car:{2}", p2.id, p2.name, p2.car.name);

            Console.WriteLine("改变P1的值后:");
            p1.id = 2;
            p1.name = "Mary";
            p1.car.name = "红旗";

            //Console.WriteLine("改变P2的值后:");
            //p2.id = 2;
            //p2.name = "Mary";
            //p2.car.name = "红旗";

            Console.Write("P1对象现在的值:");
            Console.WriteLine("id:{0}  name:{1}  car:{2}", p1.id, p1.name, p1.car.name);
            Console.Write("P2对象现在的值:");
            Console.WriteLine("id:{0}  name:{1}  car:{2}", p2.id, p2.name, p2.car.name);
        }
    }

    class Car
    {
        public string name;
        public Car(string name)
        {
            this.name = name;
        }
    }

    class Person
    {
        public int id;
        public string name;
        public Car car;
        public Person(int id, string name, Car car)
        {
            this.id = id;
            this.name = name;
            this.car = car;
        }

        //对外提供一个创建自身的浅副本的能力
        public object Clone()
        {
            return this.MemberwiseClone();
        }
    }
}

值对象和string对象都是传值的，所以id和name都没有变化。而类是传递引用的，所以Car对象变化了。输出结果为：

深拷贝的例子：

参考的网站上的一个例子，使用了下面的代码：

    class Person : ICloneable //深拷贝必须实现ICloneable接口..   
    {
        public int id;
        public string name;
        public Car car;
        public Person(int id, string name, Car car)
        {
            this.id = id;
            this.name = name;
            this.car = car;
        }

        //对外提供一个创建自身的浅副本的能力
        public object Clone()
        {
            return this.MemberwiseClone() as Person;
        }
    }

发现完全不能实现，跟浅拷贝的作用是一样的！又查阅了其它资料，只要用MemberwiseClone()就只是浅拷贝而已。所以深拷贝要么一个一个的属性重新赋值，最简单最粗暴的方法。但是肯定是扩展性不好，所以采纳陈老师课上的另外一种方法，采用序列化和反序列化的办法，这样不用去关心这个类到底有什么属性了。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;//


namespace Test
{

    public class MyData
    {
        static void Main(string[] args)
        {
            Person p1 = new Person(1, "Alan", new Car("宝马"));
            Person p2 = (Person)p1.DeepCopy(p1);//深拷贝调用

            Console.Write("P1对象原始的值:");
            Console.WriteLine("id:{0}  name:{1}  car:{2}", p1.id, p1.name, p1.car.name);
            Console.Write("P2对象原始的值:");
            Console.WriteLine("id:{0}  name:{1}  car:{2}", p2.id, p2.name, p2.car.name);

            Console.WriteLine("改变P1的值后:");
            p1.id = 2;
            p1.name = "Mary";
            p1.car.name = "红旗";

            //Console.WriteLine("改变P2的值后:");
            //p2.id = 2;
            //p2.name = "Mary";
            //p2.car.name = "红旗";

            Console.Write("P1对象现在的值:");
            Console.WriteLine("id:{0}  name:{1}  car:{2}", p1.id, p1.name, p1.car.name);
            Console.Write("P2对象现在的值:");
            Console.WriteLine("id:{0}  name:{1}  car:{2}", p2.id, p2.name, p2.car.name);
        }
    }
    [Serializable]
    class Car
    {
        public string name;
        public Car(string name)
        {
            this.name = name;
        }
    }
    [Serializable]
    class Person //深拷贝必须实现ICloneable接口..   
    {
        public int id;
        public string name;
        public Car car;
        public Person(int id, string name, Car car)
        {
            this.id = id;
            this.name = name;
            this.car = car;
        }

        //对外提供一个创建自身的浅副本的能力
        public object Clone()
        {
            return this.MemberwiseClone() as Person;
        }

        //深拷贝
        public object DeepCopy(object obj)
        {
            MemoryStream ms = new MemoryStream();
            BinaryFormatter bf = new BinaryFormatter();
            bf.Serialize(ms, obj);
            ms.Position = 0;
            return bf.Deserialize(ms);
        }
    }
}

注意[Serializable]以及添加的命名空间。输出的结果为：

字符串的解释：

字符串在C#中其实中引用类型，但是使用浅拷贝时，发现象值类型一样处理了。这是为什么？来看MSDN的解释：字符串对象是“不可变的”，即它们一旦创建就无法更改。对字符串进行操作的方法实际上返回的是新的字符串对象。

比如下面这个例子：

string s1 = "hello";
string s2 = s1;
s1 = "world";
Console.WriteLine("s1:{0}/ns2:{1}", s1, s2);

我们平常大量使用这样的方法，没有象引用那样造成麻烦，string s2=s1;语句将会使s1 ,s2指向同一内存位置.如果改变s1(s1="world"),原来的"hello"并不会改变,只是会创建新的字符串对象"world",s1对其引用。