深拷贝 与 浅拷贝 验证

验证内容：

　　　　浅拷贝:是指将对象的所有字段复制到一个新对象。
             对值类型字段只是简单的拷贝一个副本到目标对象，改变对象中值类型字段的值不会反映到原始对象中,因为拷贝的是副本。
             引用型字段则是拷贝他的一个引用到目标对象.改变目标对象中引用类型字段的值它反映到原始对象中,因为拷贝的是指向堆上的一个地址。
　　　　深拷贝和浅拷贝不同的是对于引用字段的解决,深拷贝将会新对象中创建一个新对象和原始对象中对应字段相同（内容相同）字段也就说这个引用和原始对象引用不同 我们改变新对象中这个字段时候不会影响到原始对象中对应字段内容。

    [Serializable]//深拷贝必须要可序列化
    public class MyClassA : ICloneable
    {
        private int a = 0;

        public int A
        {
            get { return a; }
            set { a = value; }

        }

//引用类型

        MyObj obj = null;

        public MyObj Obj
        {
            get { return obj; }
            set { obj = value; }
        }

        private string b = string.Empty;

        public string B
        {
            get { return b; }
            set { b = value; }
        }


        #region ICloneable 成员

//浅拷贝

        public object Clone()
        {
            return this.MemberwiseClone() as MyClassA ;
        }

        #endregion

//深拷贝

        public object DeepClone()
        {
            MemoryStream stream = new MemoryStream();
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(stream, this);
            stream.Position = 0;
            return formatter.Deserialize(stream) as MyClassA;
        }
    }

    [Serializable]//引用类型也必须为可序列化
    public class MyObj
    {
        int pk = 100;

        public int Pk
        {
            get { return pk; }
            set { pk = value; }
        }
        string name = string.Empty;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public MyObj(string n)
        {
            this.name = n;
        }

    }

//测试

    public class TestClone
    {
        public TestClone()
        {
            MyClassA a = new MyClassA();
            a.A = 100;
            a.B = "Hello World!";
            //创建一个新对象，然后将当前对象的非静态字段复制到该新对象。如果字段是值类型的，则对该字段执行逐位复制。
            //如果字段是引用类型，则复制引用但不复制引用的对象；因此，原始对象及其复本引用同一对象。
            MyObj myobj = new MyObj("a");
            a.Obj = myobj;

            MyClassA b = a.Clone() as MyClassA;//浅拷贝
            MyClassA c = a.DeepClone() as MyClassA;//深拷贝

            a.Obj.Name = "b";//更改引用类型 中数据
            a.A = 1000;

            a.B = "good";

            Console.WriteLine(a.A.ToString());
            Console.WriteLine(a.B.ToString());
            Console.WriteLine(a.Obj.Pk);
            Console.WriteLine(a.Obj.Name);
            Console.WriteLine("");

            Console.WriteLine(b.A.ToString());
            Console.WriteLine(b.B.ToString());
            Console.WriteLine(b.Obj.Pk);
            Console.WriteLine(b.Obj.Name);
            Console.WriteLine("");

            Console.WriteLine(c.A.ToString());
            Console.WriteLine(c.B.ToString());
            Console.WriteLine(c.Obj.Pk);
            Console.WriteLine(c.Obj.Name);
        }

    }

结果：

--原对象输出

1000
good
100
b   （更改）
--浅拷贝输出
100
Hello World!
100
b   （更改）

--深拷贝输出
100
Hello World!
100
a