日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

學無先后，達者為師

網站首頁 編程語言 正文

C#中深拷貝和淺拷貝的介紹與用法_C#教程

作者：.NET開發菜鳥 ? 更新時間： 2022-05-22 編程語言

一、什么是深拷貝和淺拷貝

對于所有面向對象的語言，復制永遠是一個容易引發討論的題目，C#中也不例外。此類問題在面試中極其容易被問到，我們應該在了解淺拷貝和深拷貝基本概念的基礎上，從設計的角度進一步考慮如何支持對象的拷貝。

在System.Object類中，有一個受保護的方法object.MemberwiseClone(),這個方法實現了對象的復制。事實上，它所實現的就是我們所稱的淺拷貝。

深拷貝：指的是拷貝一個對象時，不僅僅把對象的引用進行復制，還把該對象引用的值也一起拷貝。這樣進行深拷貝后的拷貝對象就和源對象互相獨立，其中任何一個對象的改動都不會對另外一個對象造成影響。比如一個黃狗叫大黃，使用克隆術克隆另外一個黃狗叫小黃，這樣大黃和小黃就相對獨立了，他們不互相影響。在.NET中int,double以及結構體和枚舉等。

int a=12;
int c=a;//進行了深拷貝
c=232 //不影響

淺拷貝：指的是拷貝一個對象時，僅僅拷貝對象的引用進行拷貝，但是拷貝對象和源對象還是引用同一份實體。此時，其中一個對象的改變都會影響到另一個對象。就像一個人改名了一樣，他還是這個人，只不過名字變了而已。

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

所謂的淺拷貝，是指拷貝一個對象的時候，拷貝原始對象中所有的非靜態值類型成員和所有的引用類型成員的引用。換言之，新的對象和原始對象將共享所有引用類型成員的實際對象。而相對的，深拷貝是指不僅復制所有的非靜態值類型成員，而且也復制所有引用類型成員的實際對象。深拷貝和淺拷貝的概念是遞歸的，也就是說當引用類型成員中包含另外一個引用類型成員時，拷貝的時候將對其內部成員實行同樣的復制策略。

淺拷貝示意圖如下所示：

深拷貝示意圖如下圖所示：

類型基類System.Object已經為所有類型都實現了淺拷貝，類型所要做的就是公開一個復制的接口，而通常的，這個接口會借由實現ICloneable接口來實現。ICLoneable只包含一個Clone方法。該方法既可以被實現為淺拷貝也可以被實現為深拷貝，具體如何取舍需要根據具體類型的需求來決定。下面的代碼提供了一個深拷貝的簡單示例：

using System;

namespace DeepCopy
{
    class Program
    {
        static void Main(string[] args)
        {
            // 定義原始對象
            DpCopy dc = new DpCopy();
            dc._i = 10;
            dc._a = new A();

            // 定義深拷貝對象
            DpCopy deepClone = (DpCopy)dc.Clone();
            // 定義淺拷貝對象
            DpCopy shadowclone = (DpCopy)dc.MemberwiseClone();
            // 深拷貝的復制對象將擁有自己的引用類型成員對象
            // 所以這里的賦值不會影響原始對象
            deepClone._a._s = "我是深拷貝的A";
            Console.WriteLine(dc);
            Console.WriteLine(deepClone);
            Console.WriteLine("\r\n");

            // 淺拷貝的復制對象共享原始對象的引用類型成員對象
            // 所以這里的賦值將影響原始對象
            shadowclone._a._s = "我是淺拷貝的A";
            Console.WriteLine(dc);
            Console.WriteLine(shadowclone);

            Console.ReadKey();
        }
    }

    public class DpCopy : ICloneable
    {
        public int _i = 0;
        public A _a = new A();
        public object Clone()
        {
            // 實現深拷貝
            DpCopy newDc = new DpCopy();
            // 重新實例化一個引用類型變量
            newDc._a = new A();
            // 給新引用類型變量的成員值
            newDc._a._s = _a._s;
            newDc._i = _i;
            return newDc;
        }

        // 實現淺拷貝
        public new object MemberwiseClone()
        {
            return base.MemberwiseClone();
        }

        /// 
        /// 重寫類的ToString()方法
        /// 
        /// 
        public override string ToString()
        {
            return "I的值為：" + _i.ToString() + ",A為：" + _a._s;
        }
    }

    /// 
    /// 包含一個引用成員的類型
    /// 
    public class A
    {
        public string _s = "我是原始A";
    }
}

