C#解析深淺拷貝_ZenDei技術網路在線

前言前面我們學習完了設計模式，在其中我們有瞭解到原型模式。這裡涉及到了克隆自身對象。那麼也就是對對象進行拷貝。這裡就涉及到了這麼一個概念。深淺拷貝、何為深拷貝何為淺拷貝呢？我們一起來看看吧。淺拷貝首先我們看看淺拷貝。淺拷貝就是將對象中的所有欄位複製到新對象中去，淺拷貝對於值類型和引用類型有不同 ...

前言

　　前面我們學習完了設計模式，在其中我們有瞭解到原型模式。這裡涉及到了克隆自身對象。那麼也就是對對象進行拷貝。這裡就涉及到了這麼一個概念。深淺拷貝、何為深拷貝何為淺拷貝呢？我們一起來看看吧。

淺拷貝

　　首先我們看看淺拷貝。淺拷貝就是將對象中的所有欄位複製到新對象中去，淺拷貝對於值類型和引用類型有不同的影響。值類型的值被覆制到副本中後，修改副本中的值不會影響原來對象的值。然而引用類型被覆制到副本中的是引用類型的引用。不是引用的對象。這樣再修改副本中的值是會導致原來對象的值也被修改了。但是這裡引用類型情況我們需要排除字元串String類型。

　　那麼為何引用類型修改副本的值會造成原來對象的值的變化，而string字元串類型卻排除在外呢？首先我們需要知道這麼一個概念，string類型是一個不可變的數據類型，也就是意味著對字元串對象進行了初始化，該字元串對象就不能改變了。錶面上我們修改字元串的內容的方法和運算實際上是創建了一個新字元串，然後根據需要可以把舊字元串的內容複製到新字元串中。怎麼理解你？我們看下麵這個案例：

        #region  字元串比較
        /// <summary>
        ///   獲取引用類型的記憶體地址方法
        /// </summary>
        /// <param name="o"></param>
        /// <returns></returns>
        public static string getMemory(object o)
        {
            GCHandle h = GCHandle.Alloc(o, GCHandleType.Pinned);
            IntPtr addr = h.AddrOfPinnedObject();
            return "0x" + addr.ToString("X");
        }
        /// <summary>
        /// 字元串比較
        /// </summary>
        public static void Compares()
        {
            string a = "123";
            Console.WriteLine("a的引用地址：\t\t" + getMemory(a));
            string b = "123";
            Console.WriteLine("b的引用地址：\t\t" + getMemory(b));
            Console.WriteLine("a與b的比較：\t\t" + Object.ReferenceEquals(a, b));
            b = "456";
            Console.WriteLine("b的引用地址：\t\t" + getMemory(b));


        }

        #endregion

　　這裡我們看a=”123”,b=”123”。我們看他們的引用地址是一樣的。也就是說我們先創建a的時候創建了字元串a，有了一個引用地址。然後我們創建b的時候首先會尋找是否存在相同的值。如果存在相同的值就獲取其引用地址。這也就是為什麼a與b的引用地址是一樣的。這裡涉及到一個叫做字元駐留池的東西。會對字元串進行保存。那麼後面我們修改b的值然後輸出其引用地址，發現和之前的引用地址不一樣。說明並不是修改原來的值，而是重新創建了一個字元串，重新獲取了它的引用地址。

　　我們接下來看一個淺拷貝的案例吧，首先我們準備的是以下的數據類型的值：int，string，enum，struct，class，int[]，string[]。

    /// <summary>
    /// 枚舉
    /// </summary>
    public enum EnumTest
    {
        TestOne = 1,
        TestTwo = 2
    }

    /// <summary>
    /// 結構體
    /// </summary>
    public struct StructTest
    {
        public int Test;
        public StructTest(int i)
        {
            Test = i;
        }
    }

    /// <summary>
    /// 類
    /// </summary>
    public class ClassTest
    {
        public string TestString;
        public ClassTest(string _string)
        {
            TestString = _string;
        }
    }
    /// <summary>
    /// 深拷貝
    /// </summary>
    public class DeepClone : ICloneable
    {
        public int _int = 1;
        public string _string = "1";
        public EnumTest _enum = EnumTest.TestOne;
        public StructTest _struct = new StructTest(1);
        public ClassTest _class = new ClassTest("1");
        public int[] arrInt = new int[] { 1 };
        public string[] arrString = new string[] { "1" };
        public object Clone()
        {
            var NewOne = JsonConvert.SerializeObject(this);
            return JsonConvert.DeserializeObject<DeepClone>(NewOne);
        } 
    }
    class Program
    {
        static void Main(string[] args)
        {
            DeepClone simple = new DeepClone();
            var simpleTwo = (DeepClone)simple.Clone();
            simpleTwo._int = 2;
            simpleTwo._string = "2";
            simpleTwo._enum = EnumTest.TestTwo;
            simpleTwo._struct.Test = 2;
            simpleTwo._class.TestString = "2";
            simpleTwo.arrInt[0] = 2;
            simpleTwo.arrString[0] = "2";

            Console.WriteLine($"int 類型變化     原對象：{simple._int}\t\t               備份對象:{simpleTwo._int}");
            Console.WriteLine($"string 類型變化  原對象：{simple._string}\t\t            備份對象:{simpleTwo._string}");
            Console.WriteLine($"enum 類型變化    原對象：{(int)simple._enum}\t\t         備份對象:{(int)simpleTwo._enum}");
            Console.WriteLine($"struct 類型變化  原對象：{simple._struct.Test}\t\t       備份對象:{simpleTwo._struct.Test}");
            Console.WriteLine($"class 類型變化   原對象：{simple._class.TestString}\t\t  備份對象:{simpleTwo._class.TestString}");
            Console.WriteLine($"int數組 類型變化  原對象：{simple.arrInt[0]}\t\t         備份對象:{simpleTwo.arrInt[0]}");
            Console.WriteLine($"string數組 類型變化   原對象：{simple.arrString[0]}\t\t  備份對象:{simpleTwo.arrString[0]}");
        } 
    }

