---
title: CSharp-02-面向对象
aliases:
  - C# 面向对象
  - CSharp OOP
  - C# 类与结构体
tags:
  - 编程语言/CSharp
  - 类型/教程
created: 2026-10-11
updated: 2026-10-11
level: 入门
prerequisites:
  - "[[CSharp-01-环境与基础语法]]"
sources:
  - https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties
  - https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/object-oriented/polymorphism
  - https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/fundamentals
  - https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/record
  - https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/extension-methods
  - https://learn.microsoft.com/en-us/dotnet/api/system.idisposable
---

# CSharp-02-面向对象

> [!abstract] 这篇讲什么
> C# 是一门**面向对象（Object-Oriented Programming, OOP）**语言，但它的 OOP 不是为了"显得高级"：封装对应**不变量保护**，继承对应**复用与扩展点**，多态对应**在运行时替换实现**。本篇从"字段 vs 属性"这种最小的设计决策开始，一路讲到 `record`、`IDisposable`、运算符重载与 `object` 三件套的重写约定，每一条都回答同一个问题：**它解决什么真实问题，不用它会怎样**。
> 阅读前提：[[CSharp-01-环境与基础语法]]（类型、值/引用语义、命名空间）。示例以 **.NET SDK 10.0.401 / C# 13** 为基准，版本差异处标注「以官方最新文档为准」。

---

## 一、是什么：封装、继承、多态在 C# 里的落点

| OOP 支柱 | 解决的问题 | C# 提供的机制 |
|---|---|---|
| 封装（Encapsulation） | 对象状态被外部随意改动导致不一致 | 访问修饰符、属性、`readonly`、`init`、只读集合 |
| 继承（Inheritance） | 复制粘贴式复用带来的维护地狱 | `class : Base`、`virtual`/`override`、`abstract`、`sealed` |
| 多态（Polymorphism） | 调用方不该知道具体实现 | 虚方法 + 虚方法表（vtable）、接口、泛型约束 |
| 抽象（Abstraction） | 只暴露契约、隐藏实现 | `abstract class`、`interface`、默认接口实现 |

C# 的一个特点是**单继承 + 多接口**：类只能继承一个基类，但可以实现任意多个接口。这避免了 C++ 的多重继承菱形问题，同时用接口保留"多能力组合"的表达力。

---

## 二、为什么这样设计

### 2.1 为什么用属性，而不是公共字段

公共字段 `public int Age;` 看起来最省事，但它把**未来的修改成本**埋进去了：

| 需求变化 | 公共字段 | 属性 |
|---|---|---|
| 想加范围校验 | 破坏性改动：所有调用方要改成 `SetAge()` | 在 `set` 里加校验，调用方零改动 |
| 想改成计算值 | 不可能（字段就是存储） | 改成 `=> ...` 表达式体，零改动 |
| 想加日志/通知/懒加载 | 不可能 | 在访问器里做 |
| 想支持绑定（WPF/序列化） | 不支持（反射找属性） | 天然支持 |
| 二进制兼容性 | 改字段签名即破坏 ABI | 访问器是方法，可独立演进 |

结论：**字段是私有的实现细节，属性是公开的契约**。除了 `private`/`internal` 的内部数据载体和 `const`，公共成员一律用属性。

### 2.2 为什么有 `init` 和 `required`

不可变对象（immutable object）是并发安全与推理友好的基础，但用构造函数表达所有参数会很难写（参数一多就成了"参数爆炸"）。`init` 让"只能在对象初始化阶段赋值"成为语法能力，`required` 则强制调用方必须写。

```csharp
var cfg = new EndpointConfig { Host = "api.example.com", Port = 443 };  // 可读性接近字段初始化
// cfg.Host = "other";   // 编译错误：init 访问器只在初始化时可写
```

---

## 三、核心内容

### 3.1 类与对象

```csharp
// 类 = 类型的定义（模板）；对象 = 它的实例（在堆上）
public sealed class BankAccount
{
    // 私有字段：只在本类可见，外部无法绕过校验改余额
    private decimal _balance;

    // 属性：对外契约。get 只读，set 私有 —— 外部只能通过 Deposit 修改
    public string Owner { get; }
    public decimal Balance => _balance;   // 计算型属性，不占存储

    public BankAccount(string owner, decimal initial = 0m)
    {
        // 构造期校验：让"非法对象"根本创建不出来（保护不变量）
        if (string.IsNullOrWhiteSpace(owner))
            throw new ArgumentException("户主不能为空", nameof(owner));
        if (initial < 0)
            throw new ArgumentOutOfRangeException(nameof(initial), "初始余额不能为负");

        Owner = owner;
        _balance = initial;
    }

    public void Deposit(decimal amount)
    {
        if (amount <= 0) throw new ArgumentOutOfRangeException(nameof(amount));
        _balance += amount;
    }
}

var acc = new BankAccount("阿伟", 100m);
acc.Deposit(50m);
Console.WriteLine($"{acc.Owner}: {acc.Balance}");   // 阿伟: 150
```

### 3.2 字段与属性：五种属性写法

| 写法 | 代码 | 何时用 |
|---|---|---|
| 字段 | `private int _age;` | 内部存储，不对外暴露 |
| 自动属性 | `public int Age { get; set; }` | 最常用，无附加逻辑 |
| 只读自动属性 | `public int Age { get; }` | 构造时赋值，之后不变 |
| 计算属性 | `public bool IsAdult => Age >= 18;` | 由其他状态派生 |
| `init` 属性 | `public int Age { get; init; }` | 对象初始化器赋值，之后不可变 |
| `required` 属性 | `public required int Age { get; init; }` | 强制调用方在创建时提供 |
| 带逻辑的属性 | `public int Age { get => _age; set => _age = value < 0 ? 0 : value; }` | 需要校验/转换 |

```csharp
public class Profile
{
    // 自动属性：编译器生成隐藏的 backing field
    public string Name { get; set; } = "匿名";     // 默认值可在声明处给

    // init：只能在对象初始化器或构造函数里赋值，之后只读
    public DateOnly BirthDate { get; init; }

    // required：编译期强制"必须显式初始化"，取代"构造函数塞满参数"
    public required string Id { get; init; }

    // 属性可以有不同的访问级别：外部只读，内部可写
    public int LoginCount { get; private set; }

    public void RecordLogin() => LoginCount++;
}

// 对象初始化器：先调构造函数，再按顺序调用属性 set/init
var p = new Profile { Id = "u-001", BirthDate = new DateOnly(2000, 1, 1), Name = "阿伟" };
p.RecordLogin();
Console.WriteLine($"{p.Id} {p.Name} 登录 {p.LoginCount} 次");

// 编译错误示例（不要取消注释）：
// var bad = new Profile { BirthDate = new DateOnly(2000,1,1) };  // 缺 Id → required 报错
// p.Id = "u-002";                                                 // init 属性不能再赋值
```

