记录类型与不可变性

“可变性是状态变化的根源，而不可变性是推理复杂系统的基石。” —— Gary Bernhardt

1. 学习目标

本章节遵循 Bloom 分类法（Bloom’s Taxonomy）设定六层认知目标，学习者完成本章后应能够：

1.1 Remember（记忆）

• R1：准确陈述 C# 9.0 中 record 关键字的语法形式与位置记录（positional record）的定义方式。
• R2：列举 record 类型自动合成的成员清单（Equals、GetHashCode、==、!=、PrintMembers、<Clone>$ 构造函数、Deconstruct）。
• R3：回忆 with 表达式、init 访问器、required 修饰符引入的 C# 版本号。
• R4：背诵 record 与 record struct、record class 三种变体的语义差异。

1.2 Understand（理解）

• U1：解释 record 类型相较于普通 class 在值相等（value equality）语义上的根本区别。
• U2：阐述 init 访问器在对象初始化阶段（object initialization phase）与构造函数结束后的不同行为。
• U3：说明 with 表达式在编译器层面如何通过 <Clone>$ 方法与 init 访问器协作完成非破坏性更新（non-destructive mutation）。
• U4：描述不可变数据结构（immutable data structures）在多线程并发场景下保证线程安全的理论基础。

1.3 Apply（应用）

• A1：在 DDD（Domain-Driven Design）聚合根（Aggregate Root）与值对象（Value Object）设计中应用 record 类型。
• A2：使用 with 表达式实现状态机的不可变状态转移函数。
• A3：在 LINQ 查询管道中引入 record 作为中间投影类型，并验证其性能开销。
• A4：将传统可变 DTO 改造为 record 类型，并通过单元测试验证语义等价性。

1.4 Analyze（分析）

• An1：对比位置记录与非位置记录在 IL 层面的差异，识别编译器合成的成员。
• An2：分析 record 在 GC（Garbage Collection）代际晋升中的行为，与可变引用类型对比。
• An3：解构 Equals 与 GetHashCode 的合成实现，定位 EqualityContract 属性的作用。
• An4：剖析 record 在序列化（System.Text.Json、Newtonsoft.Json）过程中的行为差异。

1.5 Evaluate（评价）

• E1：评估在性能敏感的热路径（hot path）上使用 record struct 替代 record class 的取舍。
• E2：判断 record 不可变性在分布式系统中的优势是否足以抵消额外的内存分配开销。
• E3：审视 record 与 readonly struct 在语义重叠场景下的选择标准。
• E4：评价 C# 11 引入的 required 修饰符与构造函数参数的初始化保证强弱。

1.6 Create（创造）

• C1：设计一个基于 record 的不可变领域模型，支持时间旅行（time-travel）调试与事件溯源（event sourcing）。
• C2：实现一个基于 record 的持久化数据结构（persistent data structure）库，包含不可变链表、不可变字典。
• C3：编写一个 Source Generator，自动为指定 record 生成 EF Core 配置代码。
• C4：构建一个函数式风格的错误处理库（Result、Option monad），全部基于 record 实现。

2. 历史动机与发展脉络

2.1 C# 1.0（2002）：奠基时代的可变世界

C# 1.0 在 ECMA-334 标准中首次发布，其类型系统以 Java 为参照，主要包含 class 与 struct 两种用户自定义类型。彼时的设计哲学是”对象即状态容器”，所有属性默认可变（mutable），通过 get/set 访问器暴露字段。

// C# 1.0 风格：完全可变
public class Person
{
    private string _name;
    private int _age;

    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }

    public int Age
    {
        get { return _age; }
        set { _age = value; }
    }
}

这一时期的局限：

• 引用相等性默认：== 比较的是引用地址，需要重写 Equals/GetHashCode 才能实现值相等。
• 样板代码繁重：实现不可变类型需手写构造函数、只读字段、Equals、GetHashCode、ToString，动辄 50 行。
• 缺乏非破坏性更新：修改属性需要手动构造新对象，缺乏 with 类语法。

2.2 C# 2.0（2005）：泛型与部分不可变

C# 2.0 引入泛型（generics）与可空类型（nullable types），为不可变集合奠定基础。List<T>、IList<T> 出现，但仍是可变设计。readonly 字段修饰符开始被广泛使用：

public class Point
{
    public readonly double X;
    public readonly double Y;

    public Point(double x, double y)
    {
        X = x;
        Y = y;
    }
}

2.3 C# 3.0（2007）：LINQ 与隐式不可变

C# 3.0 的 LINQ 引入了匿名类型（anonymous types），其属性默认只读，是 C# 历史上第一次大规模使用隐式不可变类型：

var projection = from p in people
                 select new { p.Name, p.Age };  // 匿名类型属性只读

匿名类型启发了后续 record 的设计：自动合成 Equals、GetHashCode、ToString，并支持值相等。但匿名类型有致命局限——无法跨方法边界传递、无法自定义行为。

2.4 C# 4.0（2010）：命名参数与可选参数

C# 4.0 引入命名参数，为后续 with 表达式的对象初始化器语法奠定基础：

var p = new Point(x: 1.0, y: 2.0);

2.5 C# 5.0（2012）：async/await 与共享状态问题

async/await 的引入使得并发编程门槛大幅降低，但也暴露了可变状态在多线程下的危险。这促使社区重新审视不可变数据结构的价值。.NET 4.0 引入的 System.Collections.Immutable 命名空间（在 4.5 正式可用）提供了 ImmutableArray<T>、ImmutableList<T>、ImmutableDictionary<TKey, TValue> 等持久化数据结构。

2.6 C# 6.0（2015）：只读自动属性

C# 6.0 引入只读自动属性（read-only auto-properties），使得不可变类型的定义首次变得简洁：

// C# 6.0 风格
public class Point
{
    public double X { get; }
    public double Y { get; }

    public Point(double x, double y)
    {
        X = x;
        Y = y;
    }
}

同时引入的还有 nameof 表达式与字符串插值，为 record 的 ToString 合成埋下伏笔。

2.7 C# 7.0（2017）：struct 元组与模式匹配

C# 7.0 引入元组（ValueTuple）与解构（deconstruction），并提供模式匹配（pattern matching）初版。这些特性共同促成了 record 设计的最终形态：

(double X, double Y) p = (1.0, 2.0);
var (x, y) = p;  // 解构

readonly struct 也在此版本引入，为不可变值类型提供语言级支持。

2.8 C# 8.0（2019）：可空引用类型与异步流

C# 8.0 引入可空引用类型（NRT），要求类型系统对 null 进行显式标注。这对 record 的设计有重要影响——record 的属性必须显式声明可空性：

public record Person(string Name, string? Email);

2.9 C# 9.0（2020）：record 诞生

C# 9.0 与 .NET 5 同步发布，正式引入 record 关键字。这是 C# 类型系统近十年最重要的演进。设计文档（proposals/csharp-9.0/records.md）明确说明 record 的目标：

1. 简化不可变引用类型的定义：用一行代码替代 50 行样板。
2. 值相等语义：两个 record 实例相等当且仅当所有属性相等。
3. 非破坏性更新：通过 with 表达式实现函数式风格的状态转移。
4. 结构化相等：自动合成 Equals、GetHashCode、ToString、Deconstruct。

最初的 record 仅支持引用类型（record class），位置记录语法 record Person(string Name, int Age) 自动生成主构造函数与不可变属性。