在上面的代碼中，類型DpCopy通過ICLoneable接口的Clone方法提供了深拷貝，并且通過提供一個MemberwiseClone的公共方法提供了淺拷貝。DpCopy類型具有一個值類型成員和一個引用類型成員，引用類型成員在淺拷貝和深拷貝時將展現不同的特性，淺拷貝的原始對象和目標對象公用了一個引用類型成員對象，這在程序的執行結果中可以清楚地看到：

有的參考資料上說C#中的深拷貝通過ICloneable接口來實現。這句話并不正確。事實上任何名字的方法都可以用來實現深拷貝，并且沒有任何語法來規定深拷貝只能通過Clone方法來實現。Clone這個名字只是一種習慣的稱呼，而實現ICloneable只能帶來一般接口的通用便利性，而并沒有任何關于拷貝的特殊性。

一般可被繼承的類型應該避免實現ICloneable接口，因為這樣做將強制所有的子類型都需要實現ICloneable接口，否則將使類型的深拷貝不能覆蓋子類的新成員。

實現深拷貝

1、新建一個對象，一個一個的重新賦值，麻煩一點

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ServiceTest
{
    public class Program
    {
        static void Main(string[] args)
        {

            YDog Dog = new YDog() { Name = "大黃" };
            YDog NewDog = new YDog();
            NewDog.Name = Dog.Name;

            Console.WriteLine($"Dog.Name：{Dog.Name},NewDog.Name：{NewDog.Name}");
            Console.Read();
        }
    }
}

輸出結果

2、利用反射實現深拷貝

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace ServiceTest
{
    public class Program
    {
        static void Main(string[] args)
        {

            YDog Dog = new YDog() { Name = "大黃" };
            YDog NewDog = (YDog)DeepCopy(Dog);
            NewDog.Name = Dog.Name;

            Console.WriteLine($"Dog.Name：{Dog.Name},NewDog.Name：{NewDog.Name}");
            Console.Read();
        }

        /* 利用反射實現深拷貝*/
        public static object DeepCopy(object _object)
        {
            Type T = _object.GetType();
            object o = Activator.CreateInstance(T);
            PropertyInfo[] PI = T.GetProperties();
            for (int i = 0; i < PI.Length; i++)
            {
                PropertyInfo P = PI[i];
                P.SetValue(o, P.GetValue(_object));
            }
            return o;
        }
    }
}

輸出結果

?

3、利用序列化和反序列化來實現，如下代碼

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;

namespace ServiceTest
{
    public class Program
    {
        static void Main(string[] args)
        {

            YDog Dog = new YDog() { Name = "大黃" };
            //YDog NewDog = (YDog)DeepCopy(Dog);
            //NewDog.Name = Dog.Name;

            // 序列化實現
            YDog NewDog = (YDog)DeepCopy(Dog);

            Console.WriteLine($"Dog.Name：{Dog.Name},NewDog.Name：{NewDog.Name}");
            Console.Read();
        }

        /* 利用反射實現深拷貝*/
        public static object DeepCopy(object _object)
        {
            Type T = _object.GetType();
            object o = Activator.CreateInstance(T);
            PropertyInfo[] PI = T.GetProperties();
            for (int i = 0; i < PI.Length; i++)
            {
                PropertyInfo P = PI[i];
                P.SetValue(o, P.GetValue(_object));
            }
            return o;
        }

        // 利用XML序列化和反序列化實現
        public static T DeepCopyWithXmlSerializer(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 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;
        }

        public static T DeepCopy(T obj)
        {
            // 序列化
           string json= JsonConvert.SerializeObject(obj);
            // 反序列化
           return JsonConvert.DeserializeObject(json);
        }
    }
}

二、總結

淺拷貝是指復制類型中的所有值類型成員，而只賦值引用類型成員的引用，并且使目標對象共享原對象的引用類型成員對象。深拷貝是指同時復制值類型成員和引用類型成員的對象。淺拷貝和深拷貝的概念都是遞歸的。System.Object中的MemberwiseClone已經實現了淺拷貝，但它是一個受保護的方法。無論深拷貝還是淺拷貝，都可以通過實現ICloneable接口的Clone方法來實現，可被繼承的類型需要謹慎地實現ICloneable接口，因為這將導致所有的子類型都必須實現ICloneable接口。

原文鏈接：https://www.cnblogs.com/dotnet261010/p/12329220.html

欄目分類
最近更新