> [!important] 属性初始化器的执行顺序
> 1. 字段/属性的**声明处初始化器**（按文本顺序）
> 2. **基类构造函数**
> 3. **本类构造函数体**
> 4. **对象初始化器**（在构造函数返回之后执行，按书写顺序）
> 所以 `init` 访问器里读到的其他属性可能还是默认值——不要依赖初始化器的执行顺序做交叉计算。

### 3.3 访问修饰符

| 修饰符 | 可见范围 | 典型用途 |
|---|---|---|
| `public` | 任何程序集 | 公开 API |
| `private` | 仅本类型（含嵌套类型） | 内部实现、字段 |
| `protected` | 本类型 + 派生类型 | 为子类提供的扩展点 |
| `internal` | 同一程序集 | 程序集内部协作，避免污染公开 API |
| `protected internal` | 同一程序集**或**派生类型（并集） | 少见，库内部扩展点 |
| `private protected` | 同一程序集**且**派生类型（交集） | 库内继承体系专用 |
| `file` | 仅当前**文件**（C# 11+） | 源生成器产物、单文件辅助类型 |

```csharp
public class Widget
{
    public string Name { get; set; } = "";       // 谁都能读
    private int _secret;                          // 只有本类
    protected int Depth { get; set; }             // 子类可访问
    internal string ModuleName { get; set; } = ""; // 同程序集可见

    protected internal void Hook() { }            // 同程序集 或 子类
    private protected void InternalHook() { }     // 同程序集 且 子类
}

// file 修饰的类型只在当前文件可见：避免为了一个辅助类起一个奇怪的名字
file sealed class WidgetHelper
{
    public static string Describe(Widget w) => $"Widget({w.Name})";
}
```

> [!warning] 默认可见性
> - 类型的默认可见性是 `internal`（不是 `public`）。
> - 类成员的默认可见性是 `private`。
> - 接口成员默认 `public`，且不能写 `private` 以外的更严格修饰符（C# 8+ 允许 `private` 成员用于默认实现内部复用）。
> - `protected` 成员既构成本类的 API，也构成**对所有子类的契约**：改动它就等于破坏性变更，谨慎使用。

### 3.4 构造函数与对象初始化器

| 成员 | 语法 | 何时调用 | 用途 |
|---|---|---|---|
| 实例构造函数 | `public C(...)` | `new C(...)` 时 | 初始化实例状态、校验参数 |
| 无参构造函数 | `public C() { }` | `new C()` | 需要默认构造时显式声明 |
| 静态构造函数 | `static C() { }` | 类型**首次被使用**前，且仅一次 | 初始化静态字段、读配置 |
| 私有构造函数 | `private C() { }` | `C.Create()` 内部 | 阻止 `new`，强制走工厂 |
| 主构造函数（C# 12+） | `class C(int x)` | `new C(1)` | 简洁声明不可变数据 |
| 终结器（Finalizer） | `~C() { }` | GC 回收前，不确定时机 | 仅用于释放非托管资源 |

```csharp
public class Connection
{
    private static readonly Dictionary<string, string> Aliases;

    // 静态构造函数：没有访问修饰符、不能带参数、不能手动调用
    // 适合做"只做一次"的初始化；抛异常会让类型永久不可用（TypeInitializationException）
    static Connection()
    {
        Aliases = new Dictionary<string, string> { ["local"] = "127.0.0.1" };
    }

    public string Host { get; }

    // 构造函数链：用 this(...) 复用默认值逻辑，避免重复校验代码
    public Connection() : this("local", 5432) { }

    public Connection(string host, int port)
    {
        if (port is < 1 or > 65535)
            throw new ArgumentOutOfRangeException(nameof(port));
        Host = Aliases.GetValueOrDefault(host, host);
        Port = port;
    }

    public int Port { get; }

    // 私有构造 + 静态工厂：语义清晰，且可返回缓存实例
    private Connection(string host) : this(host, 5432) { }
    public static Connection ForHost(string host) => new(host);

    public override string ToString() => $"{Host}:{Port}";
}

Console.WriteLine(new Connection());            // local → 127.0.0.1:5432
Console.WriteLine(Connection.ForHost("db"));    // db:5432
```

### 3.5 静态成员与静态构造函数

```csharp
public static class MathEx          // 静态类：不能实例化，只能放静态成员
{
    public const double Epsilon = 1e-9;            // 编译期常量

    // 静态字段：整个类型一份，多线程共享 —— 可变静态状态是并发 bug 的温床
    private static int _callCount;
    public static int CallCount => _callCount;

    public static bool NearlyEqual(double a, double b) => Math.Abs(a - b) < Epsilon;
}

// 静态成员用类型名访问，没有隐含的实例
Console.WriteLine(MathEx.NearlyEqual(0.1 + 0.2, 0.3));
```

| 对比项 | 实例成员 | 静态成员 |
|---|---|---|
| 归属 | 每个对象一份 | 类型一份 |
| 访问方式 | `obj.Member` | `Type.Member` |
| 能否访问实例成员 | 能 | **不能**（没有 `this`） |
| 生命周期 | 随对象 | 随应用域/类型加载 |
| 线程安全 | 对象本身不共享则安全 | 共享，需同步或用不可变 |

> [!warning] 静态构造函数与 `beforefieldinit`
> 没有显式静态构造函数的类型会被标记 `beforefieldinit`，运行时**可以在任意时刻**（通常是第一次访问前）初始化静态字段，时机更宽松、性能更好。一旦你写了静态构造函数，运行时就被强制为"精确时机"语义，可能引入初始化顺序依赖。**能用静态字段初始化器解决就别写静态构造函数**。

### 3.6 继承：`base`、虚方法与重写、`sealed`

