C#中的浅度和深度复制（C#如何复制一个对象）

浅度和深度复制

在C#中，浅度复制（Shallow Copy）和深度复制（Deep Copy）是两种不同的对象复制方式，满足不同的应用场景需求，它们主要区别在于处理引用类型成员的方式不同。

浅度复制

当进行浅复制时，系统会创建一个新的对象实例，这个新对象的值类型字段将与原始对象中的值类型字段具有相同的值，像整数、浮点数、结构体等值类型的数据会在浅复制过程中被完整地复制一份到新对象中。

而对于引用类型字段，则仅仅是复制了引用本身而不是引用的对象内容。比如类实例或数组，它们在内存中存储的是指向实际数据的引用。浅复制时，只会复制这些引用，而不是复制引用所指代的实际数据。所以，原对象和新对象的引用类型成员会共享相同的对象实例。

那么如果一个类中有引用类型的成员变量（比如数组、其他自定义类的对象等），那么浅复制后，新对象和原对象的这些引用类型成员仍然指向同一个内存地址。因此，对任何一个对象的引用类型成员所做的修改都会影响到另一个对象。如果需要完全独立的副本，不共享任何引用类型资源，则需要实现深度复制。

接下来具体实现一个浅度复制。

using System;

class AnotherClass
{
    public string Message = "原来的字符串";
}

class MyClass 
{
    public int Value; // 值类型成员
    public AnotherClass RefObj; // 引用类型成员

    public object Clone() // 实现浅复制
    {
        return this.MemberwiseClone();
    }
}

class Program
{
    static void Main()
    {
        // 创建原始对象
        var original = new MyClass { Value = 10, RefObj = new AnotherClass() };

        // 浅复制
        var shallowCopy = (MyClass)original.Clone();

        // 修改引用类型成员
        shallowCopy.Value = 20;
        shallowCopy.RefObj.Message = "修改了浅复制的引用对象";

        // 检查浅复制结果
        Console.WriteLine("原来的值类型数据: " + original.Value);
        Console.WriteLine("浅度复制的值类型数据: " + shallowCopy.Value);

        // 输出原对象和副本对象的引用类型成员
        Console.WriteLine("原来的引用对象数据（可查看是否被改变）: " + original.RefObj.Message);
        Console.WriteLine("浅度复制的引用对象数据: " + shallowCopy.RefObj.Message);
    }
}

运行结果如下图所示，可以发现原来对象的字符串确实被一同修改了，证明引用的是同一个实例。

深度复制

深度复制不仅复制了原始对象的所有值类型字段，还为所有引用类型字段创建了新的独立副本。这意味着如果一个类包含引用类型成员，在执行深度复制时，不仅复制这些引用，还会递归地复制引用所指向的对象，直到所有的引用都指向全新的对象实例。

因此，通过深度复制得到的新对象是一个完全独立的副本，对新对象的任何更改都不会影响到原始对象及其引用的其他对象。

实现深度复制通常需要显式编写代码来复制每个引用类型字段，并在必要时递归复制其内部的引用类型字段。我们可以实现ICloneable接口并重写Clone()方法来进行自定义的深度复制逻辑，或者直接调用相关的构造函数、序列化/反序列化方法等方式来实现深度复制。

接下来我们看一个实例，假设有一个 Person类，它包含一个引用类型字段 Address，我们为其实现深度复制，代码如下所示：

public class Person : ICloneable
{
    public string Name { get; set; }
    public Address HomeAddress { get; set; } //Address 是一个引用类型

    public object Clone()
    {
        var clone = new Person
        {
            Name = this.Name,
            HomeAddress = (Address)this.HomeAddress.Clone() //Address 类也实现了 ICloneable 接口
        };
        return clone;
    }
}

public class Address : ICloneable
{
    public string Street { get; set; }

    public object Clone()
    {
        return new Address { Street = this.Street };
    }
}

这样，当调用 person.Clone() 方法时，将会创建一个包含全新 Address 对象的新 Person 实例。
然后我们测试一下，深度复制后，是否还是原来的对象。

public class Program
{
    public static void Main()
    {
        // 创建原始 Person 对象
        var originalPerson = new Person
        {
            Name = "水智",
            HomeAddress = new Address { Street = "天桥底下." }
        };

        // 使用 Clone 方法进行深度复制
        var clonedPerson = (Person)originalPerson.Clone();

        // 修改克隆后的 Person 和 Address 对象的属性值
        clonedPerson.Name = "智哥";
        clonedPerson.HomeAddress.Street = "别墅一条街.";

        // 输出原始和克隆对象的属性值，验证它们是否独立
        Console.WriteLine($"原来的姓名: {originalPerson.Name}, 住址: {originalPerson.HomeAddress.Street}");
        Console.WriteLine($"克隆后的姓名: {clonedPerson.Name}, 住址: {clonedPerson.HomeAddress.Street}");
    }
}

在这个示例中，我们首先创建了一个 Person 对象，并设置了它的 Name 和 HomeAddress。然后通过调用 Clone 方法创建了该对象的一个副本。接着，我们修改了复制得到的对象及其引用类型字段的属性值，最后输出原始对象和复制对象的属性值。如果输出结果显示两者属性值不同，那么就证明我们成功实现了深度复制，即复制的对象与原对象是完全独立的。

运行后，我们可以发现，并不是原来的对象，而是创建了一个新的对象，如下图所示。

如何选择

在一些场景下，我们可能只需要复制对象的引用类型成员的引用而不是其实际内容。例如，在某些集合类（如 List）的 CopyTo 方法中，默认就是进行浅复制。

当你确定引用类型的对象在复制后不会被修改，或者多个对象共享同一份数据是合理的情况时，可以使用浅复制来节省内存。

在其他情况下，尤其是当对象包含复杂的引用类型成员，且这些引用类型的成员也需要独立于原对象时，就需要进行深度复制。比如在游戏开发中，角色或物品需要复制时，复制后的对象应当具有独立的状态，不影响原对象和其他副本。

选择合适的复制方式能够确保程序的效率。浅度复制相对快速且占用内存较小，但可能会导致意料之外的数据共享。而深度复制虽然可能消耗更多资源，但它能确保复制出的对象与原对象之间不存在任何关联，更有利于保持数据的一致性和隔离性。

具体用哪个，就根据对象的具体情况以及业务逻辑需求。