一、前言
这个星期参加了一个面试,面试中问到深浅拷贝的区别,然后我就简单了讲述了它们的之间的区别,然后面试官又继续问,如何实现一个深拷贝呢?当时只回答回答了一种方式,就是使用反射,然后面试官提示还可以通过反序列化和表达树的方式。然后又继续问,如果用反射来实现深拷贝的话,如何解决互相引用对象的问题呢? 当时我给出的答案是说那就不用反射去实现呗,用反序列化实现呗,或者直接避免使两个对象互相引用呗。然后面试官说,如果一定用反射来写,你是怎么去解决这个问题呢?这时候我就愣住了。
这样也就有了这篇文章。今天就来深入解析下深浅拷贝的问题。
二、深拷贝 Vs 浅拷贝
首先,讲到深浅拷贝,自然就有一个问题来了?什么是深拷贝,什么又是浅拷贝呢?下面就具体介绍下它们的定义。
深拷贝:指的是拷贝一个对象时,不仅仅把对象的引用进行复制,还把该对象引用的值也一起拷贝。这样进行深拷贝后的拷贝对象就和源对象互相独立,其中任何一个对象的改动都不会对另外一个对象造成影响。举个例子,一个人叫张三,然后使用克隆技术以张三来克隆另外一个人叫李四,这样张三和李四就是相互独立的,不管张三缺胳膊还是李四少腿了都不会影响另外一个人。在.NET领域,值对象就是典型的例子,如int, Double以及结构体和枚举等。具体例子如下所示:
1
2
3
4
5
6
7
|
int
source = 123;
// 值类型赋值内部执行深拷贝
int
copy = source;
// 对拷贝对象进行赋值不会改变源对象的值
copy = 234;
// 同样对源对象赋值也不会改变拷贝对象的值
source = 345;
|
浅拷贝:指的是拷贝一个对象时,仅仅拷贝对象的引用进行拷贝,但是拷贝对象和源对象还是引用同一份实体。此时,其中一个对象的改变都会影响到另一个对象。例如,一个人一开始叫张三,后来改名字为张老三了,可是他们还是同一个人,不管张三缺胳膊还是张老三少腿,都反应在同一个人身上。在.NET中引用类型就是一个例子。如类类型。具体例子如下所示:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public
class
Person
{
public
string
Name {
get
;
set
; }
}
class
Program
{
static
void
Main(
string
[] args)
{
Person sourceP =
new
Person() { Name =
"张三"
};
Person copyP = sourceP;
// 浅拷贝
copyP.Name =
"张老三"
;
// 拷贝对象改变Name值
// 结果都是"张老三",因为实现的是浅拷贝,一个对象的改变都会影响到另一个对象
Console.WriteLine(
"Person.Name: [SourceP: {0}] [CopyP:{1}]"
, sourceP.Name, copyP.Name);
Console.Read();
}
}
|
三、深浅拷贝的几种实现方式
上面已经明白了深浅拷贝的定义,至于他们之间的区别也在定义中也有所体现。介绍完了它们的定义和区别之后,自然也就有了如何去实现它们呢?
对于,浅拷贝的实现方式很简单,.NET自身也提供了实现。我们知道,所有对象的父对象都是System.Object对象,这个父对象中有一个MemberwiseClone方法,该方法就可以用来实现浅拷贝,下面具体看看浅拷贝的实现方式,具体演示代码如下所示:
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
|
// 继承ICloneable接口,重新其Clone方法
class
ShallowCopyDemoClass : ICloneable
{
public
int
intValue = 1;
public
string
strValue =
"1"
;
public
PersonEnum pEnum = PersonEnum.EnumA;
public
PersonStruct pStruct =
new
PersonStruct() { StructValue = 1};
public
Person pClass =
new
Person(
"1"
);
public
int
[] pIntArray =
new
int
[] { 1 };
public
string
[] pStringArray =
new
string
[] {
"1"
};
#region ICloneable成员
public
object
Clone()
{
return
this
.MemberwiseClone();
}
#endregion
}
class
Person
{
public
string
Name;
public
Person(
string
name)
{
Name = name;
}
}
public
enum
PersonEnum
{
EnumA = 0,
EnumB = 1
}
public
struct
PersonStruct
{
public
int
StructValue;
}
|
上面类中重写了IConeable接口的Clone方法,其实现直接调用了Object的MemberwiseClone方法来完成浅拷贝,如果想实现深拷贝,也可以在Clone方法中实现深拷贝的逻辑。接下来就是对上面定义的类进行浅拷贝测试了,看看是否是实现的浅拷贝,具体演示代码如下所示:
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
|
class
Program
{
static
void
Main(
string
[] args)
{
ShallowCopyDemo();
// List浅拷贝的演示
ListShallowCopyDemo();
}
public
static
void
ListShallowCopyDemo()
{
List<PersonA> personList =
new
List<PersonA>()
{
new
PersonA() { Name=
"PersonA"
, Age= 10, ClassA=
new
A() { TestProperty =
"AProperty"
} },
new
PersonA() { Name=
"PersonA2"
, Age= 20, ClassA=
new
A() { TestProperty =
"AProperty2"
} }
};
// 下面2种方式实现的都是浅拷贝
List<PersonA> personsCopy =
new
List<PersonA>(personList);
PersonA[] personCopy2 =
new
PersonA[2];
personList.CopyTo(personCopy2);
// 由于实现的是浅拷贝,所以改变一个对象的值,其他2个对象的值都会发生改变,因为它们都是使用的同一份实体,即它们指向内存中同一个地址
personsCopy.First().ClassA.TestProperty =
"AProperty3"
;
WriteLog(
string
.Format(
"personCopy2.First().ClassA.TestProperty is {0}"
, personCopy2.First().ClassA.TestProperty));
WriteLog(
string
.Format(
"personList.First().ClassA.TestProperty is {0}"
, personList.First().ClassA.TestProperty));
WriteLog(
string
.Format(
"personsCopy.First().ClassA.TestProperty is {0}"
, personsCopy.First().ClassA.TestProperty));
Console.Read();
}
public
static
void
ShallowCopyDemo()
{
ShallowCopyDemoClass DemoA =
new
ShallowCopyDemoClass();
ShallowCopyDemoClass DemoB = DemoA.Clone()
as
ShallowCopyDemoClass ;
DemoB.intValue = 2;
WriteLog(
string
.Format(
" int->[A:{0}] [B:{1}]"
, DemoA.intValue, DemoB.intValue));
DemoB.strValue =
"2"
;
WriteLog(
string
.Format(
" string->[A:{0}] [B:{1}]"
, DemoA.strValue, DemoB.strValue));
DemoB.pEnum = PersonEnum.EnumB;
WriteLog(
string
.Format(
" Enum->[A: {0}] [B:{1}]"
, DemoA.pEnum, DemoB.pEnum));
DemoB.pStruct.StructValue = 2;
WriteLog(
string
.Format(
" struct->[A: {0}] [B: {1}]"
, DemoA.pStruct.StructValue, DemoB.pStruct.StructValue));
DemoB.pIntArray[0] = 2;
WriteLog(
string
.Format(
" intArray->[A:{0}] [B:{1}]"
, DemoA.pIntArray[0], DemoB.pIntArray[0]));
DemoB.pStringArray[0] =
"2"
;
WriteLog(
string
.Format(
"stringArray->[A:{0}] [B:{1}]"
, DemoA.pStringArray[0], DemoB.pStringArray[0]));
DemoB.pClass.Name =
"2"
;
WriteLog(
string
.Format(
" Class->[A:{0}] [B:{1}]"
, DemoA.pClass.Name, DemoB.pClass.Name));
Console.WriteLine();
}
private
static
void
WriteLog(
string
msg) { Console.WriteLine(msg); } } }
|
上面代码的运行结果如下图所示:
从上面运行结果可以看出,.NET中值类型默认是深拷贝的,而对于引用类型,默认实现的是浅拷贝。所以对于类中引用类型的属性改变时,其另一个对象也会发生改变。
上面已经介绍了浅拷贝的实现方式,那深拷贝要如何实现呢?在前言部分已经介绍了,实现深拷贝的方式有:反射、反序列化和表达式树。在这里,我只介绍反射和反序列化的方式,对于表达式树的方式在网上也没有找到,当时面试官说是可以的,如果大家找到了表达式树的实现方式,麻烦还请留言告知下。下面我们首先来看看反射的实现方式吧:
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
|
// 利用反射实现深拷贝
public
static
T DeepCopyWithReflection<T>(T obj)
{
Type type = obj.GetType();
// 如果是字符串或值类型则直接返回
if
(obj
is
string
|| type.IsValueType)
return
obj;
if
(type.IsArray)
{
Type elementType = Type.GetType(type.FullName.Replace(
"[]"
,
string
.Empty));
var
array = obj
as
Array;
Array copied = Array.CreateInstance(elementType, array.Length);
for
(
int
i = 0; i < array.Length; i++)
{
copied.SetValue(DeepCopyWithReflection(array.GetValue(i)), i);
}
return
(T)Convert.ChangeType(copied, obj.GetType());
}
object
retval = Activator.CreateInstance(obj.GetType());
PropertyInfo[] properties = obj.GetType().GetProperties(
BindingFlags.Public | BindingFlags.NonPublic
| BindingFlags.Instance | BindingFlags.Static);
foreach
(
var
property
in
properties)
{
var
propertyValue = property.GetValue(obj,
null
);
if
(propertyValue ==
null
)
continue
;
property.SetValue(retval, DeepCopyWithReflection(propertyValue),
null
);
}
return
(T)retval;
}
|
反序列化的实现方式,反序列化的方式也可以细分为3种,具体的实现如下所示:
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
|
// 利用XML序列化和反序列化实现
public
static
T DeepCopyWithXmlSerializer<T>(T obj)
{
object
retval;
using
(MemoryStream ms =
new
MemoryStream())
{
XmlSerializer xml =
new
XmlSerializer(
typeof
(T));
xml.Serialize(ms, obj);
ms.Seek(0, SeekOrigin.Begin);
retval = xml.Deserialize(ms);
ms.Close();
}
return
(T)retval;
}
// 利用二进制序列化和反序列实现
public
static
T DeepCopyWithBinarySerialize<T>(T obj)
{
object
retval;
using
(MemoryStream ms =
new
MemoryStream())
{
BinaryFormatter bf =
new
BinaryFormatter();
// 序列化成流
bf.Serialize(ms, obj);
ms.Seek(0, SeekOrigin.Begin);
// 反序列化成对象
retval = bf.Deserialize(ms);
ms.Close();
}
return
(T)retval;
}
// 利用DataContractSerializer序列化和反序列化实现
public
static
T DeepCopy<T>(T obj)
{
object
retval;
using
(MemoryStream ms =
new
MemoryStream())
{
DataContractSerializer ser =
new
DataContractSerializer(
typeof
(T));
ser.WriteObject(ms, obj);
ms.Seek(0, SeekOrigin.Begin);
retval = ser.ReadObject(ms);
ms.Close();
}
return
(T)retval;
}
// 表达式树实现
// ....
|
四、使用反射进行深拷贝如何解决相互引用的问题
上面反射的实现方式,对于相互引用的对象会出现StackOverflower的错误,由于对象的相互引用,会导致方法循环调用。下面就是一个相互引用对象的例子:
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
|
[Serializable]
public
class
DeepCopyDemoClass
{
public
string
Name {
get
;
set
;}
public
int
[] pIntArray {
get
;
set
; }
public
Address Address {
get
;
set
; }
public
DemoEnum DemoEnum {
get
;
set
; }
// DeepCopyDemoClass中引用了TestB对象,TestB类又引用了DeepCopyDemoClass对象,从而造成了相互引用
public
TestB TestB {
get
;
set
;}
public
override
string
ToString()
{
return
"DeepCopyDemoClass"
;
}
}
|