Lesson 26: C# 15 — Closed Hierarchies Closed Class Hierarchies

2.2 加新子类 → 全面亮警告

// 六个月后，有人加了第四种状态：
public record class Maintenance(string Worker) : GateState;

// 💡 编译器立即在所有 switch 上亮警告：
// "The switch expression does not handle 'Maintenance'"
// 同一个程序集内的所有 switch 全部收到——无一遗漏

三、Union vs Closed Hierarchy——选型决策 Choosing Between Them

3.1 看两组代码——一眼看出区别

同样的"三种消息类型"，Union 和 Closed Hierarchy 写出来完全不同：

// ═══ 方案 A: Union——类型形状各异，毫无共同之处 ═══
public record class TextMessage(string Body, DateTime SentAt);
public record class ImageMessage(byte[] Data, string MimeType);
public record class Reaction(string Emoji, int TargetMsgId);
public union ChatEvent(TextMessage, ImageMessage, Reaction);
// ↑ 注意三个类型的字段完全不同：
//   TextMessage  → Body(string) + SentAt(DateTime)
//   ImageMessage → Data(byte[]) + MimeType(string)
//   Reaction     → Emoji(string) + TargetMsgId(int)
// 没有任何共同字段——强行抽基类只会得到一个空壳

// ═══ 方案 B: Closed Hierarchy——各有各的数据，共享基类行为 ═══
public closed record class Notification
{
    public required DateTime CreatedAt { get; init; }   // ← 所有通知都有的时间戳
    public abstract Task<bool> Send();                      // ← 所有通知都能发送
}
public record class Email(string To, string Subject, string Body) : Notification
{ public override Task<bool> Send() => /* SMTP */; }
public record class Sms(string PhoneNumber, string Text) : Notification
{ public override Task<bool> Send() => /* 短信网关 */; }
public record class Push(string DeviceToken, string Title, string Body) : Notification
{ public override Task<bool> Send() => /* FCM/APNs */; }
// ↑ 三个子类的字段也完全不同：
//   Email → To + Subject + Body（邮件地址）
//   Sms   → PhoneNumber + Text（手机号）
//   Push  → DeviceToken + Title + Body（设备令牌）
// 但它们都继承了 CreatedAt（时间戳）和 Send()（发送行为）

两者都能穷举检查。区别在于其他维度：

3.2 一句话决策

3.3 边界案例——当两种都能用时

有时同一个领域模型两种都能表达，选哪个取决于你预期未来会不会长出共享行为。比如一个简单的Pet：

// 场景：三种宠物目前只有名字不同——Union 更直接
public record class Cat(string Name);
public record class Dog(string Name);
public record class Bird(string Name);
public union Pet(Cat, Dog, Bird);
// ✅ 三个类型字段一样（都只有 Name）——但这是特例，现实中少见

// 但如果未来要加 FeedingSchedule、VetRecord、Adopt()……
// 共享行为开始累积 → 迁移到 Closed Hierarchy：
public closed record class Pet
{
    public required string Name { get; init; }
    public abstract FeedingSchedule DailyFeeding();  // 每种宠物喂食不同
    public virtual VetRecord? LastCheckup { get; set; }  // 所有宠物共享的结构
}
public record class Cat(string Name) : Pet { public override FeedingSchedule DailyFeeding() => /* 猫粮 2 次/天 */; }
public record class Dog(string Name) : Pet { public override FeedingSchedule DailyFeeding() => /* 狗粮 2 次/天 + 遛 */; }
public record class Bird(string Name) : Pet { public override FeedingSchedule DailyFeeding() => /* 鸟食 1 次/天 */; }
// ✅ 继承层次开始体现价值——FeedingSchedule 和 VetRecord 只需在基类定义一次

两者都正确——选让你现在的代码更清晰的那个。如果今天不确定，从 Union 开始。当共享行为开始涌现（基类不再空洞），迁移到 Closed Hierarchy 的成本很低：case 类型加上 : BaseType，union 声明改为 closed class。

四、非传递性——封闭只到直接子类 Non-Transitive Closure

4.1 封闭不向下传递

一个常见的误解：以为 closed 会沿着继承链向下传递。实际上不会——封闭性只约束直接派生：

// ──── Assembly A ────
public closed record class Animal;              // closed: 直接子类必须在本程序集
public record class Mammal : Animal;             // 本程序集内派生 → ✅
public record class Bird : Animal;               // 本程序集内派生 → ✅

// ──── Assembly B: 引用方 ────
public record class Dog : Mammal;  // ✅ 合法！Mammal 不是 closed——可以从外部派生
public record class Cat : Mammal;  // ✅ 同样合法

这意味着 Animal 的 switch 穷举只需要覆盖 Mammal 和 Bird——不需要知道 Dog 和 Cat 的存在。穷举检查的粒度是直接派生类。

4.2 如果你想让子类也封闭

给 Mammal 也加 closed：

public closed record class Mammal : Animal;     // closed: Mammal 的直接子类也必须在本程序集
public record class Dog : Mammal;
public record class Cat : Mammal;
public record class Human : Mammal;

