C# 深拷贝：从翻车到「版本答案」

前言

几年前写过一个 bug，根因很土：该深拷贝的地方没深拷贝，副本一改，原件跟着变。排查的时候老板以为动的是库里的数据，其实就是一个本地对象被共享了。

先把词说清楚：

浅拷贝：值类型复制一份；引用类型复制的是引用，两边还指着同一个子对象。你改副本里的引用成员，原件也会变。

只复制对象自身的一层：字段/属性里如果是值类型，会复制一份值；如果是引用类型，复制的是引用（指针），新旧对象仍指向同一块堆上的子对象。

深拷贝：引用链上也建新对象，改副本不该动到原件的嵌套数据。

从根对象开始，递归地为引用类型也创建新实例，并把内容复制过去，直到整棵「对象图」在逻辑上独立。改拷贝不应意外改动原对象里的嵌套数据。

ICloneable：能深，但接口不保证

ICloneable 只有一个 object Clone()，文档不会替你承诺浅还是深，看实现。你想做深拷贝，可以，全写在 Clone() 里就行。

浅拷贝场景下，改拷贝里的引用类型字段，往往会影响原对象（反之亦然），除非你再给那个字段赋一个新实例。

// 浅拷贝示例（Address 还是同一个引用）
public class DeepAndShallowCopy
{
    public static void ShallowCopy()
    {
        var rawUser = new UserDto { Id = 1, Name = "name1", Address = new UserDto.AddressDto { City = "CS" } };

        var copyUser = rawUser.Clone() as UserDto;
        copyUser.Id = 2;
        copyUser.Name = "name2";
        copyUser.Address.City = "CS2"; // 浅拷贝：动的是同一块 Address，原数据跟着变

        Console.WriteLine($"rawUser={JsonSerializer.Serialize(rawUser)}");
        Console.WriteLine($"copyUser={JsonSerializer.Serialize(copyUser)}");
    }
}

public class UserDto : ICloneable
{
    public int Id { get; set; }
    public string Name { get; set; }
    public AddressDto Address { get; set; }

    public object Clone()
    {
        return new UserDto { Id = Id, Name = Name, Address = Address };
    }

    public class AddressDto
    {
        public string City { get; set; }
    }
}

深拷贝就要让 Address 也 Clone() 一份。引用类型多就一层层写，啰嗦但清楚。

public class DeepAndShallowCopy
{
    public static void DeepCopy()
    {
        var rawUser = new UserDto { Id = 1, Name = "name1", Address = new UserDto.AddressDto { City = "CS" } };

        var copyUser = rawUser.Clone() as UserDto;
        copyUser.Id = 2;
        copyUser.Name = "name2";
        copyUser.Address.City = "CS2"; // 深拷贝：Address 已是新实例，原数据不变

        Console.WriteLine($"rawUser={JsonSerializer.Serialize(rawUser)}");
        Console.WriteLine($"copyUser={JsonSerializer.Serialize(copyUser)}");
    }
}

public class UserDto : ICloneable
{
    public int Id { get; set; }
    public string Name { get; set; }
    public AddressDto Address { get; set; }

    public object Clone()
    {
        return new UserDto { Id = Id, Name = Name, Address = Address.Clone() as AddressDto };
    }

    public class AddressDto : ICloneable
    {
        public string City { get; set; }

        public object Clone()
        {
            return new AddressDto { City = City };
        }
    }
}

手写这条路：性能好，行为自己说了算。代价是对象图一大就容易漏，漏一处就是浅拷贝；另外 Clone() 返回 object，调用处总要转一下类型，有点烦。

序列化 / AutoMapper：省事，但要心里有数

我们 CRUD 程序员经常不想维护一整张克隆图，就会想走捷径。

System.Text.Json

思路就是序列化再反序列化，得到一棵新对象。代码少，DTO、配置这类能完整序列化的类型用起来很省事。

public class DeepAndShallowCopy
{
    public static void DeepCopyByJsonSerializer()
    {
        var rawUser = new UserDto { Id = 1, Name = "name1", Address = new UserDto.AddressDto { City = "CS" } };

        var copyUser = rawUser.DeepCopy();
        copyUser.Id = 2;
        copyUser.Name = "name2";
        copyUser.Address.City = "CS2";

        Console.WriteLine($"rawUser={JsonSerializer.Serialize(rawUser)}");
        Console.WriteLine($"copyUser={JsonSerializer.Serialize(copyUser)}");
    }
}

public class UserDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public AddressDto Address { get; set; }

    /// <summary>
    /// 序列化 → 反序列化，换一批新实例
    /// </summary>
    public UserDto DeepCopy()
    {
        var rawUserString = JsonSerializer.Serialize(this);
        return JsonSerializer.Deserialize<UserDto>(rawUserString)!;
    }

    public class AddressDto
    {
        public string City { get; set; }
    }
}

好处是加字段一般不用改克隆逻辑（只要还能序列化）。麻烦在循环引用要单独配，委托、怪类型、非公开成员也可能过不去。

AutoMapper