```csharp
public abstract class Shape
{
    public string Name { get; }
    protected Shape(string name) => Name = name;

    // 虚方法：给出默认实现，子类可（也可不）重写 —— 这就是多态的入口
    public virtual double Area() => 0;

    // 抽象方法：没有实现，子类必须重写
    public abstract double Perimeter();

    // 非虚方法：不允许子类改变行为，保护关键逻辑（如不变量检查）
    public string Describe() => $"{Name}: 面积 {Area():F2}，周长 {Perimeter():F2}";
}

public class Circle : Shape
{
    private readonly double _r;

    // 用 base(...) 把参数转交给基类构造函数：基类状态必须由基类自己初始化
    public Circle(double r) : base("圆") => _r = r;

    // override 要求签名完全一致；返回类型协变（C# 9+）允许返回更具体的类型
    public override double Area() => Math.PI * _r * _r;
    public override double Perimeter() => 2 * Math.PI * _r;
}

// sealed 类：不能被继承。用于
// 1) 明确关闭扩展点（安全、可推理）  2) 让 JIT 能去虚化（性能）
public sealed class Unit : Shape
{
    public Unit() : base("单位") { }
    public override double Area() => 1;
    public override double Perimeter() => 4;
}

Shape[] shapes = [new Circle(1), new Unit()];
foreach (Shape s in shapes)
    Console.WriteLine(s.Describe());     // 运行时才决定调用哪个 Area()
```

| 关键字 | 含义 | 子类可否改变行为 |
|---|---|---|
| `virtual` | 有实现，可重写 | 可以（也可不重写） |
| `abstract` | 无实现，必须重写 | 必须 |
| `override` | 重写基类的虚/抽象成员 | 可以（除非加 `sealed`） |
| `sealed override` | 重写了，但**终止**再重写 | 不可以 |
| `new` | **隐藏**基类成员（不是重写） | 取决于静态类型 —— 通常是 bug |
| （无修饰符） | 非虚方法 | 不可以 |

> [!danger] `new` 隐藏成员是多态杀手
> ```csharp
> class A { public virtual string Who() => "A"; }
> class B : A { public new string Who() => "B"; }   // 隐藏，不是重写
> A x = new B();
> Console.WriteLine(x.Who());   // 输出 "A"！
> ```
> 因为 `Who()` 不是虚调用，编译器按**静态类型** `A` 绑定。这正是"为什么应该用 `override`"的最有力证明。编译器会给出警告（`CS0108`），别忽略它。

### 3.7 多态的实现原理：虚方法表（vtable）

每个类型在加载时，运行时为其构建一张**方法表（Method Table）**，其中包含该类型所有虚方法的**实际入口地址**。对象头里有一个指向自己类型方法表的指针。

```
对象实例                    类型的方法表（Method Table / vtable）
┌──────────────┐           ┌──────────────────────────────┐
│ 同步块索引    │           │ Area()      → Circle.Area     │
│ 方法表指针 ───┼──────────►│ Perimeter() → Circle.Perim.   │
│ 字段 _r      │           │ ToString()  → Object.ToString │
└──────────────┘           └──────────────────────────────┘
```

一次虚调用 `s.Area()` 的执行过程：

1. 取 `s` 的对象头里的方法表指针；
2. 按固定**槽位索引**在表里查到 `Area` 的地址；
3. 跳转执行（间接调用）。

代价与优化：

- 代价：一次间接跳转，且**阻止内联**（编译器不知道目标是谁），分支预测器可能猜错。
- 优化一：**去虚化（devirtualization）**。JIT 若发现 `s` 的实际类型唯一（如 `new Circle()` 后立即调用、或类型是 `sealed`），就把虚调用改成直接调用甚至内联。
- 优化二：接口调用在 .NET 里有**接口分发（interface dispatch）**的专用缓存，比早期版本快很多。
- 关键结论：**多态不是"免费的抽象"，但在绝大多数代码里它的开销可以忽略；只有剖析（profiling）证明它是热点时才需要处理。**

### 3.8 抽象类与接口：对比与选型

| 维度 | 抽象类（`abstract class`） | 接口（`interface`） |
|---|---|---|
| 继承数量 | 只能继承 1 个 | 可实现任意多个 |
| 能否有字段 | 能（实例状态） | **不能**（C# 8+ 可有静态字段，但不能有实例字段） |
| 能否有构造函数 | 能 | 不能 |
| 成员实现 | 可以有具体方法（非抽象） | 默认实现可选（C# 8+ 默认接口成员） |
| 版本兼容性 | 加抽象成员会破坏所有子类 | 加**默认实现**的成员不破坏实现方 |
| 可见性 | 成员可 `protected`/`internal` | 成员默认 `public` |
| 语义 | "**是一种**（is-a）"，共享实现 | "**能做某事**（can-do）"，声明能力 |
| 典型例子 | `Stream`、`Shape` | `IDisposable`、`IComparable<T>`、`IEnumerable<T>` |

```csharp
// 接口：只声明能力，不关心实现者是谁
public interface IShape
{
    double Area();

    // 默认接口实现（C# 8+）：给已有接口"加成员而不破坏实现方"
    // 注意：默认实现只能通过接口类型的引用调用，实现类的实例上不可见
    string Describe() => $"面积 {Area():F2}";
}

public sealed class Square : IShape
{
    private readonly double _side;
    public Square(double side) => _side = side;
    public double Area() => _side * _side;
}

IShape sq = new Square(3);
Console.WriteLine(sq.Area());        // 9
Console.WriteLine(sq.Describe());    // 面积 9.00（默认实现，需通过接口引用调用）
```

静态抽象接口成员（C# 11+）是另一件事：让接口能声明**静态契约**，供泛型算法使用——这是"零开销抽象"的基石。两个必须注意的点：返回类型要写成**类型参数本身**（写成接口名会报 `CS8926`），并且类型参数要构成自引用约束 `where TSelf : IShape<TSelf>`（也叫 F-bounded 约束）。

```csharp
// 静态抽象成员：泛型算法可以直接调用 T.Unit，JIT 为每个 T 生成专用代码（无反射、无装箱）
public interface IShape<TSelf> where TSelf : IShape<TSelf>
{
    double Area();
    string Describe() => $"面积 {Area():F2}";   // 默认实现与静态抽象成员可以共存
    static abstract TSelf Unit { get; }         // 返回类型必须是 TSelf，不能写成 IShape<TSelf>
}

public sealed class Square : IShape<Square>
{
    private readonly double _side;
    public Square(double side) => _side = side;
    public double Area() => _side * _side;
    public static Square Unit => new Square(1); // 实现静态抽象成员
}

static T CreateUnit<T>() where T : IShape<T> => T.Unit;   // 零开销：编译为对 T 静态方法的直接调用

IShape<Square> sq = new Square(3);
Console.WriteLine(sq.Describe());              // 面积 9.00
Console.WriteLine(CreateUnit<Square>().Area()); // 1
```

> [!tip] 默认接口实现解决的真实痛点
> 你发布了一个 `IRepository` 接口，几十个类实现了它。现在想加一个便捷方法 `GetOrNull(id)`。传统接口做不到——加成员就会让所有实现类编译不过。默认接口实现允许你**只加方法体**就完成演进，实现方零改动。
> 代价是：默认实现不能被实现类"继承"（只能通过接口引用调用），且它带来了一定的运行时成本（接口分发）。**能改所有实现方时，仍然优先直接加成员。**

