[C#進階系列]專題一：深入解析深拷貝和淺拷貝

一、前言

　　這個星期參加了一個面試，面試中問到深淺拷貝的區別，然后我就簡單了講述了它們的之間的區別，然后面試官又繼續問，如何實現一個深拷貝呢？當時只回答回答了一種方式，就是使用反射，然后面試官提示還可以通過反序列化和表達樹的方式。然后又繼續問，如果用反射來實現深拷貝的話，如何解決互相引用對象的問題呢？ 當時我給出的答案是說那就不用反射去實現唄，用反序列化實現唄，或者直接避免使兩個對象互相引用唄。然后面試官說，如果一定用反射來寫，你是怎么去解決這個問題呢？這時候我就愣住了。

　　這樣也就有了這篇文章。今天就來深入解析下深淺拷貝的問題。

二、深拷貝 Vs 淺拷貝

　　首先，講到深淺拷貝，自然就有一個問題來了？什么是深拷貝，什么又是淺拷貝呢？下面就具體介紹下它們的定義。

　　深拷貝：指的是拷貝一個對象時，不僅僅把對象的引用進行復制，還把該對象引用的值也一起拷貝。這樣進行深拷貝后的拷貝對象就和源對象互相獨立，其中任何一個對象的改動都不會對另外一個對象造成影響。舉個例子，一個人叫張三，然后使用克隆技術以張三來克隆另外一個人叫李四，這樣張三和李四就是相互獨立的，不管張三缺胳膊還是李四少腿了都不會影響另外一個人。在.NET領域，值對象就是典型的例子，如int, Double以及結構體和枚舉等。具體例子如下所示：

int source = 123;// 值類型賦值內部執行深拷貝int copy = source;// 對拷貝對象進行賦值不會改變源對象的值copy = 234;// 同樣對源對象賦值也不會改變拷貝對象的值source = 345;

　　淺拷貝：指的是拷貝一個對象時，僅僅拷貝對象的引用進行拷貝，但是拷貝對象和源對象還是引用同一份實體。此時，其中一個對象的改變都會影響到另一個對象。例如，一個人一開始叫張三，后來改名字為張老三了，可是他們還是同一個人，不管張三缺胳膊還是張老三少腿，都反應在同一個人身上。在.NET中引用類型就是一個例子。如類類型。具體例子如下所示：

public class Person    {        public string Name { get; set; }    }    class PRogram    {        static void Main(string[] args)        {            Person sourceP = new Person() { Name = "張三" };            Person copyP = sourceP; // 淺拷貝            copyP.Name = "張老三"; // 拷貝對象改變Name值            // 結果都是"張老三",因為實現的是淺拷貝，一個對象的改變都會影響到另一個對象            Console.WriteLine("Person.Name: [SourceP: {0}] [CopyP:{1}]", sourceP.Name, copyP.Name);            Console.Read();        }    }

三、深淺拷貝的幾種實現方式

　　上面已經明白了深淺拷貝的定義，至于他們之間的區別也在定義中也有所體現。介紹完了它們的定義和區別之后，自然也就有了如何去實現它們呢？

　　對于，淺拷貝的實現方式很簡單，.NET自身也提供了實現。我們知道，所有對象的父對象都是System.Object對象，這個父對象中有一個MemberwiseClone方法，該方法就可以用來實現淺拷貝，下面具體看看淺拷貝的實現方式，具體演示代碼如下所示：

// 繼承ICloneable接口，重新其Clone方法    class ShallowCopyDemoClass : ICloneable    {        public int intValue = 1;        public string strValue = "1";        public PersonEnum pEnum = PersonEnum.EnumA;        public PersonStruct pStruct = new PersonStruct() {  StructValue = 1};        public Person pClass = new Person("1");        public int[] pIntArray = new int[] { 1 };        public string[] pStringArray = new string[] { "1" };        #region ICloneable成員        public object Clone()        {            return this.MemberwiseClone();        }        #endregion     }    class Person    {        public string Name;        public Person(string name)        {            Name = name;        }    }    public enum PersonEnum    {        EnumA = 0,        EnumB = 1    }    public struct PersonStruct    {        public int StructValue;    }

　　上面類中重寫了IConeable接口的Clone方法，其實現直接調用了Object的MemberwiseClone方法來完成淺拷貝，如果想實現深拷貝，也可以在Clone方法中實現深拷貝的邏輯。接下來就是對上面定義的類進行淺拷貝測試了，看看是否是實現的淺拷貝，具體演示代碼如下所示：

class Program    {        static void Main(string[] args)        {            ShallowCopyDemo();            // List淺拷貝的演示            ListShallowCopyDemo();        }        public static void ListShallowCopyDemo()        {            List<PersonA> personList = new List<PersonA>()             {                new PersonA() { Name="PersonA", Age= 10, ClassA= new A() { TestProperty = "AProperty"} },                new PersonA() { Name="PersonA2", Age= 20, ClassA= new A() { TestProperty = "AProperty2"} }            };            // 下面2種方式實現的都是淺拷貝            List<PersonA> personsCopy = new List<PersonA>(personList);            PersonA[] personCopy2 = new PersonA[2];            personList.CopyTo(personCopy2);　　　　　　　// 由于實現的是淺拷貝，所以改變一個對象的值，其他2個對象的值都會發生改變，因為它們都是使用的同一份實體，即它們指向內存中同一個地址　            personsCopy.First().ClassA.TestProperty = "AProperty3";            WriteLog(string.Format("personCopy2.First().ClassA.TestProperty is {0}", personCopy2.First().ClassA.TestProperty));            WriteLog(string.Format("personList.First().ClassA.TestProperty is {0}", personList.First().ClassA.TestProperty));            WriteLog(string.Format("personsCopy.First().ClassA.TestProperty is {0}", personsCopy.First().ClassA.TestProperty));　　　　　　　Console.Read();　        }        public static void ShallowCopyDemo()        {            ShallowCopyDemoClass DemoA = new ShallowCopyDemoClass();            ShallowCopyDemoClass DemoB = DemoA.Clone() as ShallowCopyDemoClass ;            DemoB.intValue = 2;            WriteLog(string.Format("    int->[A:{0}] [B:{1}]", DemoA.intValue, DemoB.intValue));            DemoB.strValue = "2";            WriteLog(string.Format("    string->[A:{0}] [B:{1}]", DemoA.strValue, DemoB.strValue));            DemoB.pEnum = PersonEnum.EnumB;            WriteLog(string.Format("  Enum->[A: {0}] [B:{1}]", DemoA.pEnum, DemoB.pEnum));            DemoB.pStruct.StructValue = 2;            WriteLog(string.Format("    struct->[A: {0}] [B: {1}]", DemoA.pStruct.StructValue, DemoB.pStruct.StructValue));            DemoB.pIntArray[0] = 2;            WriteLog(string.Format("   intArray->[A:{0}] [B:{1}]", DemoA.pIntArray[0], DemoB.pIntArray[0]));            DemoB.pStringArray[0] = "2";            WriteLog(string.Format("stringArray->[A:{0}] [B:{1}]", DemoA.pStringArray[0], DemoB.pStringArray[0]));            DemoB.pClass.Name = "2";            WriteLog(string.Format("      Class->[A:{0}] [B:{1}]", DemoA.pClass.Name, DemoB.pClass.Name));　　　　　　　Console.WriteLine();　　　　　　} 

private static void WriteLog(string msg) { Console.WriteLine(msg); } 　　} }

　　上面代碼的運行結果如下圖所示：

　　從上面運行結果可以看出，.NET中值類型默認是深拷貝的，而對于引用類型，默認實現的是淺拷貝。所以對于類中引用類型的屬性改變時，其另一個對象也會發生改變。

　　上面已經介紹了淺拷貝的實現方式，那深拷貝要如何實現呢？在前言部分已經介紹了，實現深拷貝的方式有：反射、反序列化和表達式樹。在這里，我只介紹反射和反序列化的方式，對于表達式樹的方式在網上也沒有找到，當時面試官說是可以的，如果大家找到了表達式樹的實現方式，麻煩還請留言告知下。下面我們首先來看看反射的實現方式吧：

// 利用反射實現深拷貝        public static T DeepCopyWithReflection<T>(T obj)        {            Type type = obj.GetType();            // 如果是字符串或值類型則直接返回            if (obj is string || type.IsValueType) return obj;            if (type.IsArray)            {                Type elementType = Type.GetType(type.FullName.Replace("[]", string.Empty));                var array = obj as Array;                Array copied = Array.CreateInstance(elementType, array.Length);                for (int i = 0; i < array.Length; i++)                {                    copied.SetValue(DeepCopyWithReflection(array.GetValue(i)), i);                }                return (T)Convert.ChangeType(copied, obj.GetType());            }            object retval = Activator.CreateInstance(obj.GetType());                        PropertyInfo[] properties = obj.GetType().GetProperties(                BindingFlags.Public | BindingFlags.NonPublic                | BindingFlags.Instance | BindingFlags.Static);            foreach (var property in properties)            {                var propertyValue = property.GetValue(obj, null);                if (propertyValue == null)                    continue;                property.SetValue(retval, DeepCopyWithReflection(propertyValue), null);            }            return (T)retval;        }

　　反序列化的實現方式，反序列化的方式也可以細分為3種，具體的實現如下所示：

 // 利用xml序列化和反序列化實現        public static T DeepCopyWithXmlSerializer<T>(T obj)        {            object retval;            using (MemoryStream ms = new MemoryStream())            {                XmlSerializer xml = new XmlSerializer(typeof(T));                xml.Serialize(ms, obj);                ms.Seek(0, SeekOrigin.Begin);                retval = xml.Deserialize(ms);                ms.Close();            }            return (T)retval;        }        // 利用二進制序列化和反序列實現        public static T DeepCopyWithBinarySerialize<T>(T obj)        {            object retval;            using (MemoryStream ms = new MemoryStream())            {                BinaryFormatter bf = new BinaryFormatter();                // 序列化成流                bf.Serialize(ms, obj);                ms.Seek(0, SeekOrigin.Begin);                // 反序列化成對象                retval = bf.Deserialize(ms);                ms.Close();            }            return (T)retval;        }        // 利用DataContractSerializer序列化和反序列化實現        public static T DeepCopy<T>(T obj)        {            object retval;