深度复制与浅表复制的区别在于,浅表复制只复制值类型的值,而对于实例所包含的对象依然指向原有实例。
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
|
class
Program
{
[Serializable]
public
class
Car
{
public
string
name;
public
Car(
string
name)
{
this
.name = name;
}
}
[Serializable]
public
class
Person:ICloneable
{
public
int
id;
public
string
name;
public
Car car;
public
Person()
{
}
public
Person(
int
id,
string
name, Car car)
{
this
.id = id;
this
.name = name;
this
.car = car;
}
public
Object Clone()
//实现ICloneable接口,达到浅表复制。浅表复制与深度复制无直接有关系。 对外提供一个创建自身的浅表副本的能力
{
return
this
.MemberwiseClone();
}
}
//要复制的实例必须可序列化,包括实例引用的其它实例都必须在类定义时加[Serializable]特性。
public
static
T Copy<T>(T RealObject)
{
using
(Stream objectStream =
new
MemoryStream())
{
//利用 System.Runtime.Serialization序列化与反序列化完成引用对象的复制
IFormatter formatter =
new
BinaryFormatter();
formatter.Serialize(objectStream, RealObject);
objectStream.Seek(0, SeekOrigin.Begin);
return
(T)formatter.Deserialize(objectStream);
}
}
static
void
Main(
string
[] args)
{
Person p1 =
new
Person(1,
"Scott"
,
new
Car(
"宝马"
));
Console.WriteLine(
"原始值:P1:id={0}----------->name={1}------>car={2}"
, p1.id, p1.name, p1.car.name);
Person p2 = Copy<Person>(p1);
//克隆一个对象
Person p3 = p1.Clone()
as
Person;
//浅表复制
Console.WriteLine(
"改变P1的值"
);
p1.id = 2;
p1.name =
"Lacy"
;
p1.car.name =
"红旗"
;
Console.WriteLine(
"P1:id={0}----------->name={1}------>car={2}"
, p1.id, p1.name, p1.car.name);
Console.WriteLine(
"深度复制:P2:id={0}----------->name={1}------>car={2}"
, p2.id, p2.name, p2.car.name);
Console.WriteLine(
"浅表复制:P3:id={0}----------->name={1}------>car={2}"
, p3.id, p3.name, p3.car.name);
Console.ReadKey();
}
|
运行结果:
一、List<T>对象中的T是值类型的情况(int 类型等)
对于值类型的List直接用以下方法就可以复制:
1
2
3
|
List<T> oldList =
new
List<T>();
oldList.Add(..);
List<T> newList =
new
List<T>(oldList);
|
二、List<T>对象中的T是引用类型的情况(例如自定义的实体类)
1、对于引用类型的List无法用以上方法进行复制,只会复制List中对象的引用,可以用以下扩展方法复制:
1
2
3
4
5
6
7
8
|
static
class
Extensions
{
public
static
IList<T> Clone<T>(
this
IList<T> listToClone) where T: ICloneable
{
return
listToClone.Select(item => (T)item.Clone()).ToList();
}
//<SPAN style="COLOR: #000000">当然前题是List中的对象要实现ICloneable接口</SPAN>
}
|
2、另一种用序列化的方式对引用对象完成深拷贝,此种方法最可靠
1
2
3
4
5
6
7
8
9
10
11
12
|
public
static
T Clone<T>(T RealObject)
{
using
(Stream objectStream =
new
MemoryStream())
{
//利用 System.Runtime.Serialization序列化与反序列化完成引用对象的复制
IFormatter formatter =
new
BinaryFormatter();
formatter.Serialize(objectStream, RealObject);
objectStream.Seek(0, SeekOrigin.Begin);
return
(T)formatter.Deserialize(objectStream);
}
}
|
3、利用System.Xml.Serialization来实现序列化与反序列化
1
2
3
4
5
6
7
8
9
10
|
public
static
T Clone<T>(T RealObject)
{
using
(Stream stream=
new
MemoryStream())
{
XmlSerializer serializer =
new
XmlSerializer(
typeof
(T));
serializer.Serialize(stream, RealObject);
stream.Seek(0, SeekOrigin.Begin);
return
(T)serializer.Deserialize(stream);
}
}
|
以上这篇C#复制和深度复制的实现方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。