也许会有人这样解释c# 中浅拷贝与深拷贝区别：
浅拷贝是对引用类型拷贝地址，对值类型直接进行拷贝。
不能说它完全错误，但至少还不够严谨。比如：string 类型咋说？
其实，我们可以通过实践来寻找答案。
首先，定义以下类型：
int 、string 、enum 、struct 、class 、int[ ] 、string[ ]
代码如下：
| //枚举 |
| public enum myenum |
| { _1 = 1, _2 = 2 } |
| //结构体 |
| public struct mystruct |
| { |
| public int _int; |
| public mystruct(int i) |
| { _int = i; } |
| } |
| //类 |
| class myclass |
| { |
| public string _string; |
| public myclass(string s) |
| { _string = s; } |
| } |
| //icloneable：创建作为当前实例副本的新对象。 |
| class democlass : icloneable |
| { |
| public int _int = 1; |
| public string _string = "1"; |
| public myenum _enum = myenum._1; |
| public mystruct _struct = new mystruct(1); |
| public myclass _class = new myclass("1"); |
| //数组 |
| public int[] arrint = new int[] { 1 }; |
| public string[] arrstring = new string[] { "1" }; |
| //返回此实例副本的新对象 |
| public object clone() |
| { |
| //memberwiseclone：返回当前对象的浅表副本(它是object对象的基方法) |
| return this.memberwiseclone(); |
| } |
| } |
注意：
icloneable 接口：支持克隆，即用与现有实例相同的值创建类的新实例。
memberwiseclone 方法：创建当前 system.object 的浅表副本。
接下来，构建实例a ，并对实例a 克隆产生一个实例b。
然后，改变实例b 的值，并观察实例a 的值会不会被改变。
代码如下：
| class 浅拷贝与深拷贝 |
| { |
| static void main(string[] args) |
| { |
| democlass a = new democlass(); |
| //创建实例a的副本 --> 新对象实例b |
| democlass b = (democlass)a.clone(); |
| b._int = 2; |
| console.writeline(" int tt a:{0} b:{1}", a._int, b._int); |
| b._string = "2"; |
| console.writeline(" string t a:{0} b:{1}", a._string, b._string); |
| b._enum = myenum._2; |
| console.writeline(" enum tt a:{0} b:{1}", (int)a._enum, (int)b._enum); |
| b._struct._int = 2; |
| console.writeline(" struct t a:{0} b:{1}", a._struct._int, b._struct._int); |
| b._class._string = "2"; |
| console.writeline(" class tt a:{0} b:{1}", a._class._string, b._class._string); |
| b.arrint[0] = 2; |
| console.writeline(" intarray t a:{0} b:{1}", a.arrint[0], b.arrint[0]); |
| b.arrstring[0] = "2"; |
| console.writeline(" stringarray t a:{0} b:{1}", a.arrstring[0], b.arrstring[0]); |
| console.readkey(); |
| } |
| } |
结果如下：
从最后的输出结果，我们得知：
对于内部的class 对象和数组，则copy 一份地址。[ 改变b 时，a也被改变了 ]
而对于其它内置的int / string / enum / struct / object 类型，则copy 一份值。
有一位网友说：string 类型虽然是引用类型，但是很多情况下.net 把string 做值类型来处理，我觉得string 应该也是按照值类型处理的。
这说明他对string 类型还不够了解。
可以肯定的是：string 一定是引用类型。那它为什么是深拷贝呢？
如果你看一下string 类型的源代码就知道了：
| //表示空字符串。此字段为只读。 |
| public static readonly string empty; |
答案就在于 string 是 readonly 的，当改变 string 类型的数据值时，将重新分配了内存地址。
下面引用一段网友的代码： vseen[ aloner ] 的个人陋见：
| public class student |
| { |
| // 这里用“字段”，其实应当是属性。 |
| public string name; |
| public int age; |
| //自定义类 classroom |
| public classroom class; |
| } |
| 浅拷贝：student a 浅拷贝出 student b，name和age拥有新的内存地址，但引用了同一个 classroom。 |
| 深拷贝：student a 浅拷贝出 student b，name和age拥有新的内存地址，并且a.classroom 的内存地址不等于 b.classroom。 |
| 其实俗点讲，有点像： |
| public object clone() |
| { |
| student b = new student(); |
| b.name = this.name; |
| b.age = this.age; |
| //浅拷贝 |
| b.class = this.class; |
| //深拷贝 |
| b.class = new classromm(); |
| b.class.name = this.class.name; |
| b.class.teacher = this.class.teacher; //根据情况，对teacher 进行判定要进行的是深拷贝，还是浅拷贝。 |
| } |
浅拷贝：给对象拷贝一份新的对象。
浅拷贝的定义 —— 只对值类型（或string）类型分配新的内存地址。
深拷贝：给对象拷贝一份全新的对象。
深拷贝的定义 —— 对值类型分配新的内存地址，引用类型、以及引用类型的内部字段分配的新的地址。
我是这么定义的：浅拷贝，换汤不换药。
注意：
1、在 .net 程序中，应该避免使用 icloneable 接口。
因为通过该接口无法判断究竟是浅拷贝还是深拷贝，这会造成误解或误用。
2、深拷贝应该复制该对象本身及通过该对象所能到达的完整的对象图，浅拷贝只复制对象本身（就是该对象所表示的在堆中的一块连续地址中的内容）。
个人愚见：
clone ：深层拷贝，拷贝到了指针指向的内存块的值。
浅拷贝：仅仅拷贝了指针的内容。（只是给一个对象多起了个名字，所以，当改变拷贝的某个属性的时候，原对象的对应属性亦会改变）。
【说明】：本文章由站长整理发布，文章内容不代表本站观点，如文中有侵权行为，请与本站客服联系(QQ:254677821)！