选型建议：

- 需要**共享状态或大量复用实现**、且概念上确有"是一种"关系 → 抽象类。
- 只表达**能力/契约**，或一个类型需要多种能力 → 接口。
- 需要**版本演进**（库作者给已发布接口加成员）→ 接口 + 默认实现。
- 只有"数据 + 少量行为"且不需要继承 → 考虑 `record` 或 `readonly struct`。
- **不要为了复用代码而用继承**：优先组合（composition）。继承是最强的耦合形式。

### 3.9 结构体与类的区别

| 维度 | `struct` | `class` |
|---|---|---|
| 类型 | 值类型 | 引用类型 |
| 赋值 | 复制全部字段 | 复制引用 |
| 默认 `Equals` | 逐字段比较 | 引用相等 |
| 能否为 `null` | 不能（`T?` 可以） | 可以 |
| 继承 | 不能继承、不能被继承（可实现接口） | 完全支持 |
| 参数传递 | 默认按值复制（`in`/`ref` 可避免） | 默认传引用 |
| 大小建议 | **≤ 16–24 字节**，且不可变 | 无限制 |
| 分配位置 | 通常在栈，或内联在宿主里 | 托管堆 |
| 适用场景 | 小数据载体（坐标、范围、颜色、金额、`ValueTuple`） | 有身份、有生命周期、可能较大 |

```csharp
// readonly struct：所有字段 readonly，编译器可据此优化（避免防御性复制）
public readonly struct Money : IEquatable<Money>
{
    public decimal Amount { get; }
    public string Currency { get; }

    public Money(decimal amount, string currency)
    {
        Amount = amount;
        Currency = currency ?? throw new ArgumentNullException(nameof(currency));
    }

    // 实现 IEquatable<T> 避免装箱，并明确相等语义（见 3.15）
    public bool Equals(Money other) =>
        Amount == other.Amount && string.Equals(Currency, other.Currency, StringComparison.Ordinal);

    public override bool Equals(object? obj) => obj is Money m && Equals(m);
    public override int GetHashCode() => HashCode.Combine(Amount, Currency);
    public override string ToString() => $"{Amount} {Currency}";

    public static Money operator +(Money a, Money b) =>
        a.Currency == b.Currency
            ? new Money(a.Amount + b.Amount, a.Currency)
            : throw new InvalidOperationException("币种不同，不能相加");
}

var a = new Money(10m, "CNY");
var b = new Money(5m, "CNY");
Console.WriteLine(a + b);                       // 15 CNY
Console.WriteLine((a + b).Equals(new Money(15m, "CNY")));   // True
```

> [!warning] 可变结构体的经典陷阱
> ```csharp
> struct Counter { public int Value; public void Inc() => Value++; }
> var list = new List<Counter> { new Counter() };
> list[0].Inc();                 // 编译错误：不能修改返回的临时副本
> var c = list[0]; c.Inc(); list[0] = c;   // 必须这样写
> ```
> `List<T>` 的索引器返回**副本**，`list[0].Inc()` 修改的是临时值。历史上这个坑也出现在 `foreach` 迭代变量上（C# 5 之前是可变副本，现在 `foreach` 变量默认只读）。**结论：结构体一律做成不可变（`readonly struct`）**。

### 3.10 枚举与 `[Flags]`

```csharp
// 普通枚举：底层是整数，默认从 0 递增
public enum OrderStatus { Pending, Paid, Shipped, Cancelled }

// [Flags] 标志枚举：值必须是 2 的幂，可组合
[Flags]
public enum FileAccess : byte      // 可指定底层类型：byte/sbyte/short/ushort/int/uint/long/ulong
{
    None      = 0,
    Read      = 1 << 0,   // 1
    Write     = 1 << 1,   // 2
    Execute   = 1 << 2,   // 4
    ReadWrite = Read | Write,
    All       = Read | Write | Execute,
}

var perm = FileAccess.Read | FileAccess.Write;

// HasFlag：注意它对"值为 0 的标志"总是返回 true，且早期实现有装箱开销
Console.WriteLine(perm.HasFlag(FileAccess.Write));         // True
Console.WriteLine((perm & FileAccess.Execute) != 0);       // False（推荐写法，无装箱）

// ToString() 会优先匹配"名字完全等于该组合值"的成员，所以这里输出 ReadWrite 而不是 "Read, Write"
Console.WriteLine(perm);                                    // ReadWrite（因为定义了 ReadWrite = Read | Write）
Console.WriteLine((int)perm);                               // 3
Console.WriteLine(Enum.TryParse<FileAccess>("read", true, out var parsed));  // True（忽略大小写）
```

| 使用要点 | 说明 |
|---|---|
| 普通枚举不要用 `[Flags]` | 否则 `ToString()` 输出难以阅读 |
| 标志枚举的 `None = 0` | 表示"无标志"，是组合运算的单位元 |
| 用 `&` 判断、`\|` 组合、`~` 取反 | 不要用 `HasFlag` 判断 0 值标志 |
| `ToString()` 优先匹配已命名成员 | 定义了 `ReadWrite = Read \| Write` 时，`perm.ToString()` 给 `ReadWrite` 而非 `"Read, Write"`；去掉这个复合成员才会看到分解结果 |
| 枚举值改数字会破坏持久化数据 | 数据库/JSON 里存了枚举的整数，重排值就是数据事故；显式赋值锁定 |
| 枚举参与字符串转换有反射成本 | 热路径上考虑 `switch` 或缓存 |
| 想给枚举成员加方法 | 用**扩展方法**（见 3.13） |

### 3.11 `record` 与 `record struct`

`record` 的核心是**值相等性 + 非破坏性变更**：两个 `record` 的所有属性相等就 `==`，`with` 生成改了几个属性的新实例。

```csharp
// record class（引用类型，但用值语义比较）
public record Person(string Name, int Age)
{
    // 位置参数自动生成：构造、init 属性、Deconstruct、值相等、ToString、with
    public string Display => $"{Name}({Age})";
}

// record struct：值类型 + 值相等（C# 10+）
public readonly record struct Point(double X, double Y);

var p1 = new Person("阿伟", 30);
var p2 = new Person("阿伟", 30);
Console.WriteLine(p1 == p2);          // True —— 引用类型但按值比较
Console.WriteLine(p1);                // Person { Name = 阿伟, Age = 30 }

// with 表达式：浅复制 + 覆盖部分属性，原对象不变
var p3 = p1 with { Age = 31 };
Console.WriteLine($"{p1.Age} → {p3.Age}");   // 30 → 31

// 解构（由位置参数自动生成）
var (name, age) = p3;

var a = new Point(1, 2);
var b = new Point(1, 2);
Console.WriteLine(a == b);            // True —— 值类型比较，无装箱
```

