备案控制台
开发者社区 开发与运维 文章 正文

[C#进阶系列]专题一：深入解析深拷贝和浅拷贝

2017-11-03 1211
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

一、前言

　　这个星期参加了一个面试，面试中问到深浅拷贝的区别，然后我就简单了讲述了它们的之间的区别，然后面试官又继续问，如何实现一个深拷贝呢？当时只回答回答了一种方式，就是使用反射，然后面试官提示还可以通过反序列化和表达树的方式。然后又继续问，如果用反射来实现深拷贝的话，如何解决互相引用对象的问题呢？ 当时我给出的答案是说那就不用反射去实现呗，用反序列化实现呗，或者直接避免使两个对象互相引用呗。然后面试官说，如果一定用反射来写，你是怎么去解决这个问题呢？这时候我就愣住了。

　　这样也就有了这篇文章。今天就来深入解析下深浅拷贝的问题。

二、深拷贝 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" ;
         }
     }
 
     [Serializable]
     public  class  TestB
     {
         public  string  Property1 {  get ;  set ; }
 
         public  DeepCopyDemoClass DeepCopyClass {  get ;  set ; }
 
         public  override  string  ToString()
         {
             return  "TestB Class" ;
         }
     }
 
     [Serializable]
     public  struct  Address
     {
         public  string  City {  get ;  set ; }
     }
 
     public  enum  DemoEnum
     {
         EnumA = 0,
         EnumB = 1
     }

　　在面试过程中，针对这个问题的解决方式我回答的是不知道，回来之后思考了之后，也就有了点思路。首先想到的是：能不能用一个字典来记录每个对象被反射的次数，仔细想想可行，于是开始实现，初步修复后的反射实现如下所示：

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
public  class  DeepCopyHelper
     {
         // 用一个字典来存放每个对象的反射次数来避免反射代码的循环递归
         static  Dictionary<Type,  int > typereflectionCountDic =  new  Dictionary<Type,  int >();
 
  public  static  T DeepCopyWithReflection_Second<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_Second(array.GetValue(i)), i);
                 }
 
                 return  (T)Convert.ChangeType(copied, obj.GetType());
             }
 
             // 对于类类型开始记录对象反射的次数
             int  reflectionCount = Add(typereflectionCountDic, obj.GetType());
             if  (reflectionCount > 1)
                 return  obj;  // 这里有错误
 
             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_Second(propertyValue),  null );
             }
 
             return  (T)retval;
         }
         private  static  int  Add(Dictionary<Type,  int > dict, Type key)
         {
             if  (key.Equals( typeof (String)) || key.IsValueType)  return  0;
             if  (!dict.ContainsKey(key))
             {
                 dict.Add(key, 1);
                 return  dict[key];
             }
 
             dict[key] += 1;
             return  dict[key];
         }
}

