C#学习笔记（十）：阴影和深度复制

从一个变量到另一个变量按值复制对象，而不是按引用复制对象（即以与结构相同的方式复制）可能非常复杂。因为一个对象可能包含许多对象的引用，例如字段、成员等，这将涉及许多烦人的处理操作。把每个成员从一个对象复制到另一个对象中可能不会成功，因为其中一些成员可能是引用类型。

按照成员复制简单的对象可以通过派生于System.Object的MemberwiseClone()方法来完成，这是一个受保护的方法，但很容易在对象上定义一个该方法的公共方法。这个方法提供的复制功能称为阴影复制，因为它没有考虑引用类型成员。因此，新对象中的引用成员就会指向与源对象中相同成员的对象，在许多情况下这并不理想。如果要创建成员的新实例，此时应复制值，而不复制引用，就需要使用深度复制。

我们看下面一个例子，其中有一个值类型的域：

    public class Cloner

    {

        public int Val;

 

        public Cloner(int newVal)

        {

            Val = newVal;

        }

 

        public object GetCopy()

        {

            return MemberwiseClone();

        }

    }

我们用下面这段代码进行测试：

            Cloner mySource = new Cloner(5);

            Cloner myTarget = (Cloner)mySource.GetCopy();

            Console.WriteLine("mySource.Val = {0}",mySource.Val);

            Console.WriteLine("myTarget.Val = {0}",myTarget.Val);

            mySource.Val = 2;

            Console.WriteLine("mySource.Val = {0}",mySource.Val);

            Console.WriteLine("myTarget.Val = {0}",myTarget.Val);

得出如下结果：

    我们发现，这种简单的值类型域的复制，即使改变源对象的值也不会影响复制对象的值。也就是说我们创建了一个新的对象实例。

 

再来看一段修改的代码，使用引用类型的域作试验：

    public class Content

    {

        public int Val;

    }

 

    public class Cloner

    {

        public Content MyContent = new Content();

 

        public Cloner(int newVal)

        {

            MyContent.Val = newVal;

        }

 

        public object GetCopy()

        {

            return MemberwiseClone();

        }

    }

这时，我们通过GetCopy()得到的阴影复制有一个域，它引用的对象与源对象相同。使用下面这段代码进行测试：

            Cloner mySource = new Cloner(5);

            Cloner myTarget = (Cloner)mySource.GetCopy();

            Console.WriteLine("mySource.MyContent.Val = {0}",mySource.MyContent.Val);

            Console.WriteLine("myTarget.MyContent.Val = {0}",myTarget.MyContent.Val);

            mySource.MyContent.Val = 2;

            Console.WriteLine("mySource.MyContent.Val = {0}",mySource.MyContent.Val);

            Console.WriteLine("myTarget.MyContent.Val = {0}",myTarget.MyContent.Val);

则得到不同的执行结果：

    发现，当改变源对象mySource.MyContent.Val的引用类型域的值后通过阴影复制得到的对象myTarget的引用类型域的值同时发生了改变。这是因为mySource.MyContent引用了与myTarget.MyContent相同的对象实例。

为了说明这个过程，需要执行深度复制。修改上面的GetCopy()方法就可以进行深度复制，但最好使用.NET Framework的标准方式。为此，执行ICloneable接口，该接口有一个方法Clone()，这个方法不带参数，返回一个对象类型，其签名和上面使用的GetCopy()方法相同。

我们使用这个接口看相应的阴影复制：

    public class Content

    {

        public int Val;

    }

 

    public class Cloner : ICloneable

    {

        public Content MyContent = new Content();

 

        public Cloner(int newVal)

        {

            MyContent.Val = newVal;

        }

 

        #region ICloneable 成员

 

        public object Clone()

        {

            Cloner clonedCloner = new Cloner(MyContent.Val);

            return clonedCloner;

        }

 

        #endregion

    }