| 对比项 | `class` | `record`（引用类型） | `record struct` | `struct` |
|---|---|---|---|---|
| 相等语义 | 引用相等（除非重写） | **值相等**（自动生成） | 值相等 | 逐字段反射比较（慢） |
| `with` 表达式 | 不支持 | 支持 | 支持 | 不支持 |
| `ToString` | 类型名 | 自动打印所有属性 | 自动打印所有属性 | 类型名 |
| 解构 `Deconstruct` | 手写 | 位置参数自动生成 | 位置参数自动生成 | 手写 |
| 可继承 | 是 | 是（可 `sealed`） | 否 | 否 |
| 可变性 | 任意 | 属性默认 `init` | 属性默认 `get/set`（建议 `readonly`） | 任意 |
| 适合 | 有身份的对象 | DTO、事件、领域值 | 小坐标/区间 | 小数据载体 |

> [!important] `record` 的相等性是**浅**比较
> 如果 `record` 里有个 `List<int>` 属性，`==` 比较的是**引用**，不是元素。需要深比较就自己重写 `Equals`/`GetHashCode`。另外 `with` 也是浅复制：复制后两个实例仍共享同一个列表对象。

### 3.12 分部类与分部方法

分部（`partial`）让**一个类型分散在多个文件**，主要服务于：源生成器产出代码、大型类的职责拆分、设计器代码与手写代码分离。

```csharp
// 文件 A：手写部分
public partial class ReportBuilder
{
    private readonly List<string> _lines = new();

    public void Add(string line) => _lines.Add(line);

    // 分部方法：声明与实现分离。C# 9+ 可以带返回值与 out 参数
    // 若没有实现，编译器会把调用点整个移除（零开销的钩子）
    partial void OnAdded(string line);

    public string Build()
    {
        OnAdded("build");                 // 没有实现时这一行会被删掉
        return string.Join(Environment.NewLine, _lines);
    }
}

// 文件 B：生成/扩展部分
public partial class ReportBuilder
{
    private int _count;

    // 实现分部方法
    partial void OnAdded(string line) => _count++;

    public int Count => _count;
}

var rb = new ReportBuilder();
rb.Add("第一行");
Console.WriteLine($"{rb.Build()} / 计数 {rb.Count}");   // 第一行 / 计数 1
```

> [!warning] `partial` 的边界
> - 所有部分必须**同一程序集、同一命名空间、同一类型名**，且 `partial` 不能用在接口/枚举/委托上（接口和枚举不支持，`record` 支持）。
> - 分部方法必须是 `private`（隐式），不能有访问修饰符（C# 9+ 允许 `public` 等修饰符，但此时**必须**有实现）。
> - 不要用它来把"上帝类"拆成多文件假装不大——文件数不改变耦合度。

### 3.13 扩展方法

扩展方法让你在**不修改原类型、不继承**的前提下为它添加方法（LINQ 就是靠它实现的）。

三条定义规则：

1. 必须定义在**非嵌套、非泛型的静态类**里；
2. 方法必须是 `static`；
3. 第一个参数带 `this` 修饰符，且方法不能是 `ref struct` 相关特殊情形。

```csharp
public static class StringExtensions
{
    // 扩展方法：调用时 this 参数不出现在实参里
    public static string Truncate(this string value, int maxLength)
    {
        ArgumentNullException.ThrowIfNull(value);
        if (maxLength < 0) throw new ArgumentOutOfRangeException(nameof(maxLength));
        return value.Length <= maxLength ? value : value[..maxLength] + "…";
    }

    // 给枚举加语义方法：枚举本身不能定义方法
    public static bool Includes(this FileAccess value, FileAccess flag) => (value & flag) == flag;

    // 泛型扩展 + 约束：对所有 IComparable 的值类型可用
    public static T Clamp<T>(this T value, T min, T max) where T : IComparable<T>
    {
        if (value.CompareTo(min) < 0) return min;
        return value.CompareTo(max) > 0 ? max : value;
    }
}

Console.WriteLine("Hello, world".Truncate(7));           // Hello, …
Console.WriteLine(FileAccess.Read.Includes(FileAccess.Read));  // True
Console.WriteLine(15.Clamp(0, 10));                      // 10
```

| 要点 | 说明 |
|---|---|
| 优先级低于实例方法 | 实例上已有同名方法时，实例方法胜出（可用它做"版本迁移"） |
| 通过命名空间生效 | 所在命名空间没 `using` 就找不到扩展方法 |
| 不能访问私有成员 | 它只是语法糖的静态调用，不是真正的成员 |
| 对 `null` 调用不抛异常 | `((string)null!).Truncate(3)` 能进入方法体 → 必要时自己 `ThrowIfNull` |
| 不要滥用 | 给 `object`/`int` 加一堆扩展方法会污染整个项目的补全列表 |

### 3.14 索引器

索引器让对象支持 `obj[key]` 语法，本质是名为 `this` 的参数化属性。

```csharp
public class Matrix
{
    private readonly double[,] _data;

    public Matrix(int rows, int cols)
    {
        _data = new double[rows, cols];
        Rows = rows; Cols = cols;
    }

    public int Rows { get; }
    public int Cols { get; }

    // 索引器：可以有多个参数（这里是行、列）
    public double this[int row, int col]
    {
        get => _data[row, col];
        set => _data[row, col] = value;      // 也可以在这里做校验
    }

    // 只读索引器：支持 C# 8 的范围语法（matrix[1..3]）
    public double[] this[Range rows]
    {
        get
        {
            var (offset, length) = rows.GetOffsetAndLength(Rows);
            var result = new double[length * Cols];
            for (int i = 0; i < length; i++)
                for (int j = 0; j < Cols; j++)
                    result[i * Cols + j] = _data[offset + i, j];
            return result;
        }
    }
}

var m = new Matrix(3, 3);
m[1, 1] = 5;
Console.WriteLine(m[1, 1]);        // 5
Console.WriteLine(m[0..2].Length); // 6（前两行）
```

> [!tip] 索引器的设计约定
> - 索引器里有**副作用或昂贵计算**时，考虑提供 `TryGet` 风格的方法，避免"看起来是读取、实际很慢"。
> - 集合类型的索引器一般**不返回可空**；字典语义的索引器在键不存在时通常 `throw KeyNotFoundException`，并另配 `TryGetValue`。
> - `IEnumerable<T>` 上也定义了 `ElementAt`，但那是 $O(n)$ 的线性查找——别把它当索引器用。