　　下面用代码来测试下上面的代码是否已经解决了循环递归的问题，具体的测试代码如下所示：

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
class  Program
     {
         static  void  Main( string [] args)
         {
             //ShallowCopyDemo();
             //ListShallowCopyDemo();
             DeepCopyDemo();
             DeepCopyDemo2();
         }
         private  static  void  WriteLog( string  msg)
         {
             Console.WriteLine(msg);
         }
 
         public  static  void  DeepCopyDemo()
         {
             DeepCopyDemoClass deepCopyClassA =  new  DeepCopyDemoClass();
             deepCopyClassA.Name =  "DeepCopyClassDemo" ;
             deepCopyClassA.pIntArray =  new  int [] { 1 };
             deepCopyClassA.DemoEnum = DemoEnum.EnumA;
             deepCopyClassA.Address =  new  Address() { City =  "Shanghai"  };
 
             deepCopyClassA.TestB =  new  TestB() { Property1 =  "TestProperty" , DeepCopyClass = deepCopyClassA };
 
             // 使用反序列化来实现深拷贝
             DeepCopyDemoClass deepCopyClassB = DeepCopyHelper.DeepCopyWithBinarySerialize<DeepCopyDemoClass>(deepCopyClassA);
             deepCopyClassB.Name =  "DeepCopyClassDemoB" ;
             WriteLog( string .Format( "    Name->[A:{0}] [B:{1}]" , deepCopyClassA.Name, deepCopyClassB.Name));
             deepCopyClassB.pIntArray[0] = 2;
             WriteLog( string .Format( "    intArray->[A:{0}] [B:{1}]" , deepCopyClassA.pIntArray[0], deepCopyClassB.pIntArray[0]));
             deepCopyClassB.Address =  new  Address() { City =  "Beijing"  };
             WriteLog( string .Format( "    Addressstruct->[A: {0}] [B: {1}]" , deepCopyClassA.Address.City, deepCopyClassB.Address.City));
             deepCopyClassB.DemoEnum = DemoEnum.EnumB;
             WriteLog( string .Format( "    DemoEnum->[A: {0}] [B: {1}]" , deepCopyClassA.DemoEnum, deepCopyClassB.DemoEnum));
             deepCopyClassB.TestB.Property1 =  "TestPropertyB" ;
             WriteLog( string .Format( "    Property1->[A:{0}] [B:{1}]" , deepCopyClassA.TestB.Property1, deepCopyClassB.TestB.Property1));
             WriteLog( string .Format( "    TestB.DeepCopyClass.Name->[A:{0}] [B:{1}]" , deepCopyClassA.TestB.DeepCopyClass.Name, deepCopyClassB.TestB.DeepCopyClass.Name));
             Console.WriteLine();
         }
 
         public  static  void  DeepCopyDemo2()
         {
             DeepCopyDemoClass deepCopyClassA =  new  DeepCopyDemoClass();
             deepCopyClassA.Name =  "DeepCopyClassDemo" ;
             deepCopyClassA.pIntArray =  new  int [] { 1, 2 };
             deepCopyClassA.DemoEnum = DemoEnum.EnumA;
             deepCopyClassA.Address =  new  Address() { City =  "Shanghai"  };
 
             deepCopyClassA.TestB =  new  TestB() { Property1 =  "TestProperty" ,  DeepCopyClass = deepCopyClassA };
 
             // 使用反射来完成深拷贝
             DeepCopyDemoClass deepCopyClassB = DeepCopyHelper.DeepCopyWithReflection_Second<DeepCopyDemoClass>(deepCopyClassA);
 
             //DeepCopyDemoClass deepCopyClassB = DeepCopyHelper.DeepCopyWithReflection<DeepCopyDemoClass>(deepCopyClassA);
             deepCopyClassB.Name =  "DeepCopyClassDemoB" ;
             WriteLog( string .Format( "    Name->[A:{0}] [B:{1}]" , deepCopyClassA.Name, deepCopyClassB.Name));
             deepCopyClassB.pIntArray[0] = 2;
             WriteLog( string .Format( "    intArray->[A:{0}] [B:{1}]" , deepCopyClassA.pIntArray[0], deepCopyClassB.pIntArray[0]));
             deepCopyClassB.Address =  new  Address() { City =  "Beijing"  };
             WriteLog( string .Format( "    Addressstruct->[A: {0}] [B: {1}]" , deepCopyClassA.Address.City, deepCopyClassB.Address.City));
             deepCopyClassB.DemoEnum = DemoEnum.EnumB;
             WriteLog( string .Format( "    DemoEnum->[A: {0}] [B: {1}]" , deepCopyClassA.DemoEnum, deepCopyClassB.DemoEnum));
             deepCopyClassB.TestB.Property1 =  "TestPropertyB" ;
             WriteLog( string .Format( "    Property1->[A:{0}] [B:{1}]" , deepCopyClassA.TestB.Property1, deepCopyClassB.TestB.Property1));
             WriteLog( string .Format( "    TestB.DeepCopyClass.Name->[A:{0}] [B:{1}]" , deepCopyClassA.TestB.DeepCopyClass.Name, deepCopyClassB.TestB.DeepCopyClass.Name));
             Console.ReadKey();
         }
     }

　　此时的运行结果如下图所示：

　　刚开始看到这样的运行结果，开心地以为已经解决了循环递归的问题了，因为此时结果成功运行出来了，没有了StackOverflower的错误了。但是仔细一看，反序列化和反射完成的深拷贝的运行结果不一样，如上图中红色圈出来的部分。显然，反序列化的结果是没有错误的，显然目前实现的反射代码还是有问题的。接下来就是思考了。为什么上面反射的代码不正确呢？

　　仔细分析DeepCopyWithReflection_Second中的代码，发现下面代码红色部分是错误的：

1
int  reflectionCount = Add(typereflectionCountDic, obj.GetType());             if  (reflectionCount > 1)                 return  obj;  // 是错误的

