C#解析深浅拷贝

时间 2019-11-17

标签 c# 解析深浅拷贝栏目 C# 繁體版

原文原文链接

前言

　　前面咱们学习完了设计模式，在其中咱们有了解到原型模式。这里涉及到了克隆自身对象。那么也就是对对象进行拷贝。这里就涉及到了这么一个概念。深浅拷贝、何为深拷贝何为浅拷贝呢？咱们一块儿来看看吧。设计模式

浅拷贝

　　首先咱们看看浅拷贝。浅拷贝就是将对象中的全部字段复制到新对象中去，浅拷贝对于值类型和引用类型有不一样的影响。值类型的值被复制到副本中后，修改副本中的值不会影响原来对象的值。然而引用类型被复制到副本中的是引用类型的引用。不是引用的对象。这样再修改副本中的值是会致使原来对象的值也被修改了。可是这里引用类型状况咱们须要排除字符串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的值而后输出其引用地址，发现和以前的引用地址不同。说明并非修改原来的值，而是从新建立了一个字符串，从新获取了它的引用地址。this

　　咱们接下来看一个浅拷贝的案例吧，首先咱们准备的是如下的数据类型的值：int，string，enum，struct，class，int[]，string[]。spa

    /// <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。那么咱们看看对应的深拷贝又是什么样的呢？这里能够先声明，深拷贝对值类型和引用类型都没有区别对待。深拷贝也是将对象中的全部字段复制到新对象中去，可是对象不管是值类型仍是引用类型都将被从新建立而后复制到副本对象去。对于副本对象的修改将不会影响到原对象，不管任何类型。code

　　咱们继续将上面的例子进行深拷贝看看：对象

    /// <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]}");
        } 
    }

这里咱们看这个运行结果，不管值类型仍是引用类型修改副本对象以后都没有影响原对象的值。这也就是深拷贝的特色了。blog

总结

　　咱们看完了浅拷贝与深拷贝，咱们仔细回顾下。浅拷贝将对象的字段复制到新的对象中去，可是当修改新对象的时候，值类型和string类型的字段将不会影响原对象的字段，而引用类型除string类型外都将影响原对象的值。深拷贝也是将对象的字段复制到新的对象中去，可是不管是值类型仍是引用类型的改变都不会影响原对象的值。由于深拷贝是将原对象从新建立而后复制到副本对象中去的。继承

　　人生只有走出来的美丽，没有等出来的辉煌。

　欢迎你们扫描下方二维码，和我一块儿学习更多的知识😊