MemberwiseClone与Clone

克隆是创建作为当前实例副本的新对象。

克隆分为深度克隆和浅度克隆

深度克隆:会克隆当前实例的所有所有成员.

浅度克隆:只会克隆当前实例的所有值类型的.

浅度克隆Object类为我们提供了一个受保护的克隆方法MemberwiseClone()

深度克隆要我们自己实现

 

实现深度克隆的方式一般有2种...

 

 

我来创建2个类

 

 [Serializable]//这个标记是表示可以序列化这个类

   //Address类  有2个属性 Province 和City
   public class Address
   {

      private string _city; 

      public string City

      {

        get { return _city; }

        set { _city = value; }

       }

 

 

        private string _province;    

        public string Province

        {

           get { return _province; }

           set { _province = value; }

        }

      }

        

     //Person 类有3个属性  Name 、Age、Address 

     [Serializable]

     public class Person

     {

        private string _name;

        private int _age;

        private Address _address;
       

        public Person(string name,int age,Address address)

        {

           _name = name;

           _age = age;

           _address = address;
         }

          public Person()
          {

          }

           public Address Address

           {

              get { return _address; }
              set { _address = value; }
            }

           public string Name

           {

              get { return this._name; }
              set {this._name = value;}
            }

            public int Age

            {

               get { return _age; }

               set { _age = value; }

             }

   

         }

      BinaryFormatter bf = new BinaryFormatter();
      ms.Seek(0, SeekOrigin.Begin);   
 
 

    

 

   

      

   我们现在来让Person实现克隆

 

   在Person类中加入

   public Person Clone()

   {

      MemoryStream ms = new MemoryStream();

      bf.Serialize(ms, this);

      ms.Seek(0, SeekOrigin.Begin);

      return (Person)bf.Deserialize(ms);
    }

    这个方法就可以实现克隆了

    这个方法是利用序列化和反序列化来实现克隆 比较方便但是类必须用[Serializable]标记可以序列化  

    令一种方式:

    public Person Clone()
    {

       Person temp = new Person();
       temp.Name = this.Name;
       temp.Age = this.Age;
       temp.Address.Province = this.Address.Province;
       temp.Address.City = this.Address.City;
       return temp;
     }

      这种方式容易出错 当一个类的成员过多时容易出错。当你要修改类的成员时，这个克隆方法也要修改 。

      建议用第序列化的方式来实现克隆。

     

   

      public Person Clone()
      {

        return this.MemberwiseClone();
      }

 

 

MemberwiseClone 方法创建一个浅表副本，具体来说就是创建一个新对象，然后将当前对象的非静态字段复制到该新对象。如果字段是值类型的，则对该字段执行逐位复制。如果字段是引用类型，则复制引用但不复制引用的对象；因此，原始对象及其复本引用同一对象。

 

下面的代码就是演示这个问题：

using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

namespace CloneDemo
{
    [Serializable]
    class DemoClass
    {
        public int i = 0;
        public int[] iArr = { 1, 2, 3 };

        public DemoClass Clone1()
        {
            return this.MemberwiseClone() as DemoClass;
        }

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

    class Program
    {
        static void Main(string[] args)
        {
            DemoClass a = new DemoClass();
            a.i = 10;
            a.iArr = new int[] { 8, 9, 10 };
            DemoClass b = a.Clone1();
            DemoClass c = a.Clone2();

            // 更改 a 对象的iArr[0], 导致 b 对象的iArr[0] 也发生了变化
              a.iArr[0] = 88;

            Console.WriteLine("MemberwiseClone");
            Console.WriteLine(b.i);
            foreach (var item in b.iArr)
            {
                Console.WriteLine(item);
            }

            Console.WriteLine("Clone2");
            Console.WriteLine(c.i);
            foreach (var item in c.iArr)
            {
                Console.WriteLine(item);
            }

            Console.ReadLine();
        }
    }
}

 

      浅度克隆就很简单了 调用受保护的克隆方法MemberwiseClone()就可以了