　　对DeepCopyWithReflection_Second方法仔细分析，在对TestB进行反射时，当反射到DeepCopyClass属性时，此时会递归调用DeepCopyWithReflection_Second方法，此时在typereflectionCountDic发现DeepCopyDemoClass已经被反射了，则直接返回，这样分析好像没什么错误，但是此时返回的是deepCopyClassA对象，但是我们需要返回的是deepCopyClassB对象，即此时deepCopyClassB对象的内存结构如下图所示：

 

　　而我们其实需要deepCopyClassB对象的内存结构如下图所示：

　　既然找到了DeepCopyWithReflection_Second的错误原因，那我们就要解决了。上面说我们返回的应该是deepCopyClassB对象，而我们怎么得到创建的deepCopyClassB对象呢？这里我就想能不能用一个变量来保存一开始通过CreateInstance方法创建的deepCopyClassB对象呢？验证想法最好的办法就是代码了，这样我就按照这个思路对DeepCopyWithReflection_Second又进行一次改进，最终的代码如下所示：

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
public  static  T DeepCopyWithReflection_Third<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_Second(array.GetValue(i)), i);
                 }
 
                 return  (T)Convert.ChangeType(copied, obj.GetType());
             }
 
             int  reflectionCount = Add(typereflectionCountDic, obj.GetType());
             if  (reflectionCount > 1 && obj.GetType() ==  typeof (DeepCopyDemoClass))
                 return  (T)DeepCopyDemoClasstypeRef;  // 返回deepCopyClassB对象
 
             object  retval = Activator.CreateInstance(obj.GetType());
 
             if (retval.GetType() ==  typeof (DeepCopyDemoClass))
                 DeepCopyDemoClasstypeRef = retval;  // 保存一开始创建的DeepCopyDemoClass对象
 
             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_Third(propertyValue),  null );
             }
 
             return  (T)retval;
         }

    下面我用DeepCopyWithReflection_Third方法来测试下，具体的测试代码如下所示：

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
class  Program
     {
         static  void  Main( string [] args)
         {
             //ShallowCopyDemo();
             //ListShallowCopyDemo();
             DeepCopyDemo();
             DeepCopyDemo2();
         }
          private  static  void  WriteLog( string  msg)
         {
             Console.WriteLine(msg);
         }
 
         public  static  void  DeepCopyDemo()
         {
             DeepCopyDemoClass deepCopyClassA =  new  DeepCopyDemoClass();
             deepCopyClassA.Name =  "DeepCopyClassDemo" ;
             deepCopyClassA.pIntArray =  new  int [] { 1 };
             deepCopyClassA.DemoEnum = DemoEnum.EnumA;
             deepCopyClassA.Address =  new  Address() { City =  "Shanghai"  };
 
             deepCopyClassA.TestB =  new  TestB() { Property1 =  "TestProperty" , DeepCopyClass = deepCopyClassA };
 
             // 使用反序列化来实现深拷贝
             DeepCopyDemoClass deepCopyClassB = DeepCopyHelper.DeepCopyWithBinarySerialize<DeepCopyDemoClass>(deepCopyClassA);
             deepCopyClassB.Name =  "DeepCopyClassDemoB" ;
             WriteLog( string .Format( "    Name->[A:{0}] [B:{1}]" , deepCopyClassA.Name, deepCopyClassB.Name));
             deepCopyClassB.pIntArray[0] = 2;
             WriteLog( string .Format( "    intArray->[A:{0}] [B:{1}]" , deepCopyClassA.pIntArray[0], deepCopyClassB.pIntArray[0]));
             deepCopyClassB.Address =  new  Address() { City =  "Beijing"  };
             WriteLog( string .Format( "    Addressstruct->[A: {0}] [B: {1}]" , deepCopyClassA.Address.City, deepCopyClassB.Address.City));
             deepCopyClassB.DemoEnum = DemoEnum.EnumB;
             WriteLog( string .Format( "    DemoEnum->[A: {0}] [B: {1}]" , deepCopyClassA.DemoEnum, deepCopyClassB.DemoEnum));
             deepCopyClassB.TestB.Property1 =  "TestPropertyB" ;
             WriteLog( string .Format( "    Property1->[A:{0}] [B:{1}]" , deepCopyClassA.TestB.Property1, deepCopyClassB.TestB.Property1));
             WriteLog( string .Format( "    TestB.DeepCopyClass.Name->[A:{0}] [B:{1}]" , deepCopyClassA.TestB.DeepCopyClass.Name, deepCopyClassB.TestB.DeepCopyClass.Name));
             Console.WriteLine();
         }
 
         public  static  void  DeepCopyDemo2()
         {
             DeepCopyDemoClass deepCopyClassA =  new  DeepCopyDemoClass();
             deepCopyClassA.Name =  "DeepCopyClassDemo" ;
             deepCopyClassA.pIntArray =  new  int [] { 1, 2 };
             deepCopyClassA.DemoEnum = DemoEnum.EnumA;
             deepCopyClassA.Address =  new  Address() { City =  "Shanghai"  };
 
             deepCopyClassA.TestB =  new  TestB() { Property1 =  "TestProperty" ,  DeepCopyClass = deepCopyClassA };
 
             // 使用反射来完成深拷贝
             DeepCopyDemoClass deepCopyClassB = DeepCopyHelper.DeepCopyWithReflection_Third<DeepCopyDemoClass>(deepCopyClassA);
 
             //DeepCopyDemoClass deepCopyClassB = DeepCopyHelper.DeepCopyWithReflection<DeepCopyDemoClass>(deepCopyClassA);
             deepCopyClassB.Name =  "DeepCopyClassDemoB" ;
             WriteLog( string .Format( "    Name->[A:{0}] [B:{1}]" , deepCopyClassA.Name, deepCopyClassB.Name));
             deepCopyClassB.pIntArray[0] = 2;
             WriteLog( string .Format( "    intArray->[A:{0}] [B:{1}]" , deepCopyClassA.pIntArray[0], deepCopyClassB.pIntArray[0]));
             deepCopyClassB.Address =  new  Address() { City =  "Beijing"  };
             WriteLog( string .Format( "    Addressstruct->[A: {0}] [B: {1}]" , deepCopyClassA.Address.City, deepCopyClassB.Address.City));
             deepCopyClassB.DemoEnum = DemoEnum.EnumB;
             WriteLog( string .Format( "    DemoEnum->[A: {0}] [B: {1}]" , deepCopyClassA.DemoEnum, deepCopyClassB.DemoEnum));
             deepCopyClassB.TestB.Property1 =  "TestPropertyB" ;
             WriteLog( string .Format( "    Property1->[A:{0}] [B:{1}]" , deepCopyClassA.TestB.Property1, deepCopyClassB.TestB.Property1));
             WriteLog( string .Format( "    TestB.DeepCopyClass.Name->[A:{0}] [B:{1}]" , deepCopyClassA.TestB.DeepCopyClass.Name, deepCopyClassB.TestB.DeepCopyClass.Name));
             Console.ReadKey();
         }
}

    此时的运行结果如下图示所示：

　　