　　我們通過繼承ICloneable介面對這些類型都進行了淺拷貝然後修改副本對象。輸出原對象和副本對象進行比較。我們發現int,enum,struct、值類型以及string這個特殊的引用類型的原對象值沒有被影響改變。但是class,int[],string[]這些引用類型對象原對象被影響改變了值。也就再次驗證了我們前面說的。淺拷貝是將對象進行賦值到一個副本對象中去，值類型複製值，引用類型複製其引用對象。修改副本對象值，值類型和string原對象不會被影響改變，引用類型除string其原對象都會被影響改變。

深拷貝

　　我們上面看了淺拷貝，淺拷貝還是有一定的影響的，處理不好可能就成bug。那麼我們看看對應的深拷貝又是什麼樣的呢？這裡可以先聲明，深拷貝對值類型和引用類型都沒有區別對待。深拷貝也是將對象中的所有欄位複製到新對象中去，但是對象無論是值類型還是引用類型都將被重新創建然後複製到副本對象去。對於副本對象的修改將不會影響到原對象，無論任何類型。

　　我們繼續將上面的例子進行深拷貝看看：

    /// <summary>
    /// 深拷貝
    /// </summary>
    public class DeepClone : ICloneable
    {
        public int _int = 1;
        public string _string = "1";
        public EnumTest _enum = EnumTest.TestOne;
        public StructTest _struct = new StructTest(1);
        public ClassTest _class = new ClassTest("1");
        public int[] arrInt = new int[] { 1 };
        public string[] arrString = new string[] { "1" };
        public object Clone()
        {
            var NewOne = JsonConvert.SerializeObject(this);
            return JsonConvert.DeserializeObject<DeepClone>(NewOne);
        } 
    }

    class Program
    {
        static void Main(string[] args)
        {
            DeepClone simple = new DeepClone();
            var simpleTwo = (DeepClone)simple.Clone();
            simpleTwo._int = 2;
            simpleTwo._string = "2";
            simpleTwo._enum = EnumTest.TestTwo;
            simpleTwo._struct.Test = 2;
            simpleTwo._class.TestString = "2";
            simpleTwo.arrInt[0] = 2;
            simpleTwo.arrString[0] = "2";

            Console.WriteLine($"int 類型變化     原對象：{simple._int}\t\t               備份對象:{simpleTwo._int}");
            Console.WriteLine($"string 類型變化  原對象：{simple._string}\t\t            備份對象:{simpleTwo._string}");
            Console.WriteLine($"enum 類型變化    原對象：{(int)simple._enum}\t\t         備份對象:{(int)simpleTwo._enum}");
            Console.WriteLine($"struct 類型變化  原對象：{simple._struct.Test}\t\t       備份對象:{simpleTwo._struct.Test}");
            Console.WriteLine($"class 類型變化   原對象：{simple._class.TestString}\t\t  備份對象:{simpleTwo._class.TestString}");
            Console.WriteLine($"int數組 類型變化  原對象：{simple.arrInt[0]}\t\t         備份對象:{simpleTwo.arrInt[0]}");
            Console.WriteLine($"string數組 類型變化   原對象：{simple.arrString[0]}\t\t  備份對象:{simpleTwo.arrString[0]}");
        } 
    }

這裡我們看這個運行結果，無論值類型還是引用類型修改副本對象之後都沒有影響原對象的值。這也就是深拷貝的特點了。

總結

　　我們看完了淺拷貝與深拷貝，我們仔細回顧下。淺拷貝將對象的欄位複製到新的對象中去，但是當修改新對象的時候，值類型和string類型的欄位將不會影響原對象的欄位，而引用類型除string類型外都將影響原對象的值。深拷貝也是將對象的欄位複製到新的對象中去，但是無論是值類型還是引用類型的改變都不會影響原對象的值。因為深拷貝是將原對象重新創建然後複製到副本對象中去的。

　　人生只有走出來的美麗，沒有等出來的輝煌。

　歡迎大家掃描下方二維碼，和我一起學習更多的知識