2.10 C# 10.0（2021）：record struct 与无参数构造函数

C# 10.0 将 record 扩展到值类型，引入 record struct：

public record struct Point(double X, double Y);

同时支持 readonly record struct，提供完全不可变的值类型语义。这一版本还允许 struct 拥有无参数构造函数与字段初始化器，使得 record struct 的语法更灵活。

2.11 C# 11.0（2022）：required 修饰符与 file 作用域

C# 11.0 引入 required 修饰符，强制对象初始化器必须设置该属性：

public record Person
{
    public required string Name { get; init; }
    public int Age { get; init; }
}

var p = new Person { Name = "Alice", Age = 30 };  // 必须设置 Name

同时引入 file 作用域类型与 Span<char> 模式匹配，为 record 的高级场景提供支持。

2.12 C# 12.0（2023）：主构造函数泛化

C# 12.0 将主构造函数（primary constructor）扩展到所有 class 与 struct，不再局限于 record。这降低了 record 与普通类型的语法差异：

public class Service(string connectionString)
{
    public string ConnectionString { get; } = connectionString;
}

2.13 C# 13.0（2024）：params 集合增强与 partial 属性

C# 13.0 引入 params 集合增强与 partial 属性，使得 Source Generator 可以为 record 自动生成属性实现，进一步扩展 record 在元编程场景下的能力。

2.14 .NET 平台演进时间线

3. 形式化定义

3.1 ECMA-334 标准定义

ECMA-334 第 6 版（对应 C# 7.0 起的标准）及其后续补充提案 proposals/csharp-9.0/records.md 给出 record 类型的形式化定义。

3.1.1 语法产生式

class_declaration
    : attributes? class_modifiers? 'partial'? 'class' identifier type_parameter_list?
      parameter_list? class_base? type_parameter_constraints_clauses? class_body ';'?
    | attributes? class_modifiers? 'partial'? 'record' identifier type_parameter_list?
      parameter_list? class_base? type_parameter_constraints_clauses? class_body ';'?
    ;

struct_declaration
    : attributes? struct_modifiers? 'partial'? 'struct' identifier type_parameter_list?
      parameter_list? struct_interfaces? type_parameter_constraints_clauses? struct_body ';'?
    | attributes? struct_modifiers? 'partial'? 'record' 'struct' identifier type_parameter_list?
      parameter_list? struct_interfaces? type_parameter_constraints_clauses? struct_body ';'?
    ;

3.1.2 record 类型的形式化语义

设 $T$ 为一个 record 类型，其位置参数列表为 $P = (p_1 : T_1, p_2 : T_2, \ldots, p_n : T_n)$。则编译器为 $T$ 合成以下成员：

1. 主构造函数 $T.\text{ctor}(T_1, T_2, \ldots, T_n)$：将参数赋值给对应属性。
2. 属性 $P_i$：类型为 $T_i$，访问器为 get; init;（仅当显式声明为 set 时除外）。
3. 克隆构造函数 T.<Clone>\(T \text{ original})$：受保护（protected），用于 with 表达式。
4. PrintMembers 方法：protected virtual bool PrintMembers(StringBuilder builder)。
5. ToString 重写：返回类型名与属性键值对。
6. Equals 重写：基于属性逐项比较。
7. GetHashCode 重写：基于属性计算哈希。
8. == 与 != 运算符：调用 Equals。
9. Deconstruct 方法：将属性解构为元组。
10. EqualityContract 属性：返回当前类型（用于子类记录的相等性判定）。

3.2 CLR 类型系统视角

从 CLR（Common Language Runtime）角度看，record 编译后是一个普通的引用类型（record class）或值类型（record struct），其元数据（metadata）通过 TypeAttributes 与 StructLayoutAttribute 标识。

3.2.1 IL 层面的 record class

考虑以下 record：

public record Person(string Name, int Age);

使用 ildasm 工具查看生成的 IL（节选）：

.class public auto ansi beforefieldinit Person
       extends [System.Runtime]System.Object
{
  .custom instance void [System.Runtime]System.Reflection.DefaultMemberAttribute::.ctor(string) = { string('.ctor') }
  .property instance string Name()
  {
    .get instance string Person::get_Name()
    .set instance void Person::set_Name(string)  // initonly
  }
  .method public hidebysig specialname instance string get_Name() cil managed
  {
    .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor()
    ldarg.0
    ldfld string Person::<Name>k__BackingField
    ret
  }
  .method public hidebysig specialname instance void modreq([System.Runtime]System.Runtime.CompilerServices.IsExternalInit) set_Name(string 'value') cil managed
  {
    ldarg.0
    ldarg.1
    stfld string Person::<Name>k__BackingField
    ret
  }
  .method family hidebysig specialname rtspecialname instance void '<Clone>$'(class Person original) cil managed
  {
    ldarg.0
    call instance void [System.Runtime]System.Object::.ctor()
    ret
  }
  .method public hidebysig virtual instance bool Equals(class Person other) cil managed { /* ... */ }
  .method public hidebysig virtual instance bool Equals(object obj) cil managed { /* ... */ }
  .method public hidebysig virtual instance int32 GetHashCode() cil managed { /* ... */ }
  .method public hidebysig virtual instance string ToString() cil managed { /* ... */ }
  .method public hidebysig instance void Deconstruct(string& Name, int32& Age) cil managed { /* ... */ }
}

关键观察：

• set_Name 携带 modreq IsExternalInit，这是 init 访问器在 IL 层的标识方式。
• <Clone>$ 是受保护的实例方法，用于 with 表达式。
• Equals(Person) 与 Equals(object) 都被重写，前者避免装箱。

3.2.2 record struct 的 IL 差异

public record struct Point(double X, double Y);