　　从上面的测试结果可以看出，此时深拷贝的反射实现方法基本上没什么问题了。这个方法也同时解决了相互引用对象的循环递归问题。

五、总结

　　到这里，该文章的内容就结束。这里主要记录下自己在一次面试过程中遇到问题的一次总结，从中可以看出，反射进行深拷贝会有很多其他的问题，所以平时还是建议大家使用序列化的形式来进行深拷贝。

　　最后附上本文所有源码下载：DeepCopy.zip





     本文转自LearningHard 51CTO博客，原文链接：http://blog.51cto.com/learninghard/1625985，如需转载请自行联系原作者


文章标签：
云解析DNS
C#
关键词：
C#解析
c#云解析DNS
C#深拷贝
技术小胖子
目录
相关文章
小小娥子
|
2月前
|
C语言
【进阶C语言】数组笔试题解析
【进阶C语言】数组笔试题解析
小小娥子
21 0
小万哥丶
|
4月前
|
Java C#
C# 面向对象编程解析：优势、类和对象、类成员详解
OOP代表面向对象编程。 过程式编程涉及编写执行数据操作的过程或方法，而面向对象编程涉及创建包含数据和方法的对象。 面向对象编程相对于过程式编程具有几个优势： OOP执行速度更快，更容易执行 OOP为程序提供了清晰的结构 OOP有助于保持C#代码DRY（"不要重复自己"），并使代码更易于维护、修改和调试 OOP使得能够创建完全可重用的应用程序，编写更少的代码并减少开发时间 提示："不要重复自己"（DRY）原则是有关减少代码重复的原则。应该提取出应用程序中常见的代码，并将其放置在单一位置并重复使用，而不是重复编写。
小万哥丶
52 0
是Nero哦
|
5月前
|
存储 程序员 编译器
c语言进阶部分详解（详细解析动态内存管理）
c语言进阶部分详解（详细解析动态内存管理）
是Nero哦
53 0
然然学长
|
4天前
|
存储 开发框架 .NET
C#中将DataTable转化成ListT的方法解析
C#中将DataTable转化成ListT的方法解析
然然学长
6 0
然然学长
|
4天前
|
XML 存储 开发框架
c#教你网站数据轻松解析抓取，HtmlAgilityPack解析的奇妙之处
c#教你网站数据轻松解析抓取，HtmlAgilityPack解析的奇妙之处
然然学长
8 0
东北赵四
|
20天前
|
Java Spring
Javaweb之SpringBootWeb案例之事务进阶的详细解析
Javaweb之SpringBootWeb案例之事务进阶的详细解析
东北赵四
12 0
xiaohua616
|
23天前
|
XML C# 数据格式
C# 解析XML文件
C# 解析XML文件
xiaohua616
26 1
奔跑的数据
|
2月前
|
数据采集 API C#
网页解析高手：C#和HtmlAgilityPack教你下载视频
使用C#和HtmlAgilityPack解析小红书网页，下载其视频内容。文章涵盖了解析网页、获取视频链接、C#实现、HtmlAgilityPack简化解析、代理IP确保下载稳定及多线程提高下载效率。提供的代码示例展示了如何设置代理和多线程下载视频。实验结果显示，该方法能有效、高效地下载小红书视频。
奔跑的数据
33 5
网页解析高手：C#和HtmlAgilityPack教你下载视频
泡沫o0
|
2月前
|
存储 安全 程序员
【C++ 包装器类 智能指针】完全教程：std::unique_ptr、std::shared_ptr、std::weak_ptr的用法解析与优化 — 初学者至进阶指南
【C++ 包装器类 智能指针】完全教程：std::unique_ptr、std::shared_ptr、std::weak_ptr的用法解析与优化 — 初学者至进阶指南
泡沫o0
75 0
图灵重生我名苏泽
|
2月前
|
安全 Java 数据安全/隐私保护
【Spring底层原理高级进阶】【SpringCloud整合Spring Security OAuth2】深入了解 Spring Security OAuth2：底层解析＋使用方法+实战
【Spring底层原理高级进阶】【SpringCloud整合Spring Security OAuth2】深入了解 Spring Security OAuth2：底层解析＋使用方法+实战
图灵重生我名苏泽
100 0

