前言
前面我们学习完了设计模式，在其中我们有了解到原型模式。这里涉及到了克隆自身对象。那么也就是对对象进行拷贝。这里就涉及到了这么一个概念。深浅拷贝、何为深拷贝何为浅拷贝呢？我们一起来看看吧。
浅拷贝
首先我们看看浅拷贝。浅拷贝就是将对象中的所有字段复制到新对象中去，浅拷贝对于值类型和引用类型有不同的影响。值类型的值被复制到副本中后，修改副本中的值不会影响原来对象的值。然而引用类型被复制到副本中的是引用类型的引用。不是引用的对象。这样再修改副本中的值是会导致原来对象的值也被修改了。但是这里引用类型情况我们需要排除字符串string类型。
那么为何引用类型修改副本的值会造成原来对象的值的变化，而string字符串类型却排除在外呢？首先我们需要知道这么一个概念，string类型是一个不可变的数据类型，也就是意味着对字符串对象进行了初始化，该字符串对象就不能改变了。表面上我们修改字符串的内容的方法和运算实际上是创建了一个新字符串，然后根据需要可以把旧字符串的内容复制到新字符串中。怎么理解你？我们看下面这个案例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
#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[]。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
/// <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。那么我们看看对应的深拷贝又是什么样的呢？这里可以先声明，深拷贝对值类型和引用类型都没有区别对待。深拷贝也是将对象中的所有字段复制到新对象中去，但是对象无论是值类型还是引用类型都将被重新创建然后复制到副本对象去。对于副本对象的修改将不会影响到原对象，无论任何类型。
我们继续将上面的例子进行深拷贝看看：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
/// <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类型外都将影响原对象的值。深拷贝也是将对象的字段复制到新的对象中去，但是无论是值类型还是引用类型的改变都不会影响原对象的值。因为深拷贝是将原对象重新创建然后复制到副本对象中去的。
好了，以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对服务器之家的支持。
原文链接：https://www.cnblogs.com/hulizhong/p/11776610.html
