C#中的对象深拷贝和浅拷贝

概述

在C#中，对象拷贝是指将一个对象的副本创建到另一个对象中。对象拷贝通常用于数据传输或创建对象的新实例。

C#中有两种主要的拷贝方式：浅拷贝和深拷贝

1. 浅拷贝

浅拷贝是指只拷贝对象的值类型成员，而引用类型成员的引用则保持不变。这意味着新的对象和原始对象将共享所有引用类型成员的实际对象。

实现方式

  • this.MemberwiseClone();

示例代码

实体

  1. public class Person
  2. {
  3.     public Person()
  4.     {
  5.         this.Address = new Address();
  6.     }
  7.     public string Name { get; set; }
  8.      public int Age { get; set; }
  9.     public Address Address { get; set; }
  11.     public Person Clone()
  12.     {
  13.         return (Person)this.MemberwiseClone();
  14.     }
  15. }
  17. public class Address
  18. {
  19.     public string Street { get; set; }
  20.     public string City { get; set; }
  21. }

调用

  1.  Person person1 = new Person()
  2.  {
  3.      Name = "张三",
  4.      Address = new Address()
  5.      {
  6.          City = "北京",
  7.      }
  8.  };
  10.  Person person2 = person1.Clone();//浅拷贝
  11.  //修改原对象的属性
  12.  person1.Address.City = "上海";
  13.  //修改副本对象的属性
  14.  person2.Name = "李四";
  15.  person2.Address.City = "昆明";
  16.  string result = $"原对象{JsonConvert.SerializeObject(person1)}。副本{JsonConvert.SerializeObject(person2)}";
  17.  MessageBox.Show($"浅拷贝：原对象和副本修改引用类型属性后相互影响。{result}");

2. 深拷贝

深拷贝是指不仅拷贝对象的值类型成员，而且还拷贝所有引用类型成员的实际对象。这意味着新的对象将拥有其引用类型成员的完全独立副本。

实现方式

  • 反射
  • 序列化
  • 对象映射（三方开源如TinyMapper、AutoMapper）。

示例代码

  1. /// <summary>
  2. /// 深拷贝
  3. /// </summary>
  4. public static void Copy2()
  5. {
  6.     Person person1 = new Person()
  7.     {
  8.         Name = "张三",
  9.         Address = new Address()
  10.         {
  11.             City = "北京",
  12.         }
  13.     };
  15.     //Person person2 = CreateDeepCopy(person1);//深拷贝1反射
  16.     // Person person2 =JsonConvert.DeserializeObject<Person>(JsonConvert.SerializeObject(person1));//深拷贝2序列化
  17.     Person person2 =person1.MapTo<Person,Person>();//深拷贝3对象映射
  18.     //修改原对象的属性
  19.     person1.Address.City = "上海";
  20.     //修改副本对象的属性
  21.     person2.Name = "李四";
  22.     person2.Address.City = "昆明";
  23.     string result = $"原对象{JsonConvert.SerializeObject(person1)}。副本{JsonConvert.SerializeObject(person2)}";
  24.     MessageBox.Show($"深拷贝：原对象和副本不相互影响。{result}");
  25. }
  28. /// <summary>
  29. /// 使用反射进行深拷贝
  30. /// </summary>
  31. /// <typeparam name="T"></typeparam>
  32. /// <param name="original"></param>
  33. /// <returns></returns>
  34. static T CreateDeepCopy<T>(T original)
  35. {
  36.     if (original == null)
  37.     {
  38.         return default(T);
  39.     }
  41.     Type type = original.GetType();
  42.     object newObject = Activator.CreateInstance(type);
  44.     foreach (FieldInfo fieldInfo in type.GetFields())
  45.     {
  46.         if (fieldInfo.IsStatic)
  47.         {
  48.             continue;
  49.         }
  51.         object value = fieldInfo.GetValue(original);
  52.         fieldInfo.SetValue(newObject, CreateDeepCopy(value));
  53.     }
  55.     return (T)newObject;
  56. }

总结

浅拷贝通常用于数据传输，因为它是快速且有效的。但是，如果需要避免意外修改原始对象，则应使用深拷贝。

以下是一些有关何时使用浅拷贝和深拷贝的准则：

  • 使用浅拷贝：
    • 当需要快速创建对象副本时
    • 当原始对象不可变时
    • 当原始对象和副本不会同时使用时
  • 使用深拷贝：
    • 当需要避免意外修改原始对象时
    • 当原始对象和副本需要同时使用时
    • 当原始对象包含引用类型成员时

引用