热门文章

最新文章

  • 1
    C# 设置word文档页面大小
  • 2
    (C#)Windows Shell 编程系列3 - 上下文菜单(iContextMenu)（一）右键菜单
  • 3
    C# 冒泡排序你还会吗？
  • 4
    Silverlight C# 游戏开发：Flyer02 从第一行代码写起
  • 5
    微软收购Xamarin或许对C#开发者是个好消息
  • 6
    C#注册控件处理程序（SetConsoleCtrlHandler）函数示例 控制台关闭事件改写
  • 7
    C# WinForm登录窗口代码
  • 8
    C#中double.tostring()的用法
  • 9
    如何在 C#中的listView 控件中显示图片？
  • 10
    《CLR Via C# 第3版》笔记之（十五） - 接口
  • 1
    Java必刷入门递归题×5（内附详细递归解析图）
    26
  • 2
    【进阶C语言】数组笔试题解析
    21
  • 3
    哲学家解析Sora本质，AI视频离世界模拟器还有多远？
    32
  • 4
    HashMap源码全面解析
    43
  • 5
    Qt 5.14.2 深度解析：打造高效JSON处理利器
    55
  • 6
    机器学习的魔法（三）解析无监督学习的黑科技，揭秘新闻话题背后的神奇算法
    26
  • 7
    argparse的基本使用--参数解析
    35
  • 8
    机器学习-可解释性机器学习：随机森林与fastshap的可视化模型解析
    154
  • 9
    请描述如何使用`BeautifulSoup`或其他类似的库来解析 HTML 或 XML 数据。
    28
  • 10
    数据库核心术语解析与应用
    65

    • 相关课程

    更多
  • 第八届大学生创新创业大赛阿里命题IoT赛题解析
  • 云计算工程师解析与实战-网络专家篇（体验版）
  • 深入解析Docker容器化技术
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计

    • 相关电子书

    更多
  • 神龙云服务器产品及技术深度解析
  • 弹性创造价值：基于ECS的最佳性价比实践解析
  • 又快又稳：阿里云下一代虚拟交换机解析

    • 相关实验场景

    更多
  • 通过云拨测对指定服务器进行Ping/DNS监测

    • 推荐镜像

    更多
  • DNS
  • kali-security
  • kali
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）