// 现在 Mammal 的 switch 也需要穷举 Dog、Cat、Human

五、编译器生成了什么？ Compiler Lowering

5.1 一个 attribute 搞定

和 Union 类似，closed 由编译器通过一个 attribute 实现。你写：

public closed record class GateState;

编译器生成：

[System.Runtime.CompilerServices.Closed]    // ← 就是这个 attribute
public abstract record class GateState;   // closed → abstract

编译时，编译器看到 [Closed] attribute → 枚举当前程序集中所有直接派生类 → 用这个列表验证 switch 穷举。运行时没有额外开销——attribute 只是元数据标记，不影响 JIT 生成的代码。

5.2 Preview 5 的临时负担

.NET 11 Preview 5 的 BCL 还没内置 ClosedAttribute。使用 closed 的项目需要自己声明：

namespace System.Runtime.CompilerServices;

[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
public sealed class ClosedAttribute : Attribute { }

5.3 编译期行为 vs 运行时行为

六、三个实战场景 Real-World Examples

6.1 HTTP 响应建模——共享 StatusCode 和 Headers

public closed record class HttpResponse
{
    public required int StatusCode { get; init; }
    public required Dictionary<string, string> Headers { get; init; }

    public abstract string Summarize();
}

public record class Success<T>(T Body) : HttpResponse
{
    public override string Summarize() => $"200 OK: {Body}";
}
public record class Redirect(string Location) : HttpResponse
{
    public override string Summarize() => $"302 → {Location}";
}
public record class ClientError(string Message) : HttpResponse
{
    public override string Summarize() => $"4xx: {Message}";
}
public record class ServerError(Exception Error) : HttpResponse
{
    public override string Summarize() => $"5xx: {Error.Message}";
}

// 使用——StatusCode 在基类定义一次，所有子类自动拥有
var response = new Success<string>("ok") { StatusCode = 200, Headers = [] };
Console.WriteLine(response.StatusCode);  // 200——基类属性，不是 Success 独有

这个场景如果用 Union，每种响应都要重复声明 StatusCode 和 Headers——样板地狱。Closed Hierarchy 让你在基类定义一次，所有派生类自动继承。

6.2 状态机——门禁系统

public closed record class GateState
{
    public abstract bool CanPass();
    public abstract GateState Next();
}

public record class Closed : GateState
{
    public override bool CanPass() => false;
    public override GateState Next() => new Open(100);
}
public record class Open(float Percent) : GateState
{
    public override bool CanPass() => Percent > 0;
    public override GateState Next() => new Closed();
}
public record class Locked(string Reason) : GateState
{
    public override bool CanPass() => false;
    public override GateState Next() => new Closed();
}

// 处理——用 switch 穷举所有状态，也可以用虚方法多态
string Describe(GateState state) => state switch
{
    Closed => "关",
    Open(var p) => $"开 {p}%",
    Locked(var r) => $"锁: {r}",
};

// 或者直接用虚方法——两种方式都能获得编译期穷举检查
if (!state.CanPass()) Console.WriteLine("禁止通行");

6.3 支付方式——策略模式 + 穷举检查

public closed record class PaymentMethod
{
    public abstract Task<bool> Process(decimal amount);
    public abstract string DisplayName { get; }
}

public record class CreditCard(string Number, string Cvv) : PaymentMethod
{
    public override string DisplayName => $"信用卡 ****{Number[^4..]}";
    public override Task<bool> Process(decimal amount) => /* 调用银行网关 */;
}
public record class WeChatPay(string OpenId) : PaymentMethod
{
    public override string DisplayName => "微信支付";
    public override Task<bool> Process(decimal amount) => /* 调用微信 API */;
}
public record class Alipay(string UserId) : PaymentMethod
{
    public override string DisplayName => "支付宝";
    public override Task<bool> Process(decimal amount) => /* 调用支付宝 API */;
}

// ──── 使用端 ────
async Task Pay(PaymentMethod method, decimal amount)
{
    var typeLabel = method switch     // 穷举检查——所有支付方式被覆盖
    {
        CreditCard => "信用卡",
        WeChatPay => "微信",
        Alipay => "支付宝",
    };
    Console.WriteLine($"使用 {typeLabel} 支付 {amount} 元");
    await method.Process(amount);       // 多态——每种支付方式有不同的处理逻辑
}

// 新加支付方式——改两处：加子类 + 更新 switch（编译器帮你找到所有 switch）
// public record class UnionPay(string BankCode) : PaymentMethod { ... }
// → 所有 PaymentMethod 的 switch 自动亮警告

七、一张大表——四种"封闭"方式的最终对比 The Complete Picture

八、当前限制与未来 Current Limitations & Roadmap

九、测验 Quiz

十、总结 Summary

十一、下一步 Next: Collection Expression Arguments

Closed Hierarchies 和 Union 构成了 C# 15 穷举检查的双支柱——一个管有继承的类型族，一个管无关联的 case 集合。下节课转向集合表达式的实用增强：

← L25: Union 类型 · L27: Collection Expression Arguments → · 🎯 回顾 Mission