public static void DeepCopyByAutoMapper()
{
    var config = new MapperConfiguration(config =>
    {
        config.CreateMap<UserDto, UserDto>();
        // 子类型也要建同型映射，否则 Address 可能还是同一条引用
        config.CreateMap<UserDto.AddressDto, UserDto.AddressDto>();
    });

    IMapper mapper = config.CreateMapper();

    var rawUser = new UserDto { Id = 1, Name = "name1", Address = new UserDto.AddressDto { City = "CS" } };

    var copyUser = mapper.Map<UserDto>(rawUser);
    copyUser.Id = 2;
    copyUser.Name = "name2";
    copyUser.Address.City = "CS2";

    Console.WriteLine($"rawUser={JsonSerializer.Serialize(rawUser)}");
    Console.WriteLine($"copyUser={JsonSerializer.Serialize(copyUser)}");
}

项目里本来就有 Mapper 的话，顺手 Map 一下也行。它本职是 DTO 映射，不是克隆库：子图没配齐、策略不对，照样可能浅拷贝。别指望「默认就是深拷贝」。

JSON 和 Mapper 本质上都是在「按数据重建对象」，只是经常能重建出一棵独立的树，和手写 Clone 的语义不是一回事。

record：我眼里的版本答案

前面 ICloneable 要到处 as，JSON 像绕路，AutoMapper 容易配成玄学。record 从语言层面把「数据」这件事说清楚了：默认值语义、相等性、ToString、非破坏性修改，编译器帮你生成一大坨样板，你只要在业务代码里写 with。

为什么说它像版本答案（不是银弹，但在「数据拷贝 / 派生」这条线上很对味）：

• 相等按值比：同类型的两个实例，成员一样就相等，写单元测试、去重、缓存 key 都省心。class 默认比引用，想比内容要自己重写 Equals/GetHashCode，一懒就埋雷。
• with 是语法级的「从旧副本改几处」：读代码的人一眼知道「基于 rawUser 出了一个新对象」，不用跳进 Clone() 里猜深还是浅。
• 打印友好：自动生成的 ToString 把主要字段打出来，日志里好认，排障少猜几次。

语法上有两种常见写法，知道就行：

1. 传统属性写法：和 class 差不多，只是类型是 record，白嫖相等性和 with。
2. 位置参数 record：public record UserDto(int Id, string Name, AddressDto Address); 编译器帮你生成主构造函数、解构、with 里按位置对应，DTO 里很省字。

默认的 record 是引用类型（相当于 record class）。还有 record struct，那是值类型语义，拷贝整坨 struct 时是按位复制，和「引用图里拆不拆」又是另一套题，别混在一块讲深拷贝时搞晕自己就行。

with 和深拷贝的关系再强调一遍，避免面试翻车：with 会复制你没改到的成员；引用类型的成员如果没在 with 里换掉，新旧两边仍指着同一个子对象。所以要深，就显式写 Address = rawUser.Address with { ... } 或给一个新的实例。嵌套深就链式 with，丑一点但诚实——至少「哪里拆引用」全摊在调用点，不靠隐式魔法。

想往「真·快照」靠，可以把属性收成 init 或只在构造函数里赋值，外面用 with 派生。{ get; set; } 照样能改字段，别嘴上说 record 不可变、手还在到处 set。

和 class 分工可以这样记：class 扛行为、生命周期长、引用身份有时就是业务含义；record 扛可比较的数据快照、适合命令/事件/读模型里那种「从上一版捏一版」的写法。

public class DeepAndShallowCopy
{
    public static void DeepCopyByRecord()
    {
        var rawUser = new UserDto { Id = 1, Name = "name1", Address = new UserDto.AddressDto { City = "CS" } };
        var copyUser = rawUser with { Id = 2, Name = "name2", Address = rawUser.Address with { City = "CS2" } };

        Console.WriteLine($"rawUser={JsonSerializer.Serialize(rawUser)}");
        Console.WriteLine($"copyUser={JsonSerializer.Serialize(copyUser)}");
    }
}

//注意，这不是标准用法，只是为了演示
public record UserDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public AddressDto Address { get; set; }

    public record AddressDto
    {
        public string City { get; set; }
    }
}

标准写法示意（省样板，相等/ToString/with 照样有）：

public record AddressDto(string City);

public record UserDto(int Id, string Name, AddressDto Address);

var rawUser = new UserDto(1, "name1", new AddressDto("CS"));
var copyUser = rawUser with { Name = "name2", Address = rawUser.Address with { City = "CS2" } };

怎么选（没有银弹）

按常见情况排个序，够用就行：

• 核心模型、性能敏感、要一眼能审代码：手写 Clone 或工厂从旧对象构造新的。
• 普通 DTO / 配置、能序列化、没环：JSON 往返最省事。
• 项目里 Mapper 已经到处都是：可以 CreateMap<T,T>()，把子类型也配全，并记得做配置校验和用例，别光靠手感。
• 业务就是「从旧状态派生一个新状态」、嵌套也愿意写清楚：record + with。

结论

深拷贝没有万能 API，只有你对「哪些引用该共享、哪些该拆开」有没有想清楚。工具省的是打字时间，省不了脑子。

挖坑待埋：record class与record struct 详解