### 3.15 `object` 的三个基本方法：`ToString` / `Equals` / `GetHashCode`

| 方法 | 默认行为 | 重写约定 |
|---|---|---|
| `ToString()` | 返回类型全名 | 给调试/日志用的可读表示；**不要**用来做序列化或业务逻辑 |
| `Equals(object?)` | 引用相等（值类型为逐字段反射比较） | 满足自反、对称、传递、一致性；同时实现 `IEquatable<T>` 避免装箱 |
| `GetHashCode()` | 基于引用（值类型为第一个字段的组合） | 相等对象**必须有相同哈希码**；不等的对象哈希码应尽量分散 |

**为什么重写 `Equals` 就必须重写 `GetHashCode`？** 因为哈希容器（`Dictionary`、`HashSet`）先按哈希码定位桶，再在桶内用 `Equals` 比较：

```csharp
public class UserId
{
    public string Value { get; }
    public UserId(string value) => Value = value;

    public override bool Equals(object? obj) => obj is UserId other && Value == other.Value;
    public override int GetHashCode() => Value.GetHashCode();
    public override string ToString() => Value;
}

var a = new UserId("u-1");
var b = new UserId("u-1");           // 不同实例，逻辑相等

Console.WriteLine(a.Equals(b));      // True
Console.WriteLine(a.GetHashCode() == b.GetHashCode());   // True

// HashSet 只有一行代码，却同时依赖这两个方法：
var set = new HashSet<UserId> { a };
Console.WriteLine(set.Contains(b));  // True —— 哈希码一致 → 同桶 → Equals 判定相等

// 如果忘了重写 GetHashCode：a 和 b 哈希码不同，落在不同桶，
// Contains 直接返回 False，即使 Equals 说它们相等 —— 这就是"哈希容器静默失效"的经典 bug
```

| 哈希契约 | 要求 |
|---|---|
| 相等 → 同哈希 | 必须满足，否则哈希容器错乱 |
| 同哈希 ↛ 相等 | 允许（哈希冲突），此时靠 `Equals` 区分，只是性能退化 |
| 对象作为键期间不可变 | 键的字段一旦改变，哈希码就变了，字典再也找不到它 |

> [!danger] 可变对象作字典键
> ```csharp
> var dict = new Dictionary<UserId, int> { [a] = 1 };
> // 如果 UserId.Value 是可变的，改完 Value 后：
> // dict[a] → KeyNotFoundException（哈希码变了，桶变了）
> // 而且键还留在原来的桶里 → 内存泄漏式的"幽灵条目"
> ```
> **字典键必须不可变**：用 `readonly` 字段、`init` 属性，或直接用 `string`/`int`/`record`。

### 3.16 `IDisposable` 与 `using` 声明

垃圾回收（Garbage Collection, GC）只管理**托管内存**，管不了文件句柄、网络连接、GDI 句柄、数据库连接。这些必须显式释放，这就是 `IDisposable`。

```csharp
// 标准释放模式（Dispose Pattern）：托管资源 + 非托管资源 + 终结器
public sealed class TempFileWriter : IDisposable
{
    private FileStream? _stream;
    private bool _disposed;

    public TempFileWriter(string path)
    {
        // FileOptions.DeleteOnClose 让文件在句柄关闭时自动删除
        _stream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
    }

    public void Write(string text)
    {
        // 每次使用前检查：用法错误应该尽早失败，而不是写入一个已关闭的流
        ObjectDisposedException.ThrowIf(_disposed, this);
        var bytes = System.Text.Encoding.UTF8.GetBytes(text);
        _stream!.Write(bytes);
    }

    public void Dispose()
    {
        if (_disposed) return;          // 幂等：多次 Dispose 必须安全
        _disposed = true;
        _stream?.Dispose();             // 只需释放自己拥有的托管资源
        _stream = null;
    }
    // 本类不持有非托管资源 → 不需要终结器，也不需要完整的 Dispose(bool) 模板
}

// using 语句（块）：离开作用域就释放，即使抛异常
using (var w1 = new TempFileWriter(Path.GetTempFileName()))
{
    w1.Write("hello");
}

// using 声明（C# 8+）：离开所在作用域时释放，写法更扁平
static string WriteTemp()
{
    using var w2 = new TempFileWriter(Path.GetTempFileName());
    w2.Write("world");
    return "ok";
}   // 这里自动 Dispose

// using 也能用于实现了 Dispose 的非 IDisposable 类型（模式匹配 Dispose）
// 以及 ref struct（如 Span<T> 相关类型），这是 C# 8+ 的放宽
```

| 写法 | 释放时机 | 适用 |
|---|---|---|
| `using (...) { }` | 块结束时 | 作用域就是块的边界 |
| `using var x = ...;` | 所在方法/块结束时 | 方法体较长、想减少缩进 |
| `try/finally { x.Dispose(); }` | 手动控制 | 需要在释放前后做特殊处理 |
| `await using` | 异步释放（`IAsyncDisposable`） | `DisposeAsync` 要等 IO 完成 |
| 不写 `using`，靠 GC | **不确定**（可能几分钟后） | 只有极少数"内存压力型"资源可以 |

> [!warning] 三个真实的释放错误
> 1. **忘记 `using`**：文件被占用、连接池耗尽。Windows 上表现为"文件正被另一个进程使用"。
> 2. **在 `using` 块外使用对象**：`var s = new StreamReader(p); using (s) {...} s.ReadLine();` → `ObjectDisposedException`。
> 3. **`Dispose` 抛异常掩盖真实异常**：`using` 的释放发生在 `finally` 里，若它抛异常会顶掉原来的异常。释放逻辑尽量不抛（或用 `try/catch` 包住）。
> 另外：`Dispose` 与终结器（`~Ctor`）**不要**混用除非你确实持有非托管资源（如 `SafeHandle` 之外的原生指针）。有终结器的对象会被提升到更高代，显著增加 GC 成本。

### 3.17 命名参数、可选参数与 `nameof`

