浅谈.Net中的浅拷贝和深拷贝

1. 前言

在.Net中，拷贝是一个非常常见的操作。有时候我们需要在对象之间进行数据共享，又不希望对象之间互相干扰，这时候就需要将一个对象拷贝出来，再进行修改和处理。在拷贝的过程中，有时需要进行深拷贝，有时需要进行浅拷贝。因此，在.Net开发中，掌握这两种拷贝方式的使用方法和区别是非常重要的。

2. 浅拷贝

2.1 什么是浅拷贝

浅拷贝是指将一个对象的非静态字段拷贝到另外一个对象中。在拷贝过程中，如果目标对象和源对象具有相同的引用类型，则拷贝后的两个对象会共用一个引用类型变量的内存空间。因此，在修改一个对象中的引用类型变量时，会影响到另外一个对象中的相同引用类型变量。

下面是一个浅拷贝的示例：

class Person
{
    public int Age { get; set; }
    public Address Address { get; set; }
}
class Address
{
    public string City { get; set; }
}
class Program
{
    static void Main(string[] args)
    {
        // 创建一个Person对象
        var person1 = new Person
        {
            Age = 18,
            Address = new Address { City = "北京" }
        };
        // 对person1进行浅拷贝
        var person2 = person1;
        // 修改person2的Address对象
        person2.Address.City = "上海";
        Console.WriteLine(person1.Address.City);  // 输出：上海
        Console.WriteLine(person2.Address.City);  // 输出：上海
    }
}

从上面的代码可以看到，修改person2的Address对象后，person1的Address对象也被修改了。这是因为person1和person2共用了Address对象的内存空间，因此修改其中一个对象中的Address对象，就会同时影响到另外一个对象中的Address对象。

2.2 浅拷贝的实现方式

在.Net中，可以使用ICloneable接口实现浅拷贝。ICloneable接口定义了一个Clone方法，可以用于拷贝对象。默认情况下，Clone方法进行的是浅拷贝。

以下是一个实现ICloneable接口的浅拷贝示例：

class Person : ICloneable
{
    public int Age { get; set; }
    public Address Address { get; set; }
    public object Clone()
    {
        return MemberwiseClone();
    }
}
class Address
{
    public string City { get; set; }
}
class Program
{
    static void Main(string[] args)
    {
        // 创建一个Person对象
        var person1 = new Person
        {
            Age = 18,
            Address = new Address { City = "北京" }
        };
        // 对person1进行浅拷贝
        var person2 = (Person)person1.Clone();
        // 修改person2的Address对象
        person2.Address.City = "上海";
        Console.WriteLine(person1.Address.City);  // 输出：上海
        Console.WriteLine(person2.Address.City);  // 输出：上海
    }
}

在上面的代码中，Person类实现了ICloneable接口，并重写了Clone方法。Clone方法调用了MemberwiseClone方法，该方法可以进行浅拷贝。

3.深拷贝

3.1 什么是深拷贝

深拷贝是指将一个对象的所有字段都拷贝到另外一个对象中。在拷贝过程中，如果目标对象和源对象具有相同的引用类型，则拷贝后的两个对象会分别创建自己的引用类型变量的内存空间。因此，在修改一个对象中的引用类型变量时，不会影响到另外一个对象中的相同引用类型变量。

下面是一个深拷贝的示例：

class Person
{
    public int Age { get; set; }
    public Address Address { get; set; }
}
class Address
{
    public string City { get; set; }
}
class Program
{
    static void Main(string[] args)
    {
        // 创建一个Person对象
        var person1 = new Person
        {
            Age = 18,
            Address = new Address { City = "北京" }
        };
        // 对person1进行深拷贝
        var person2 = DeepCopy(person1);
        // 修改person2的Address对象
        person2.Address.City = "上海";
        Console.WriteLine(person1.Address.City);  // 输出：北京
        Console.WriteLine(person2.Address.City);  // 输出：上海
    }
    // 实现深拷贝
    public static T DeepCopy(T obj)
    {
        using (var ms = new MemoryStream())
        {
            var formatter = new BinaryFormatter();
            formatter.Serialize(ms, obj);
            ms.Position = 0;
            return (T)formatter.Deserialize(ms);
        }
    }
}

从上面的代码可以看到，修改person2的Address对象后，person1的Address对象并没有被修改。这是因为在进行深拷贝时，目标对象和源对象创建了各自的引用类型变量的内存空间，因此修改其中一个对象中的引用类型变量，不会影响到另外一个对象中的相同引用类型变量。

3.2 深拷贝的实现方式

深拷贝的实现方式有很多，这里介绍两种比较常见的方式：

1. 使用二进制流进行深拷贝

上面的示例中，我们使用了二进制流进行深拷贝。该方式将对象进行序列化和反序列化操作，可以将对象及其子对象完整地拷贝出来。

2. 实现自定义的Clone方法

在类中实现自定义的Clone方法，可以根据具体情况对需要拷贝的字段进行递归拷贝。以下是一个使用自定义Clone方法实现深拷贝的示例：

class Person
{
    public int Age { get; set; }
    public Address Address { get; set; }
    public Person Clone()
    {
        return new Person
        {
            Age = this.Age,
            Address = this.Address?.Clone()
        };
    }
}
class Address
{
    public string City { get; set; }
    public Address Clone()
    {
        return new Address
        {
            City = this.City
        };
    }
}
class Program
{
    static void Main(string[] args)
    {
        // 创建一个Person对象
        var person1 = new Person
        {
            Age = 18,
            Address = new Address { City = "北京" }
        };
        // 对person1进行深拷贝
        var person2 = person1.Clone();
        // 修改person2的Address对象
        person2.Address.City = "上海";
        Console.WriteLine(person1.Address.City);  // 输出：北京
        Console.WriteLine(person2.Address.City);  // 输出：上海
    }
}

在上面的代码中，Person和Address类分别实现了自定义的Clone方法，用于递归地拷贝引用类型变量。

4. 总结

在.Net中，浅拷贝和深拷贝是两种常用的拷贝方式。浅拷贝是将一个对象的非静态字段拷贝到另外一个对象中，如果目标对象和源对象具有相同的引用类型，则拷贝后的两个对象会共用一个引用类型变量的内存空间；深拷贝是将一个对象的所有字段都拷贝到另外一个对象中，如果目标对象和源对象具有相同的引用类型，则拷贝后的两个对象会分别创建自己的引用类型变量的内存空间。在进行拷贝操作时，应根据具体情况选择使用浅拷贝或深拷贝，并掌握其实现方式。