测试代码为：

            Cloner mySource = new Cloner(5);

            Cloner myTarget = (Cloner)mySource.Clone();

            Console.WriteLine("mySource.MyContent.Val = {0}",mySource.MyContent.Val);

            Console.WriteLine("myTarget.MyContent.Val = {0}",myTarget.MyContent.Val);

            mySource.MyContent.Val = 2;

            Console.WriteLine("mySource.MyContent.Val = {0}",mySource.MyContent.Val);

            Console.WriteLine("myTarget.MyContent.Val = {0}",myTarget.MyContent.Val);

得到如下结果：

    这里使用的是包含在源Cloner对象(MyContent)中的Content对象的Val字段去创建一个新的Cloner对象。这个域是一个值类型所以不需要进行深度复制。

 

通过ICloneable.Clone方法支持除MemberwiseClone所提供的克隆之外的克隆。

浅表副本（阴影复制）创建与原始对象具有相同类型的新实例，然后复制原始对象的非静态字段。如果字段是值类型的，则对该字段执行逐位复制。如果字段是引用类型，则复制该引用但不复制被引用的对象；这样，原始对象中的引用和复本中的引用指向同一个对象。相反，对象的深层副本（深度复制）复制对象中字段直接或间接引用的全部内容。

例如，如果 X 是一个具有对对象 A 和对象 B 的引用的 Object，并且对象 A 还具有对对象 M 的引用，则 X 的浅表副本是对象 Y，而 Y 同样具有对对象 A 和对象 B 的引用。

    相反，X 的深层副本是对象 Y，而对象 Y 具有对对象 C 和对象 D 的直接引用以及对对象 N 的间接引用，其中 C 是 A 的副本，D 是 B 的副本，而 N 是 M 的副本。

 

最后我们再举一个例子，请大家看如下代码：

        [STAThread]

        static void Main(string[] args)

        {

  

            // Creates an instance of MyDerivedClass and assign values to its fields.

            MyDerivedClass m1 = new MyDerivedClass();

            m1.age = 42;

            m1.name = "Sam";

 

            Console.WriteLine("MyBaseClass.CompanyName = {0}",MyBaseClass.CompanyName);

            Console.WriteLine("m1.age = {0}",m1.age);

            Console.WriteLine("m1.name = {0}",m1.name);

 

            // Performs a shallow copy of m1 and assign it to m2.

            MyDerivedClass m2 = (MyDerivedClass) m1.MemberwiseClone();

            Console.WriteLine("MyBaseClass.CompanyName = {0}",MyBaseClass.CompanyName);

            Console.WriteLine("m2.age = {0}",m2.age);

            Console.WriteLine("m2.name = {0}",m2.name);

 

            m1.age = 21;

            m1.name = "Dick";

            Console.WriteLine("MyBaseClass.CompanyName = {0}",MyBaseClass.CompanyName);

            Console.WriteLine("m1.age = {0}",m1.age);

            Console.WriteLine("m1.name = {0}",m1.name);

 

            Console.WriteLine("MyBaseClass.CompanyName = {0}",MyBaseClass.CompanyName);

            Console.WriteLine("m2.age = {0}",m2.age);

            Console.WriteLine("m2.name = {0}",m2.name);

        }

    }

 

    class MyBaseClass

    {

        public static string CompanyName = "My Company";

        public int age;

        public string name;

    }

下面这个方法和其中的MyBaseClass是等效的：

    class MyBaseClass : ICloneable

    {

        public static string CompanyName = "My Company";

        public int age;

        public string name;

 

        #region ICloneable 成员

 

        public object Clone()

        {

            MyDerivedClass myDerivedClass = new MyDerivedClass();

            myDerivedClass.age = age;

            myDerivedClass.name = name;

            return myDerivedClass;

        }

 

        #endregion

    }

只不过在调用的时候写成这样：

            MyDerivedClass m2 = (MyDerivedClass) m1. Clone();