```csharp
// 可选参数必须是"编译期常量"，且必须排在必需参数之后
public static string Format(string template, bool upper = false, int width = 0, string pad = " ")
{
    string s = upper ? template.ToUpperInvariant() : template;
    return width > s.Length ? s.PadLeft(width, pad[0]) : s;
}

// 命名参数：调用点自解释，也让"跳过中间可选参数"成为可能
Console.WriteLine(Format("hi", width: 5, pad: "."));   // ...hi
Console.WriteLine(Format(template: "hi", upper: true));// HI

// 位置参数必须在命名参数之前（C# 7.2+ 允许命名参数后跟位置参数，若位置正确）
Console.WriteLine(Format("hi", true, 4));

public class Customer
{
    public string Name { get; set; } = "";

    // nameof：取标识符的字符串，重构安全（改名不会漏）
    public void Rename(string newName)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(newName);
        Name = newName;
    }

    public void Validate()
    {
        // 对比：写死 "Name" 字符串 → 改名后 MVVM/序列化悄悄失效
        throw new ArgumentException("名字非法", nameof(Name));
    }
}

Console.WriteLine(nameof(Customer));            // Customer
Console.WriteLine(nameof(Customer.Name));       // Name（只取最后一段）
Console.WriteLine(nameof(System.Collections.Generic.List<int>));  // List
```

| 特性 | 关键限制 |
|---|---|
| 可选参数 | 值被**编译进调用方**：改默认值需重编译调用方（同 `const` 的陷阱） |
| 可选参数 | 只能是编译期常量、`default`、`new T()`（值类型）或 `default(T)` |
| 命名参数 | 与位置参数混用时，位置参数必须在前且顺序正确 |
| `nameof` | 不求值，编译期直接变字符串常量，零运行时开销 |
| `nameof` | 可用于参数、局部变量、类型、成员、泛型类型；不能用于方法组本身以外的表达式 |

---

## 四、怎么用：一个完整的领域模型示例

需求：实现一个小型订单模型，要求**对象创建后不可变**（除状态机允许的转换）、**金额不允许为负**、**相等性按业务键判定**、**资源正确释放**。

```csharp
using System.Text;

namespace Demo.Orders;

public interface IOrderRepository
{
    void Save(Order order);
}

// 状态用枚举，避免字符串魔法值
public enum OrderState { Created, Paid, Shipped, Cancelled }

// 值对象：readonly record struct + 运算符重载，表达"不可变金额"
public readonly record struct Money(decimal Amount, string Currency)
{
    public static Money Cny(decimal amount) =>
        amount < 0 ? throw new ArgumentOutOfRangeException(nameof(amount)) : new Money(amount, "CNY");

    public static Money operator +(Money a, Money b) =>
        a.Currency == b.Currency ? new Money(a.Amount + b.Amount, a.Currency)
                                 : throw new InvalidOperationException($"币种不一致：{a.Currency}/{b.Currency}");

    public override string ToString() => $"{Amount:0.00} {Currency}";
}

// 实体：有身份（Id 决定相等），行为通过方法暴露，状态由方法驱动
public sealed class Order : IEquatable<Order>
{
    private readonly List<string> _items = new();
    private OrderState _state = OrderState.Created;

    public required string Id { get; init; }          // required：创建时必须给
    public Money Total { get; private set; } = Money.Cny(0);
    public OrderState State => _state;

    public IReadOnlyList<string> Items => _items;     // 只读视图：外部不能 Add

    public void AddItem(string sku, decimal price)
    {
        EnsureState(OrderState.Created, "只有创建态可以加商品");
        ArgumentException.ThrowIfNullOrWhiteSpace(sku);
        _items.Add(sku);
        Total += Money.Cny(price);
    }

    public void Pay()
    {
        EnsureState(OrderState.Created, "只有创建态可以支付");
        if (_items.Count == 0) throw new InvalidOperationException("空订单不能支付");
        _state = OrderState.Paid;
    }

    private void EnsureState(OrderState expected, string message)
    {
        if (_state != expected)
            throw new InvalidOperationException($"{message}（当前 {_state}）");
    }

    // 实体的相等性按业务键（Id），而不是按所有字段
    public bool Equals(Order? other) =>
        other is not null && string.Equals(Id, other.Id, StringComparison.Ordinal);

    public override bool Equals(object? obj) => Equals(obj as Order);
    public override int GetHashCode() => StringComparer.Ordinal.GetHashCode(Id);
    public override string ToString() =>
        new StringBuilder().Append(Id).Append(' ').Append(_state).Append(' ').Append(Total).ToString();
}

// 用扩展方法给枚举加"状态机合法性"判断，避免把规则散落在各处
public static class OrderStateExtensions
{
    public static bool IsFinal(this OrderState s) =>
        s is OrderState.Shipped or OrderState.Cancelled;
}
```

调用与验证：

```csharp
var order = new Order { Id = "O-1001" };
order.AddItem("SKU-A", 19.90m);
order.AddItem("SKU-B", 5.00m);
order.Pay();

Console.WriteLine(order);                     // O-1001 Paid 24.90 CNY
Console.WriteLine(order.State.IsFinal());     // False
Console.WriteLine(order.Items.Count);         // 2

// 相等性：按 Id 判定，与实例无关
var same = new Order { Id = "O-1001" };
Console.WriteLine(order.Equals(same));        // True
Console.WriteLine(ReferenceEquals(order, same)); // False

try { order.AddItem("SKU-C", 1m); }
catch (InvalidOperationException ex) { Console.WriteLine(ex.Message); }  // 只有创建态可以加商品（当前 Paid）
```

设计要点回顾：`required` 保证 `Id` 不会漏；`IReadOnlyList<string>` 暴露只读视图而不是 `List<string>`（避免外部绕过 `AddItem` 破坏 `Total` 的一致性）；`Money` 是不可变值对象，越界在构造处就抛异常；`Order` 的相等性按业务键，而不是按全部字段。

---

## 五、注意事项与常见坑

> [!warning] 面向对象里最容易踩的十二个坑
> 1. **公共字段**：以后加校验就是破坏性改动。公共成员一律属性。
> 2. **`new` 隐藏成员而非 `override`**：多态失效，`A x = new B()` 调到的是 `A` 的实现。
> 3. **在构造函数里调用虚方法**：基类构造函数执行时子类字段还是默认值，虚方法可能读到未初始化状态（经典 NPE/0 值 bug）。
> 4. **可变结构体**：`list[0].Inc()` 改的是副本。结构体一律 `readonly struct`。
> 5. **重写 `Equals` 忘了 `GetHashCode`**：`HashSet`/`Dictionary` 静默失效。
> 6. **用可变对象作字典键**：改字段后键"消失"，还留下幽灵条目。
> 7. **静态可变状态**：多线程下是数据竞争，测试之间还会互相污染。
> 8. **`record` 的浅比较**：含集合属性时 `==` 比的是集合引用。
> 9. **忘了 `Dispose`**：文件占用、连接池耗尽；`Dispose` 前的对象要判 `_disposed`。
> 10. **可选参数默认值写死在调用方**：改了默认值不重编译调用方不生效（同级 `const` 陷阱）。
> 11. **`[Flags]` 枚举用 0 值判断**：`perm.HasFlag(FileAccess.None)` 永远 `true`。
> 12. **用继承做代码复用**：优先组合。继承是最强耦合——基类一改，所有子类都得跟着改。