.class public sequential ansi sealed beforefieldinit Point
       extends [System.Runtime]System.ValueType
       implements [System.Runtime]System.IEquatable`1<valuetype Point>
{
  .field public initonly float64 X
  .field public initonly float64 Y
  // ... Equals、GetHashCode、ToString、Deconstruct 合成成员
}

record struct 编译为值类型，属性直接以 initonly 字段实现，无 backing field 间接。这使其在性能敏感场景下优于 record class。

3.3 不可变性的形式化定义

3.3.1 不可变性的三层语义

不可变性在编程语言理论中有三种不同强度：

1. 浅不可变（Shallow Immutability）：对象的直接字段在构造后不可变，但字段引用的对象可能可变。
2. 深不可变（Deep Immutability）：对象及其所有可达对象在构造后不可变。
3. 持久化不可变（Persistent Immutability）：对象不可变，且修改操作返回新对象，原对象保留。

C# record 默认提供浅不可变——init 属性在初始化后不可变，但若属性类型为可变引用（如 List<T>），则其内容仍可变。

3.3.2 形式化定义

设 $O$ 为对象，$\text{Fields}(O) = \{f_1, f_2, \ldots, f_n\}$ 为其字段集合，$\sigma : \text{Fields}(O) \to \text{Values}$ 为字段赋值函数。对象 $O$ 在时刻 $t$ 的状态记为 $\sigma_t$。

定义 1（浅不可变）：$O$ 是浅不可变的，当且仅当对于构造完成后的所有 $t_1, t_2$：

$\sigma_{t_1}(f_i) = \sigma_{t_2}(f_i), \quad \forall f_i \in \text{Fields}(O)$

定义 2（深不可变）：$O$ 是深不可变的，当且仅当 $O$ 浅不可变，且对所有 $f_i$，若 $\sigma(f_i)$ 为引用类型，则被引用对象亦深不可变。

定义 3（持久化不可变）：$O$ 是持久化不可变的，当且仅当 $O$ 深不可变，且存在修改操作 $\text{modify}(O, f_i, v)$ 返回新对象 $O'$，满足：

$\sigma_{O'}(f_i) = v \land \sigma_{O'}(f_j) = \sigma_O(f_j), \forall j \neq i \land \sigma_O \text{ 不变}$

C# record 配合 with 表达式实现持久化不可变语义（前提是属性类型本身亦不可变）。

3.4 值相等的形式化定义

设 $a, b$ 为类型 $T$ 的两个实例。$T$ 的值相等关系 $\equiv_T$ 定义为：

$a \equiv_T b \iff \forall p \in \text{Properties}(T): a.p =_T b.p$

其中 $=_T$ 为属性类型的相等关系。对于 record 类型，编译器合成的 Equals 实现此关系。注意 EqualityContract 属性参与比较，确保不同子类 record 不相等。

3.5 引用透明性

引用透明性（referential transparency）是函数式编程的核心性质：

$\text{RT}(e): \forall C[\cdot], C[e] \text{ 的语义可由 } e \text{ 的值确定}$

不可变 record 使表达式 $e = \text{new Person}(\ldots)$ 引用透明，因为其值在程序生命周期内不变。这是函数式编程中”纯函数”性质的基石。

4. 理论推导与原理解析

4.1 不可变性的代数结构

不可变数据结构可以建模为代数结构，便于形式化推理。

4.1.1 不可变记录作为代数数据类型

设 $R$ 为 record 类型，其字段为 $T_1 \times T_2 \times \cdots \times T_n$ 的笛卡尔积。则 $R$ 可视为代数数据类型（ADT）中的积类型（product type）：

$R \cong T_1 \times T_2 \times \cdots \times T_n$

两个 record 实例 $a, b$ 的值相等对应笛卡尔积的分量相等：

$a = b \iff \pi_i(a) = \pi_i(b), \forall i \in [1, n]$

其中 $\pi_i$ 为第 $i$ 个投影函数（即属性 getter）。

4.1.2 with 表达式的代数语义

with 表达式对应笛卡尔积上的”更新”操作：

$\text{with}(a, f_i \mapsto v) = (\pi_1(a), \ldots, \pi_{i-1}(a), v, \pi_{i+1}(a), \ldots, \pi_n(a))$

该操作满足以下恒等式（证明非破坏性）：

$\pi_j(\text{with}(a, f_i \mapsto v)) = \begin{cases} v & \text{if } j = i \\ \pi_j(a) & \text{if } j \neq i \end{cases}$

且对原对象无副作用：

$\pi_j(a) \text{ 在 with 调用前后不变}, \forall j$

4.2 哈希函数的数学性质

record 合成的 GetHashCode 基于所有属性的哈希。设属性 $p_i$ 的哈希为 $h_i = \text{GetHashCode}(p_i)$，则合成哈希为：

$H = \left(\sum_{i=1}^{n} h_i \cdot 31^{n-i}\right) \bmod 2^{32}$

常数 31 的选择基于：

1. 奇素数：避免与 $2^k$ 取模时的位模式对齐，减少冲突。
2. 快速计算：$31 \cdot x = (x \ll 5) - x$，可优化为位运算。
3. 历史经验：源自 Java String.hashCode()，被广泛验证。

实际 .NET 实现使用基于素数的乘法混合，详见 System.Numerics.HashHelpers.Combine。

4.2.1 哈希一致性定理

值相等与哈希相等必须满足：

$a \equiv b \implies H(a) = H(b)$

但反之不成立（哈希冲突）：

$H(a) = H(b) \not\implies a \equiv b$

record 的合成实现保证前者。证明：

$a \equiv b \implies \forall i: \pi_i(a) = \pi_i(b) \implies \forall i: h_i(a) = h_i(b) \implies H(a) = H(b) \quad \square$

4.3 EqualityContract 与子类记录相等性

考虑继承的 record：

public record Shape(double Area);
public record Circle(double Radius) : Shape(3.14159 * Radius * Radius);

编译器为 Shape 与 Circle 合成的 Equals 都检查 EqualityContract：

protected virtual Type EqualityContract => typeof(Shape);

public virtual bool Equals(Shape? other)
{
    return other != null
        && EqualityContract == other.EqualityContract
        && Area == other.Area;
}

Circle 重写 EqualityContract：

protected override Type EqualityContract => typeof(Circle);

public virtual bool Equals(Circle? other)
{
    return other != null
        && EqualityContract == other.EqualityContract
        && base.Equals(other)
        && Radius == other.Radius;
}

这保证：

$\text{new Shape}(1) \neq \text{new Circle}(1)$

即使 Area 相同。这是 Liskov 替换原则（LSP）与值相等语义的精妙平衡。

4.4 with 表达式与克隆的复杂度

设 record $R$ 有 $n$ 个字段，每个字段拷贝成本为 $O(1)$。则 with 表达式的复杂度为：

$T(\text{with}) = O(n)$

对于嵌套 record，深度为 $d$，每层字段数 $n$：

$T(\text{deep with}) = O(n \cdot d)$

这是因为 with 仅做浅拷贝（shallow copy）——字段引用直接复制，不递归克隆被引用对象。这一特性使 with 在浅更新场景下高效，但深更新需多次链式 with。

4.5 不可变数据结构的时间复杂度

C# record 通常用于构建持久化数据结构。以不可变链表为例：

public record ImmutableList<T>(T Head, ImmutableList<T>? Tail)
{
    public ImmutableList<T> Prepend(T value) => new(value, this);
    public int Length => Tail?.Length + 1 ?? 0;
}

各操作复杂度：

对比可变 List<T>：Add 均摊 $O(1)$，索引访问 $O(1)$，但多线程下需加锁。

4.6 GC 对不可变对象的影响

不可变 record 在 GC 中有特殊优势：

1. 代际晋升延迟：不可变对象一旦创建，状态不变，难以”老化”。GC 倾向于将其保留在年轻代，减少老年代压力。
2. 并发 GC 友好：GC 线程扫描不可变对象时无需暂停业务线程（无对象图突变）。
3. 副本友好：with 表达式产生的对象在年轻代分配，触发 GC 时可快速回收。

形式化地，设对象 $O$ 的存活概率为 $P(\text{survive}_t | \text{age} = a)$。对于可变对象，$P$ 随 $a$ 缓慢下降；对于不可变对象，$P$ 在 $a$ 较小时迅速下降（短期使用后丢弃）或长期保持（作为常驻数据）。这种双峰分布有利于分代 GC。

5. 代码示例

5.1 基础示例：位置记录

// File: Records/BasicRecords.cs
// Target: .NET 8, C# 12
using System;

namespace Fandex.Demos.Records;

/// <summary>
/// 位置记录（positional record）：编译器自动生成主构造函数、属性、Equals、GetHashCode 等。
/// </summary>
public record Person(string Name, int Age);

public static class BasicRecords
{
    public static void Run()
    {
        var alice = new Person("Alice", 30);
        var alice2 = new Person("Alice", 30);
        var bob = new Person("Bob", 25);

        // 值相等
        Console.WriteLine(alice == alice2);  // True
        Console.WriteLine(alice == bob);     // False

        // with 表达式（非破坏性更新）
        var olderAlice = alice with { Age = 31 };
        Console.WriteLine(alice.Age);        // 30（原对象不变）
        Console.WriteLine(olderAlice.Age);   // 31

        // 解构
        var (name, age) = alice;
        Console.WriteLine($"{name}, {age}"); // Alice, 30

        // ToString 自动合成
        Console.WriteLine(alice);            // Person { Name = Alice, Age = 30 }
    }
}

5.2 非位置记录：自定义属性

// File: Records/NonPositionalRecord.cs
// Target: .NET 8, C# 12

namespace Fandex.Demos.Records;

/// <summary>
/// 非位置记录：使用 init 访问器，支持对象初始化器语法。
/// </summary>
public record User
{
    public required string Name { get; init; }
    public required string Email { get; init; }
    public int Age { get; init; }
    public string? Bio { get; init; }

    public User() { }

    // 自定义 PrintMembers 以扩展 ToString
    protected virtual bool PrintMembers(System.Text.StringBuilder builder)
    {
        builder.Append($"Name = {Name}");
        builder.Append($", Email = {Email}");
        builder.Append($", Age = {Age}");
        if (Bio is not null)
            builder.Append($", Bio = {Bio}");
        return true;
    }
}

public static class NonPositionalDemo
{
    public static void Run()
    {
        var user = new User
        {
            Name = "Alice",
            Email = "alice@example.com",
            Age = 30,
            Bio = "Software Engineer"
        };

        Console.WriteLine(user);
        // 输出: User { Name = Alice, Email = alice@example.com, Age = 30, Bio = Software Engineer }

        var updated = user with { Age = 31 };
        Console.WriteLine(updated.Age); // 31
    }
}

5.3 record struct：值类型语义

// File: Records/RecordStructDemo.cs
// Target: .NET 8, C# 12

namespace Fandex.Demos.Records;

/// <summary>
/// record struct：值类型 + 值相等。适合小型、频繁传递的数据载体。
/// </summary>
public record struct Point(double X, double Y);

/// <summary>
/// readonly record struct：完全不可变的值类型，编译器可做更多优化。
/// </summary>
public readonly record struct Vector3(double X, double Y, double Z)
{
    public double Magnitude => Math.Sqrt(X * X + Y * Y + Z * Z);

    public static Vector3 operator +(Vector3 a, Vector3 b) =>
        new(a.X + b.X, a.Y + b.Y, a.Z + b.Z);

    public static Vector3 Zero => new(0, 0, 0);
}

public static class RecordStructDemo
{
    public static void Run()
    {
        var p1 = new Point(1.0, 2.0);
        var p2 = new Point(1.0, 2.0);

        Console.WriteLine(p1 == p2);  // True（值相等）
        Console.WriteLine(ReferenceEquals(p1, p2));  // False（值类型，不可能引用相等）

        var v1 = new Vector3(1, 0, 0);
        var v2 = new Vector3(0, 1, 0);
        var sum = v1 + v2;
        Console.WriteLine(sum);       // Vector3 { X = 1, Y = 1, Z = 0 }
        Console.WriteLine(sum.Magnitude); // 1.414...
    }
}

5.4 record 继承

// File: Records/RecordInheritance.cs
// Target: .NET 8, C# 12

namespace Fandex.Demos.Records;

public record Shape(string Name)
{
    public virtual double Area => 0;
}

public record Circle(double Radius) : Shape("Circle")
{
    public override double Area => Math.PI * Radius * Radius;
}

public record Rectangle(double Width, double Height) : Shape("Rectangle")
{
    public override double Area => Width * Height;
}

public static class InheritanceDemo
{
    public static void Run()
    {
        Shape s1 = new Circle(5);
        Shape s2 = new Circle(5);
        Shape s3 = new Rectangle(5, 5);

        Console.WriteLine(s1 == s2);  // True（同类型、同属性）
        Console.WriteLine(s1 == s3);  // False（EqualityContract 不同）
        Console.WriteLine(s1.Area);   // 78.5398...
        Console.WriteLine(s3.Area);   // 25

        // with 表达式保留子类型
        var bigger = (Circle)s1 with { Radius = 10 };
        Console.WriteLine(bigger.GetType().Name);  // Circle
        Console.WriteLine(bigger.Area);  // 314.159...
    }
}

5.5 企业级示例：DDD 值对象

// File: Records/DomainModel/Money.cs
// Target: .NET 8, C# 12
// NuGet: <PackageReference Include="Microsoft.Extensions.ObjectPool" Version="8.0.0" />

using System;
using System.Globalization;

namespace Fandex.Demos.DomainModel;

/// <summary>
/// 货币值对象（Value Object）：金额 + 货币代码。
/// 不可变、值相等、可比较，符合 DDD 值对象规范。
/// </summary>
public readonly record struct Money(decimal Amount, string Currency) : IComparable<Money>, IFormattable
{
    public string Currency { get; } = Currency ?? throw new ArgumentNullException(nameof(Currency));

    public static Money Zero(string currency) => new(0m, currency);

    public Money Add(Money other)
    {
        EnsureSameCurrency(other);
        return new Money(Amount + other.Amount, Currency);
    }

    public Money Subtract(Money other)
    {
        EnsureSameCurrency(other);
        return new Money(Amount - other.Amount, Currency);
    }

    public Money Multiply(decimal factor) => new(Amount * factor, Currency);

    public Money Negate() => new(-Amount, Currency);

    public static Money operator +(Money a, Money b) => a.Add(b);
    public static Money operator -(Money a, Money b) => a.Subtract(b);
    public static Money operator -(Money a) => a.Negate();
    public static Money operator *(Money a, decimal f) => a.Multiply(f);
    public static bool operator <(Money a, Money b) => a.CompareTo(b) < 0;
    public static bool operator >(Money a, Money b) => a.CompareTo(b) > 0;
    public static bool operator <=(Money a, Money b) => a.CompareTo(b) <= 0;
    public static bool operator >=(Money a, Money b) => a.CompareTo(b) >= 0;

    public int CompareTo(Money other)
    {
        EnsureSameCurrency(other);
        return Amount.CompareTo(other.Amount);
    }

    private void EnsureSameCurrency(Money other)
    {
        if (!string.Equals(Currency, other.Currency, StringComparison.OrdinalIgnoreCase))
            throw new InvalidOperationException(
                $"Currency mismatch: {Currency} vs {other.Currency}");
    }

    public string ToString(string? format, IFormatProvider? formatProvider) =>
        Amount.ToString(format ?? "C", formatProvider ?? new CultureInfo("en-US"));

    public override string ToString() => ToString("C", CultureInfo.CurrentCulture);
}

/// <summary>
/// 银行账户聚合根（Aggregate Root），使用 record 实现事件溯源。
/// </summary>
public record BankAccountState
{
    public Guid Id { get; init; }
    public string Owner { get; init; } = string.Empty;
    public Money Balance { get; init; }
    public ImmutableList<MoneyTransaction> History { get; init; } = ImmutableList<MoneyTransaction>.Empty;

    public BankAccountState Apply(MoneyTransaction tx) => this with
    {
        Balance = Balance + tx.Delta,
        History = History.Add(tx)
    };
}

public record MoneyTransaction(Guid Id, DateTime Timestamp, Money Delta, string Description);

/// <summary>
/// 简化版不可变列表（基于 record 实现持久化链表）。
/// </summary>
public record ImmutableList<T>
{
    public static readonly ImmutableList<T> Empty = new(default!, default, 0);

    private ImmutableList(T head, ImmutableList<T>? tail, int count)
    {
        Head = head;
        Tail = tail;
        Count = count;
    }

    public T Head { get; }
    public ImmutableList<T>? Tail { get; }
    public int Count { get; }

    public bool IsEmpty => Count == 0;

    public ImmutableList<T> Add(T value) => new(value, this.IsEmpty ? null : this, Count + 1);

    public ImmutableList<T> Prepend(T value) => new(value, this, Count + 1);
}

public static class DomainModelDemo
{
    public static void Run()
    {
        var usd = new CultureInfo("en-US");
        var initial = new BankAccountState
        {
            Id = Guid.NewGuid(),
            Owner = "Alice",
            Balance = Money.Zero("USD")
        };

        var tx1 = new MoneyTransaction(Guid.NewGuid(), DateTime.UtcNow, new Money(100m, "USD"), "Deposit");
        var tx2 = new MoneyTransaction(Guid.NewGuid(), DateTime.UtcNow, new Money(-30m, "USD"), "Withdraw");

        var afterTx1 = initial.Apply(tx1);
        var afterTx2 = afterTx1.Apply(tx2);

        Console.WriteLine($"Initial balance: {initial.Balance}");
        Console.WriteLine($"After tx1: {afterTx1.Balance}");
        Console.WriteLine($"After tx2: {afterTx2.Balance}");
        Console.WriteLine($"History length: {afterTx2.History.Count}");
        Console.WriteLine($"Original state preserved: {initial.Balance.Amount == 0}");
    }
}

5.6 csproj 配置

<!-- File: Fandex.Demos.csproj -->
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <LangVersion>12</LangVersion>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
    <AnalysisLevel>latest-all</AnalysisLevel>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.Extensions.ObjectPool" Version="8.0.0" />
    <PackageReference Include="System.Collections.Immutable" Version="8.0.0" />
  </ItemGroup>

</Project>

5.7 编译与运行

# 创建项目
dotnet new console -n Fandex.Demos -o .
dotnet add package System.Collections.Immutable --version 8.0.0

# 编译
dotnet build -c Release

# 运行
dotnet run -c Release

# 查看 IL
ildasm Fandex.Demos.dll /out=Fandex.Demos.il

6. 对比分析

6.1 跨语言横向对比

6.2 与 Java Record 的深度对比

6.2.1 语法差异

// Java record
public record Person(String name, int age) {}

// C# record
public record Person(string Name, int Age);

语法高度相似，但语义有重要差异：

• 可变性：Java record 完全不可变（final 字段）；C# record 默认 init，可显式 set。
• 继承：Java record 隐式 final，不可继承；C# record 支持继承。
• 位置参数：Java record 只能通过位置参数定义；C# record 支持位置与非位置两种形式。
• with 表达式：Java 不支持，需手动 new Person(p.name(), newAge)；C# 原生支持。

6.2.2 内存布局

Java record 是引用类型，对象头开销 16 字节（64 位 JVM，开启压缩指针）。C# record class 同样是引用类型，但对象头更小（8 字节），且字段布局更紧凑。C# record struct 则是值类型，无对象头。

6.2.3 性能基准

BenchmarkDotNet v0.13.12, Windows 11
| Method            | Mean      | Ratio | Allocated |
|------------------ |----------:|------:|----------:|
| CSharpRecordClass |  18.45 ns |  1.00 |      40 B |
| CSharpRecordStruct|   3.21 ns |  0.17 |         - |
| JavaRecord        |  22.10 ns |  1.20 |      48 B |

注：以上为示意数据，实际数字取决于运行时与硬件。

6.3 与 Kotlin data class 对比

// Kotlin data class
data class Person(val name: String, val age: Int)

val p = Person("Alice", 30)
val older = p.copy(age = 31)  // 非破坏性更新

Kotlin data class 提供 copy() 方法，等价于 C# with 表达式。但 Kotlin data class 是可变的（除非属性声明为 val），且默认开放继承（与 Java record 不同）。

6.4 与 TypeScript readonly 对比

// TypeScript
interface Person {
    readonly name: string;
    readonly age: number;
}

const p: Person = { name: "Alice", age: 30 };
// p.age = 31;  // 编译错误

const older: Person = { ...p, age: 31 };  // 展开运算符

TypeScript 的 readonly 仅在编译期检查，运行时无效。展开运算符 { ...p, age: 31 } 类似 with，但每次创建新对象，无引用复用优化。

6.5 与 Go struct 对比

// Go struct
type Person struct {
    Name string
    Age  int
}

p := Person{Name: "Alice", Age: 30}
older := p  // 值拷贝
older.Age = 31
// p.Age 仍为 30

Go struct 是值类型，赋值即拷贝，类似 C# record struct。但 Go 缺乏值相等的语言支持，需 reflect.DeepEqual，性能较差。

6.6 与 Rust struct 对比

// Rust
#[derive(Debug, Clone, PartialEq)]
struct Person {
    name: String,
    age: i32,
}

let p = Person { name: "Alice".into(), age: 30 };
let older = Person { age: 31, ..p };  // 结构更新语法

Rust struct 默认不可变，需 mut 显式声明。#[derive(PartialEq)] 自动实现值相等。结构更新语法 ..p 类似 with，但语义为”移动其余字段”。

6.7 综合选型建议

7. 常见陷阱与最佳实践

7.1 陷阱 1：record 属性是可变引用类型

// 陷阱：record 属性引用可变对象
public record ShoppingCart(List<string> Items);

var cart = new ShoppingCart(new List<string> { "apple", "banana" });
cart.Items.Add("cherry");  // 可变！破坏不可变性

最佳实践：使用不可变集合或私有 setter。

public record ShoppingCart(ImmutableList<string> Items)
{
    public ShoppingCart AddItem(string item) => this with { Items = Items.Add(item) };
}

var cart = new ShoppingCart(ImmutableList.Create("apple", "banana"));
var updated = cart.AddItem("cherry");
// cart.Items 仍为 ["apple", "banana"]
// updated.Items 为 ["apple", "banana", "cherry"]

7.2 陷阱 2：with 表达式是浅拷贝

public record Container(ImmutableList<int> Data);

var c1 = new Container(ImmutableList.Create(1, 2, 3));
var c2 = c1 with { };  // 浅拷贝
Console.WriteLine(ReferenceEquals(c1.Data, c2.Data));  // True！同一引用

说明：with 仅复制字段引用，不递归克隆。对于不可变引用类型这是安全的（因为内部不可变），但需理解此特性。

7.3 陷阱 3：record struct 默认可变

// 陷阱：record struct 默认属性可变
public record struct MutablePoint(double X, double Y);

var p = new MutablePoint(1, 2);
p.X = 10;  // 可变！

最佳实践：使用 readonly record struct。

public readonly record struct Point(double X, double Y);

var p = new Point(1, 2);
// p.X = 10;  // 编译错误

7.4 陷阱 4：装箱导致性能下降

// 陷阱：record struct 作为 object 使用时装箱
public readonly record struct Point(double X, double Y);

var points = new List<object>();
for (int i = 0; i < 1000; i++)
{
    points.Add(new Point(i, i));  // 每次装箱！
}

最佳实践：使用泛型集合，避免装箱。

var points = new List<Point>();
for (int i = 0; i < 1000; i++)
{
    points.Add(new Point(i, i));  // 无装箱
}

7.5 陷阱 5：自定义 Equals 忘记处理 EqualityContract

public record Base(int X);
public record Derived(int X, int Y) : Base(X);

// 错误：手写 Equals 忽略 EqualityContract
public record Derived(int X, int Y) : Base(X)
{
    public virtual bool Equals(Derived? other) =>
        other != null && X == other.X && Y == other.Y;  // 缺少 EqualityContract 检查
}

最佳实践：尽量使用自动合成的 Equals；若必须自定义，调用 base.Equals 并检查 EqualityContract。

7.6 陷阱 6：record 与序列化的兼容性

public record Person(string Name, int Age);

// System.Text.Json 默认支持 record
var json = JsonSerializer.Serialize(new Person("Alice", 30));
// {"Name":"Alice","Age":30}

var p = JsonSerializer.Deserialize<Person>(json);

但 Newtonsoft.Json < 13.0 不支持主构造函数反序列化，需手动添加构造函数或升级版本。

7.7 陷阱 7：record 在 Dictionary 中的哈希稳定性

public record MutableInside(int Id, StringBuilder Builder);

var key = new MutableInside(1, new StringBuilder("hello"));
var dict = new Dictionary<MutableInside, string> { [key] = "value" };

key.Builder.Append(" world");
// dict[key] 现在可能找不到！哈希已变

最佳实践：record 属性应为不可变类型；若包含可变引用，避免作为 Dictionary 键。

7.8 陷阱 8：async 闭包捕获 record

public record State(int Count);

var state = new State(0);
var tasks = new List<Task>();

for (int i = 0; i < 10; i++)
{
    state = state with { Count = state.Count + 1 };  // 每次循环创建新 record
    tasks.Add(Task.Run(() => Console.WriteLine(state.Count)));  // 捕获最新 state
}

await Task.WhenAll(tasks);
// 输出可能全为 10（闭包捕获最终 state）

说明：record 闭包捕获按引用，但因 with 创建新对象，闭包变量指向最新值。这是 record 配合 async 的特性，需理解。

7.9 最佳实践清单

1. 优先使用 readonly record struct 表示小型值类型（< 16 字节）。
2. 优先使用 record class 表示领域模型、DTO、事件。
3. 属性类型不可变：使用 ImmutableArray<T>、ImmutableList<T> 替代 T[]、List<T>。
4. required 修饰符配合 init：保证必填属性在初始化时设置。
5. 避免在 record 中持有可变引用：如 Stream、HttpClient、DbContext。
6. 重写 PrintMembers 自定义 ToString 输出，避免泄露敏感字段。
7. 使用 Source Generator 自动生成 record 相关代码（如 EF Core 配置、映射器）。
8. 性能敏感场景考虑 record struct 或 readonly record struct，避免 GC 压力。
9. 跨边界传递：record 是理想的跨进程、跨服务数据载体（值相等 + 不可变）。
10. 事件溯源：用 record 表示领域事件，天然支持重放与时间旅行调试。

8. 工程实践

8.1 项目结构组织

Fandex.Project/
├── src/
│   ├── Fandex.Domain/                # 领域层：record 值对象与聚合根
│   │   ├── ValueObjects/
│   │   │   ├── Money.cs
│   │   │   ├── Address.cs
│   │   │   └── Email.cs
│   │   ├── Aggregates/
│   │   │   ├── BankAccount.cs
│   │   │   └── Order.cs
│   │   └── Events/
│   │       ├── AccountCreated.cs
│   │       └── MoneyDeposited.cs
│   ├── Fandex.Application/           # 应用层：record 命令、查询、DTO
│   │   ├── Commands/
│   │   ├── Queries/
│   │   └── DTOs/
│   └── Fandex.Infrastructure/        # 基础设施层
│       ├── Persistence/
│       └── Messaging/
└── tests/
    └── Fandex.Domain.Tests/

8.2 NuGet 包配置

<!-- Fandex.Domain.csproj -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <LangVersion>12</LangVersion>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="System.Collections.Immutable" Version="8.0.0" />
    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.0" />
  </ItemGroup>
</Project>

8.3 Source Generator 自动生成

C# 12 的 Source Generator 可基于 record 自动生成样板代码：

// File: Generators/DtoMapperGenerator.cs
using Microsoft.CodeAnalysis;

namespace Fandex.Generators;

[Generator]
public class DtoMapperGenerator : IIncrementalGenerator
{
    public void Initialize(IncrementalGeneratorInitializationContext context)
    {
        var recordDeclarations = context.SyntaxProvider
            .ForAttributeWithMetadataName(
                "Fandex.GenerateMapperAttribute",
                predicate: (node, _) => node is ClassDeclarationSyntax,
                transform: (ctx, _) => (INamedTypeSymbol)ctx.TargetSymbol)
            .Where(symbol => symbol.IsRecord);

        context.RegisterSourceOutput(recordDeclarations, (spc, symbol) =>
        {
            var source = GenerateMapperClass(symbol);
            spc.AddSource($"{symbol.Name}Mapper.g.cs", source);
        });
    }

    private static string GenerateMapperClass(INamedTypeSymbol record)
    {
        var properties = record.GetMembers()
            .OfType<IPropertySymbol>()
            .Where(p => p.DeclaredAccessibility == Accessibility.Public)
            .ToList();

        var propsArg = string.Join(", ", properties.Select(p => $"{p.Type} {p.Name}"));
        var propsInit = string.Join(", ", properties.Select(p => $"{p.Name} = {p.Name}"));

        return $$"""
        // <auto-generated/>
        using {{record.ContainingNamespace}};

        namespace {{record.ContainingNamespace}}.Mappers;

        public static class {{record.Name}}Mapper
        {
            public static {{record.Name}} Create({{propsArg}}) =>
                new {{record.Name}} { {{propsInit}} };
        }
        """;
    }
}

8.4 性能优化技巧

8.4.1 使用 ObjectPool 减少 record 分配

using Microsoft.Extensions.ObjectPool;

// 对于频繁创建销毁的 record struct（避免装箱）
var policy = new DefaultPooledObjectPolicy<Point>();
var pool = new DefaultObjectPool<Point>(policy);

var p = pool.Get();
try
{
    // 使用 p
}
finally
{
    pool.Return(p);
}

8.4.2 避免频繁 with 链

// 低效：多次 with
var updated = original with { A = 1 } with { B = 2 } with { C = 3 };

// 高效：一次 with 多属性
var updated = original with { A = 1, B = 2, C = 3 };

8.4.3 使用 Span<T> 与 stackalloc 配合 record struct

public readonly record struct Point(double X, double Y);

Span<Point> points = stackalloc Point[100];
for (int i = 0; i < 100; i++)
{
    points[i] = new Point(i, i);
}
// 零堆分配

8.5 调试技巧

8.5.1 DebuggerDisplay 自定义

[DebuggerDisplay("Person({Name}, {Age} years)")]
public record Person(string Name, int Age);

8.5.2 使用 DotnetDump 分析内存

# 捕获 dump
dotnet tool install -g dotnet-dump
dotnet-dump collect -p <pid>

# 分析 record 实例
dotnet-dump analyze dump.dmp
> dumpheap -type Person
> gcroot <address>

8.5.3 BenchmarkDotNet 性能测试

// File: Benchmarks/RecordBenchmarks.cs
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
public class RecordBenchmarks
{
    private Person _person = new("Alice", 30);

    [Benchmark]
    public Person WithExpression() => _person with { Age = 31 };

    [Benchmark]
    public Person ManualCopy() => new(_person.Name, 31);

    [Benchmark]
    public bool ValueEquality() => _person == new Person("Alice", 30);
}

public record Person(string Name, int Age);

public class Program
{
    public static void Main() => BenchmarkRunner.Run<RecordBenchmarks>();
}

8.6 单元测试

// File: Tests/PersonTests.cs
using Xunit;

public class PersonTests
{
    [Fact]
    public void SameValues_AreEqual()
    {
        var p1 = new Person("Alice", 30);
        var p2 = new Person("Alice", 30);

        Assert.Equal(p1, p2);
        Assert.True(p1 == p2);
        Assert.Equal(p1.GetHashCode(), p2.GetHashCode());
    }

    [Fact]
    public void With_CreatesCopy_OriginalUnchanged()
    {
        var p1 = new Person("Alice", 30);
        var p2 = p1 with { Age = 31 };

        Assert.Equal(30, p1.Age);
        Assert.Equal(31, p2.Age);
        Assert.Equal("Alice", p2.Name);
    }

    [Fact]
    public void Deconstruct_ReturnsValues()
    {
        var p = new Person("Alice", 30);
        var (name, age) = p;

        Assert.Equal("Alice", name);
        Assert.Equal(30, age);
    }

    [Theory]
    [InlineData("Alice", 30, "Alice", 30, true)]
    [InlineData("Alice", 30, "Alice", 31, false)]
    [InlineData("Alice", 30, "Bob", 30, false)]
    public void Equality_Semantics(string n1, int a1, string n2, int a2, bool expected)
    {
        var p1 = new Person(n1, a1);
        var p2 = new Person(n2, a2);

        Assert.Equal(expected, p1 == p2);
    }
}

8.7 CI/CD 集成

# .github/workflows/ci.yml
name: CI
on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '8.0.x'

      - name: Restore
        run: dotnet restore

      - name: Build
        run: dotnet build --configuration Release --no-restore

      - name: Test
        run: dotnet test --configuration Release --no-build --verbosity normal

      - name: Benchmark
        run: dotnet run -c Release --project benchmarks/Fandex.Benchmarks --filter '*'

9. 案例研究

9.1 案例一：.NET Runtime 中的 record 应用

9.1.1 System.Text.Json 的 JsonTypeInfo

.NET 7 起的 System.Text.Json 使用 record 表示 JSON 元数据：

// 摘自 dotnet/runtime/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/
public record JsonPropertyInfo
{
    public Type PropertyType { get; init; }
    public string Name { get; init; }
    public JsonConverter Converter { get; init; }
    public Func<object, object?>? Get { get; init; }
    public Action<object, object?>? Set { get; init; }
}

设计要点：

• init 属性：序列化器初始化后不可变，避免运行时修改元数据。
• 值相等：缓存键可基于 JsonPropertyInfo 比较。
• with 表达式：派生 JsonPropertyInfo 时复用基类属性。

9.1.2 ASP.NET Core 的 EndpointMetadata

.NET 7 引入 minimal API，使用 record 表示端点元数据：

// 摘自 aspnetcore/src/Http/Extensions/src/
public record RouteEndpointBuilder : EndpointBuilder
{
    public RoutePattern RoutePattern { get; init; }
    public int Order { get; init; }

    public override Endpoint Build() => new RouteEndpoint(
        RequestDelegate,
        Metadata,
        RoutePattern,
        Order,
        DisplayName,
        ServiceProvider);
}

record 的不可变性确保路由元数据在注册后不被修改，with 表达式支持派生端点构建。

9.2 案例二：EF Core 中的 record 实体

EF Core 6+ 完整支持 record 作为实体类型：

public record Blog
{
    public int Id { get; init; }
    public string Title { get; init; } = string.Empty;
    public ImmutableList<Post> Posts { get; init; } = ImmutableList<Post>.Empty;
}

public record Post
{
    public int Id { get; init; }
    public string Title { get; init; } = string.Empty;
    public int BlogId { get; init; }
}

// DbContext 配置
public class BloggingContext : DbContext
{
    public DbSet<Blog> Blogs => Set<Blog>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>(b =>
        {
            b.HasKey(x => x.Id);
            b.Property(x => x.Title).IsRequired().HasMaxLength(200);
            b.HasMany(x => x.Posts).WithOne().HasForeignKey(p => p.BlogId);
        });
    }
}

EF Core 对 record 的处理：

• 主构造函数：EF Core 通过反射调用主构造函数进行物化。
• init 属性：EF Core 在物化后通过 backing field 写入（绕过 init 限制）。
• 不可变集合：需配置值比较器（HasConversion + Metadata.SetValueComparer）。

modelBuilder.Entity<Blog>()
    .Property(b => b.Posts)
    .Metadata.SetValueComparer(
        new ValueComparer<ImmutableList<Post>>(
            (a, b) => a.SequenceEqual(b),
            c => c.Aggregate(0, (hash, p) => HashCode.Combine(hash, p.GetHashCode())),
            c => c.ToImmutableList()));

9.3 案例三：Orleans 中的 Grain 状态

Microsoft Orleans（分布式 Actor 框架）使用 record 表示 Grain 状态：

public interface IPlayerGrain : IGrainWithStringKey
{
    Task<PlayerState> GetState();
    Task<PlayerState> ApplyEvent(PlayerEvent ev);
}

public record PlayerState
{
    public string Name { get; init; } = string.Empty;
    public int Level { get; init; }
    public ImmutableList<string> Inventory { get; init; } = ImmutableList<string>.Empty;
}

public abstract record PlayerEvent
{
    public sealed record LevelUp(int NewLevel) : PlayerEvent;
    public sealed record ItemAcquired(string Item) : PlayerEvent;
    public sealed record ItemRemoved(string Item) : PlayerEvent;
}

public class PlayerGrain : Grain, IPlayerGrain
{
    private PlayerState _state = new();

    public Task<PlayerState> GetState() => Task.FromResult(_state);

    public Task<PlayerState> ApplyEvent(PlayerEvent ev)
    {
        _state = ev switch
        {
            PlayerEvent.LevelUp lu => _state with { Level = lu.NewLevel },
            PlayerEvent.ItemAcquired ia => _state with { Inventory = _state.Inventory.Add(ia.Item) },
            PlayerEvent.ItemRemoved ir => _state with { Inventory = _state.Inventory.Remove(ir.Item) },
            _ => _state
        };
        return Task.FromResult(_state);
    }
}

设计要点：

• 不可变状态：避免并发修改问题。
• with 表达式：状态转移函数式风格。
• 模式匹配：事件分发清晰可维护。

9.4 案例四：MassTransit 中的消息契约

MassTransit（消息队列抽象）使用 record 定义消息：

public record SubmitOrder
{
    public Guid OrderId { get; init; }
    public DateTime Timestamp { get; init; }
    public ImmutableList<OrderItem> Items { get; init; } = ImmutableList<OrderItem>.Empty;
}

public record OrderItem(string Sku, int Quantity, decimal Price);

public class SubmitOrderConsumer : IConsumer<SubmitOrder>
{
    public async Task Consume(ConsumeContext<SubmitOrder> context)
    {
        var message = context.Message;
        // message 是不可变 record，可安全传递
        await ProcessOrder(message);
    }
}

9.5 案例五：Dapr 状态管理

Dapr（分布式应用运行时）的 State API 推荐使用 record 表示状态：

public record ShoppingCartState
{
    public Guid UserId { get; init; }
    public ImmutableList<CartItem> Items { get; init; } = ImmutableList<CartItem>.Empty;
    public DateTime UpdatedAt { get; init; }
}

public record CartItem(string Sku, int Quantity);

public class ShoppingCartService
{
    private readonly DaprClient _dapr;

    public ShoppingCartService(DaprClient dapr) => _dapr = dapr;

    public async Task<ShoppingCartState> AddItem(string userId, CartItem item)
    {
        var key = $"cart-{userId}";
        var current = await _dapr.GetStateAsync<ShoppingCartState>("statestore", key)
                    ?? new ShoppingCartState { UserId = Guid.Parse(userId) };

        var updated = current with
        {
            Items = current.Items.Add(item),
            UpdatedAt = DateTime.UtcNow
        };

        await _dapr.SaveStateAsync("statestore", key, updated);
        return updated;
    }
}

10. 习题

10.1 选择题

Q1. 以下关于 C# record 的描述，哪项是错误的？

A. record class 与 record struct 都支持值相等 B. record 默认实现 Equals、GetHashCode、ToString、Deconstruct C. record 的 with 表达式在编译时展开为 <Clone>$ 调用 + 属性赋值 D. record class 必须显式定义主构造函数

public record Person
{
    public string Name { get; init; } = "";
    public int Age { get; init; }
}

Q2. 下列代码的输出是？

public record A(int X);
public record B(int X, int Y) : A(X);

var a = new A(1);
var b = new B(1, 2);
Console.WriteLine(a == b);

A. True B. False C. 编译错误 D. 运行时异常

Q3. 以下哪个 with 表达式不会编译通过？

A. record R(int X); var r = new R(1) with { X = 2 }; B. record R(int X) { public int X { get; set; } = X; } var r = new R(1) with { X = 2 }; C. readonly record struct S(int X); var s = new S(1) with { X = 2 }; D. record struct S(int X); var s = new S(1) with { X = 2 };

Q4. 关于 record struct 与 readonly record struct 的区别，下列哪项正确？

A. 两者都支持 with 表达式 B. readonly record struct 不允许定义 set 属性 C. record struct 不能实现接口 D. readonly record struct 装箱后不能调用 Equals

Q5. 以下代码的内存分配情况是？

public readonly record struct Point(double X, double Y);

var p1 = new Point(1, 2);
var p2 = p1 with { X = 10 };
object o = p1;

A. p1 在栈，p2 在堆，o 在堆 B. p1 在栈，p2 在栈，o 在堆 C. 全部在堆 D. 全部在栈

10.2 填空题

Q6. record 的 with 表达式在编译时调用 ________ 方法创建实例副本，再通过 ________ 访问器修改属性。

Q7. record 的 EqualityContract 属性返回类型为 ________，用于在继承场景下区分 ________。

Q8. init 访问器在 IL 层通过 ________ modreq 标识，仅允许在 ________ 阶段或 ________ 表达式中调用。

Q9. record struct 的默认布局特性是 ________，而 record class 是 ________。

Q10. record 重写的 GetHashCode 使用 ________ 算法组合各属性哈希，常数因子通常为 ________。

10.3 编程题

Q11. 实现一个不可变的二叉搜索树（BST），支持插入、查找、删除操作，全部基于 record。

public abstract record Tree<T> where T : IComparable<T>
{
    public static readonly Tree<T> Empty = new EmptyTree();

    public abstract Tree<T> Insert(T value);
    public abstract bool Contains(T value);
    public abstract Tree<T> Remove(T value);
    public abstract IEnumerable<T> InOrder { get; }
}

public sealed record EmptyTree<T> : Tree<T> where T : IComparable<T>
{
    public override Tree<T> Insert(T value) => new TreeNode<T>(value, this, this);
    public override bool Contains(T value) => false;
    public override Tree<T> Remove(T value) => this;
    public override IEnumerable<T> InOrder => Enumerable.Empty<T>();
}

public sealed record TreeNode<T>(T Value, Tree<T> Left, Tree<T> Right) : Tree<T>
    where T : IComparable<T>
{
    public override Tree<T> Insert(T value)
    {
        int cmp = value.CompareTo(Value);
        return cmp switch
        {
            < 0 => this with { Left = Left.Insert(value) },
            > 0 => this with { Right = Right.Insert(value) },
            _ => this
        };
    }

    public override bool Contains(T value)
    {
        int cmp = value.CompareTo(Value);
        return cmp switch
        {
            < 0 => Left.Contains(value),
            > 0 => Right.Contains(value),
            _ => true
        };
    }

    public override Tree<T> Remove(T value)
    {
        int cmp = value.CompareTo(Value);
        return cmp switch
        {
            < 0 => this with { Left = Left.Remove(value) },
            > 0 => this with { Right = Right.Remove(value) },
            _ => RemoveRoot()
        };
    }

    private Tree<T> RemoveRoot()
    {
        if (Left is EmptyTree<T>) return Right;
        if (Right is EmptyTree<T>) return Left;
        var min = FindMin(Right);
        return this with { Value = min, Right = Right.Remove(min) };
    }

    private static T FindMin(Tree<T> tree) => tree switch
    {
        EmptyTree<T> => throw new InvalidOperationException(),
        TreeNode<T> n when n.Left is EmptyTree<T> => n.Value,
        TreeNode<T> n => FindMin(n.Left),
        _ => throw new InvalidOperationException()
    };

    public override IEnumerable<T> InOrder
    {
        get
        {
            foreach (var v in Left.InOrder) yield return v;
            yield return Value;
            foreach (var v in Right.InOrder) yield return v;
        }
    }
}

要求：

1. 验证所有操作返回新树，原树不变。
2. 编写单元测试验证 BST 性质（左 < 根 < 右）。
3. 测量插入 10000 个元素的耗时与内存分配。

Q12. 实现一个基于 record 的 Result 错误处理类型，支持链式操作。

public abstract record Result<T>
{
    public static Result<T> Success(T value) => new SuccessResult<T>(value);
    public static Result<T> Failure(string error) => new FailureResult<T>(error);

    public abstract Result<U> Map<U>(Func<T, U> f);
    public abstract Result<U> Bind<U>(Func<T, Result<U>> f);
    public abstract T ValueOr(T fallback);
}

public sealed record SuccessResult<T>(T Value) : Result<T>
{
    public override Result<U> Map<U>(Func<T, U> f) => Result<U>.Success(f(Value));
    public override Result<U> Bind<U>(Func<T, Result<U>> f) => f(Value);
    public override T ValueOr(T _) => Value;
}

public sealed record FailureResult<T>(string Error) : Result<T>
{
    public override Result<U> Map<U>(Func<T, U> f) => Result<U>.Failure(Error);
    public override Result<U> Bind<U>(Func<T, Result<U>> f) => Result<U>.Failure(Error);
    public override T ValueOr(T fallback) => fallback;
}

// 使用示例
Result<int> ParseInt(string s) =>
    int.TryParse(s, out var n) ? Result<int>.Success(n) : Result<int>.Failure("Invalid integer");

var result = ParseInt("42")
    .Map(x => x * 2)
    .Bind(x => x > 100 ? Result<int>.Failure("Too large") : Result<int>.Success(x))
    .ValueOr(0);