C# List<T>复制
//--------------忙忙碌碌,从代码的搬运工做起--------------//
在C#中,我们会使用List<T>存储数据,而后,当我们在别处对List<T>中的数据轮询并做逻辑处理时,有时却会发现数据被意外改动了,尤其是在多线程中,这就会引发一系列错误。因此,我们就需要对List<T>做进一步的了解,当然如果你不想了解,那就直接拖到下方看方法代码。
首先呢,我们要有个概念,值类型和引用类型。值类型存放的是实际的值,引用类型存放的是值的引用地址。
啥意思呢,举个不知道恰不恰当的栗子,张三去买厕纸,掏出了一张纸币付款,纸币上写着10元,这个是值类型;张三去买车子,掏出了一张黑不溜秋的银行卡付款,卡上写着银行卡号,这张卡就是引用类型,通过卡号这个地址,可以划扣掉张三账户里的一百万。
//-----------------------------分割线-----------------------------//
- 值类型
测试如下:
byte bValue1 = 0; //打印bValue1 byte bValue2 = bValue1; //打印bValue1 、bValue2 bValue1 = 1; //打印bValue1 、bValue2 bValue2 = 2; //打印bValue1 、bValue2
输出如下:
bValue1-0 *********************** bValue1-0,bValue2-0 *********************** bValue1-1,bValue2-0 *********************** bValue1-1,bValue2-2
结论:
将一个值类型变量的值赋给另一个值类型变量,它传递的是实际的值,对两个变量的操作,结果互不干扰。
- 引用类型
测试如下:
List<byte> lsClone1 = new List<byte>(); lsClone1.Add(1); //打印lsClone1 List<byte> lsClone2 = lsClone1; //打印lsClone1、lsClone2 lsClone1.Add(2); //打印lsClone1、lsClone2 lsClone2.Add(3); //打印lsClone1、lsClone2
输出如下:
ls1-01 *********************** ls1-01 ,ls2-01 *********************** ls1-01 02 ,ls2-01 02 *********************** ls1-01 02 03 ,ls2-01 02 03
结论:
将一个引用类型变量直接赋给另一个引用类型变量,那么它传递的是引用地址,对不同变量的操作,实际上指向的是同个地址,因此两个变量的存储值保持一致。
- 再举个栗子
值类型:发工资这天,老板王五从金库里拿出了1W元给员工张三,又从金库里拿出了一样多的钱给员工李四,他们两个拿了钱各自消费,大家其乐融融。
引用类型:过了一段时间,老板宣布换一种方式发工资,他先给张三发了一把钥匙,说这是金库的钥匙,张三确认了金库里存有1W元,然后再把李四叫进来,给了他一把跟张三一样的钥匙,李四也确认了金库里存有1W元,但是过了不久,张三把金库里的钱取走了,等到李四想去取钱的时候,只能空手而归,于是矛盾产生了,说不定还得打一架。
实际上,方式2可以看作是对引用类型的错误使用。
//-----------------------------分割线-----------------------------//
言归正传,List<T>就属于引用类型,对它的操作就得考虑引用类型的特性。
一般而言,对于List<T>的复制可以分为浅拷贝和深拷贝两种。
浅拷贝就是将变量A的引用地址复制给变量B,变量A与变量B指向同个地址,因此A与B对实际内容的修改是同步的。
深拷贝是给变量B重新分配一个地址,把变量A地址指向的内容复制给B,因此A与B对实际内容的修改是互不干扰的。
深复制的方式可以有反射、序列化等很多种,就个人理解而言,为了达到重新分配地址的目的,可以将引用类型转换成值类型,再重新转换回引用类型,比如利用Json的序列化与反序列化,或者是遍历List<T>,在值类型的层次将所有项重新赋值。
在百度上搜了一下,找了几种方法,如下所示:
方法1:利用Json的序列化与反序列化,需要引用Newtonsoft.Json
public static List<T> Clone_ByJson<T>(this List<T> list) where T : new() { var str = JsonConvert.SerializeObject(list); return JsonConvert.DeserializeObject<List<T>>(str); }
方法2:利用反射
public static List<T> Clone_ByProperties<T>(this List<T> list) where T : new() { List<T> items = new List<T>(); foreach (var m in list) { var model = new T(); var ps = model.GetType().GetProperties(); var properties = m.GetType().GetProperties(); foreach (var p in properties) { foreach (var pm in ps) { if (pm.Name == p.Name) { pm.SetValue(model, p.GetValue(m)); } } } items.Add(model); } return items; }
方法3:利用IFormatter的序列化与反序列化,需要引用System.Runtime.Serialization等,需要实体类有[Serializable]特性
public static List<T> Clone_ByStream<T>(this List<T> list) { using (Stream objectStream = new MemoryStream()) { IFormatter formatter = new BinaryFormatter(); formatter.Serialize(objectStream, list); objectStream.Seek(0, SeekOrigin.Begin); return (List<T>)formatter.Deserialize(objectStream); } }
测试:
[Serializable]//方法3需要 public class TestClone { public TestClone() { ID = 0; Items = new byte[] { 0, 1 }; Remark = ""; } public int ID { get; set; } public byte[] Items { get; set; } public string Remark { get; set; } } private void button_Click(object sender, EventArgs e) { List<TestClone> clone = new List<TestClone>(); int i = 0; TestClone c = new TestClone(); i = 1; c.ID = i; c.Items = new byte[] { 1, 2, 3 }; c.Remark = "No.1"; clone.Add(c); //打印clone:count-1,index-0,1-[01 02 03 ]-No.1 i = 2; c.ID = i; c.Items = new byte[] { 2, 2, 2 }; c.Remark = "No.2"; clone.Add(c); //打印clone count-2,index-0,2-[02 02 02 ]-No.2 //可以看到元素0的Items项被改变了,元素0跟元素1指向的地址是相同的
count-2,index-1,2-[02 02 02 ]-No.2 c = new TestClone(); i = 3; c.ID = i; c.Items = new byte[] { 3, 3, 3 }; c.Remark = "No.3"; clone.Add(c); //打印clone:count-3,index-0,2-[02 02 02 ]-No.2
count-3,index-1,2-[02 02 02 ]-No.2
count-3,index-2,3-[03 03 03 ]-No.3 //新加的元素2是将c重新new了,所以不会影响前两个元素的Items项 TestClone c1 = new TestClone(); i = 4; c1.ID = i; c1.Items = new byte[] { 4, 4, 4 }; c1.Remark = "No.4"; clone.Add(c1); //打印clone:count-4,index-0,2-[02 02 02 ]-No.2
count-4,index-1,2-[02 02 02 ]-No.2
count-4,index-2,3-[03 03 03 ]-No.3
count-4,index-3,4-[04 04 04 ]-No.4 //新定义的c1,自然也不会影响前面的元素
List<TestClone> clone1 = clone; List<TestClone> clone2 = StaticLogic.Clone_ByJson(clone); List<TestClone> clone3 = StaticLogic.Clone_ByProperties(clone); List<TestClone> clone4 = StaticLogic.Clone_ByStream(clone); clone[0].Items = new byte[] { 0, 0, 0 }; clone[0].Remark = "No.1.1.1";
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
clone,count-4,index-0,2-[00 00 00 ]-No.1.1.1 clone,count-4,index-1,2-[00 00 00 ]-No.1.1.1 clone,count-4,index-2,3-[03 03 03 ]-No.3 clone,count-4,index-3,4-[04 04 04 ]-No.4 *********************** //直接将clone赋给clone1,则clone与clone1的变化是同步的 clone1,count-4,index-0,2-[00 00 00 ]-No.1.1.1 clone1,count-4,index-1,2-[00 00 00 ]-No.1.1.1 clone1,count-4,index-2,3-[03 03 03 ]-No.3 clone1,count-4,index-3,4-[04 04 04 ]-No.4 *********************** //使用方法1将clone复制给clone2,可以看到对clone的修改不影响clone2 clone2,count-4,index-0,2-[02 02 02 ]-No.2 clone2,count-4,index-1,2-[02 02 02 ]-No.2 clone2,count-4,index-2,3-[03 03 03 ]-No.3 clone2,count-4,index-3,4-[04 04 04 ]-No.4 *********************** //使用方法2将clone复制给clone3,可以看到对clone的修改不影响clone3 clone3,count-4,index-0,2-[02 02 02 ]-No.2 clone3,count-4,index-1,2-[02 02 02 ]-No.2 clone3,count-4,index-2,3-[03 03 03 ]-No.3 clone3,count-4,index-3,4-[04 04 04 ]-No.4 *********************** //使用方法3将clone复制给clone4,可以看到对clone的修改不影响clone4 clone4,count-4,index-0,2-[02 02 02 ]-No.2 clone4,count-4,index-1,2-[02 02 02 ]-No.2 clone4,count-4,index-2,3-[03 03 03 ]-No.3 clone4,count-4,index-3,4-[04 04 04 ]-No.4
clone2[0].Items = new byte[] { 0, 0, 0 }; clone2[0].Remark = "No.1.1.2"; //打印clone2:count-4,index-0,2-[00 00 00 ]-No.1.1.2
count-4,index-1,2-[02 02 02 ]-No.2 //对元素0的修改不会影响元素1,此时元素0跟元素1指向的地址已经不同
count-4,index-2,3-[03 03 03 ]-No.3
count-4,index-3,4-[04 04 04 ]-No.4 clone3[0].Items = new byte[] { 0, 0, 0 }; clone3[0].Remark = "No.1.1.3"; //打印clone3:count-4,index-0,2-[00 00 00 ]-No.1.1.3
count-4,index-1,2-[02 02 02 ]-No.2 //对元素0的修改不会影响元素1,此时元素0跟元素1指向的地址已经不同
count-4,index-2,3-[03 03 03 ]-No.3
count-4,index-3,4-[04 04 04 ]-No.4 clone4[0].Items = new byte[] { 0, 0, 0 }; clone4[0].Remark = "No.1.1.4"; //打印clone4:count-4,index-0,2-[00 00 00 ]-No.1.1.4
count-4,index-1,2-[00 00 00 ]-No.1.1.4 //对元素0的修改会影响元素1,此时元素0与元素1指向的地址是相同的
count-4,index-2,3-[03 03 03 ]-No.3
count-4,index-3,4-[04 04 04 ]-No.4 }
结论:
抛开性能的角度不讲,三种方法都可以实现List<T>的深复制,其中,方法1与方法2类似,会将原来指向同一地址的不同元素重新分配成不同地址,方法3则保留跟原来List<T>一致的特征。
//--------------勤勤恳恳,做一只搬运知识的蚂蚁--------------//
本文来自博客园,作者:MaQaQ,转载请注明原文链接:https://www.cnblogs.com/magicMaQaQ/p/15001715.html
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文链接,否则保留追究法律责任的权利。