> [!tip] 设计上的实践建议
> - **默认 `sealed`**：不确定要不要被继承时先 `sealed`，需要时再打开。开启扩展点是成本，不是收益。
> - **默认不可变**：属性用 `get`/`init`，集合暴露 `IReadOnlyList<T>`。不可变对象天然线程安全、可安全缓存。
> - **构造即校验**：让非法状态根本无法构造，比让每个方法都要判合法性要可靠得多。
> - **小接口**：接口按能力划分（`IReadOnlyList` 而非"万能集合接口"），实现方负担低、mock 也容易。
> - **优先组合 + 依赖注入**：见 [[后端-03-ASPNET-Core]] 的依赖注入实践。
> - **`ToString` 只给调试**：不要拿它做序列化或业务判断，给它一个稳定的、人类可读的格式就够了。

---

## 六、练习题

1. **基础题**：写一个 `Temperature` 类，要求：构造函数接收摄氏度并校验不低于 $-273.15$；提供只读属性 `Celsius`、计算属性 `Fahrenheit`、`Kelvin`；实现 `ToString()` 返回 `"25.0°C / 77.0°F"`。
2. **基础题**：定义一个 `[Flags] enum Permissions { None=0, Read=1, Write=2, Delete=4, All=Read|Write|Delete }`，用扩展方法 `Has(this Permissions p, Permissions flag)` 实现权限判断（注意 `None` 的语义），并写 3 条断言验证。
3. **进阶题**：把下面的类改造成不可变设计，并解释每处改动的原因：
   ```csharp
   public class Config { public string Url; public List<string> Headers = new(); public int Timeout; }
   ```
   要求：`Timeout` 只允许 $1 \le t \le 300$；`Headers` 外部只能读；提供 `with` 风格的 `WithTimeout(int)` 方法；实现值相等性。
4. **进阶题**：实现 `sealed class CsvWriter : IDisposable`，构造时打开文件并写入表头，`WriteRow(params string[] cells)` 转义逗号与双引号，`Dispose` 时关闭流。要求多次 `Dispose` 安全，并在 `WriteRow` 里对已释放状态抛 `ObjectDisposedException`。再用 `using` 声明调用它。
5. **思考题**：`abstract class` 与 `interface` 都能定义契约。请给出**两个必须用抽象类**、**两个必须用接口**的具体场景，并解释在 C# 8 引入默认接口实现之后，抽象类是否还有不可替代的价值。提示：从实例字段、构造函数、`protected` 成员、多重实现四个角度考虑。

---

## 七、常见问题（FAQ）

**Q1：属性和字段在运行时有什么区别？性能一样吗？**
A：自动属性会被编译成"一个私有字段 + `get_`/`set_` 方法"，调用是**方法调用**，但因为通常极短，JIT 会内联，运行时开销与字段访问几乎无差。区别在于：字段可以 `ref` 传递、可以作为 `const` 语义、可以出现在 `Interlocked` 里；属性可以有逻辑、可以只读、可以参与接口。**性能不是选字段的理由，语义才是。**

**Q2：什么时候该用 `record`，什么时候该用普通 `class`？**
A：`record` 适合**数据为中心、按值判断相等**的类型：DTO、消息、事件、坐标、配置片段。普通 `class` 适合**有身份和生命周期**的类型：`Order`、`HttpClient`、`DbContext`——它们的相等性通常按业务键（如 `Id`）而不是全部字段，而且状态会变化。一个实用判据：如果两个实例所有字段相同你就认为它们"是同一个东西"，用 `record`。

**Q3：`sealed` 到底有什么好处？为什么微软的指南建议默认 `sealed`？**
A：三点。（1）**可推理**：没人能改变行为，你能放心地读代码。（2）**性能**：JIT 对 `sealed` 类型的虚调用可以去虚化甚至内联。（3）**演进自由**：不 `sealed` 就意味着所有 `virtual`/`protected` 成员都是公开契约，以后不能随便改。反过来，`sealed` 挡住了框架作者没想到的扩展场景——所以对**库的公共扩展点**要谨慎 `sealed`，对**应用内部类型**可以放心 `sealed`。

**Q4：`IDisposable` 的对象不 `Dispose`，GC 会帮我回收吗？**
A：会回收**内存**，但不会及时回收**非托管资源**。`FileStream` 不释放时，文件句柄会一直占着直到终结器运行（时机不确定，可能要等一次完整 GC），期间别的进程打不开这个文件。所以规则是：**实现了 `IDisposable` 的对象，创建者必须负责释放**——用 `using` 声明，或把所有权转移给一个明确的生命周期容器（如 DI 容器的 scoped 服务）。

---

## 相关笔记

- [[CSharp-01-环境与基础语法]]：类型系统、值/引用语义、装箱与类型转换
- [[CSharp-03-集合与LINQ]]：`Equals`/`GetHashCode` 在哈希容器中的实际作用，迭代器与泛型约束
- [[CSharp-04-委托事件与Lambda]]：把方法当参数传递，扩展方法与 LINQ 的基础
- [[CSharp-06-现代CSharp特性]]：模式匹配、可空引用类型、`Span<T>` 与源生成器
- [[Python-04-面向对象]]：与 Python 的类、继承、魔术方法做对比

## 参考来源

- [Properties](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties)
- [`required` modifier](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/required)
- [Access modifiers](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/access-modifiers)
- [Constructors](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/constructors)
- [Object and collection initializers](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/object-and-collection-initializers)
- [Static constructors](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/static-constructors)
- [Polymorphism](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/object-oriented/polymorphism)
- [Abstract and sealed classes and class members](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/abstract-and-sealed-classes-and-class-members)
- [Interfaces](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/interface)
- [`struct` type](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/struct)
- [Records](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/record)
- [Partial classes and methods](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/partial-classes-and-methods)
- [Extension methods](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/extension-methods)
- [Indexers](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/indexers/)
- [Operator overloading](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/operator-overloading)
- [Equality operators (design guidelines)](https://learn.microsoft.com/en-us/dotnet/standard/design-guidelines/equality-operators)
- [`Object.GetHashCode`](https://learn.microsoft.com/en-us/dotnet/api/system.object.gethashcode)
- [`IDisposable`](https://learn.microsoft.com/en-us/dotnet/api/system.idisposable)
- [Garbage collection fundamentals](https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/fundamentals)
- [Named and optional arguments](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments)
- 说明：C# 语言版本特性（如 `required`、静态抽象接口成员）随版本演进，以官方最新文档为准。
