Lesson 19: C# 13 — ref struct 三部曲

.NET 9（2024.11）· 实现接口 · allows ref struct · 进入 async 方法

背景：ref struct 的三个历史限制

C# 7.2 引入 ref struct 以来（回顾 L16），三个困扰开发者的问题始终存在：

1. 不能实现接口——Span<T> 无法参与 IEnumerable<T>、IDisposable 等泛型抽象
2. 不能作为泛型参数——泛型天然拒绝 ref struct
3. 不能出现在 async / 迭代器方法中——哪怕不跨越 await/yield 边界也不行

C# 13 一次性解决了这三个问题。三个特性共享同一个设计动机：让 ref struct 不再是一等公民之外的二等类型。

一、ref struct 实现接口 ref struct Interfaces 核心

1.1 痛点：Span<T> 进不了泛型方法

// C# 12：同样的逻辑要写三份重载——只因为 Span 不实现接口
void Process(int[] data)      => ProcessCore(data);
void Process(List<int> data)  => ProcessCore(data);
void Process(Span<int> data)  => ProcessCore(data);  // 重载 × 3

// 理想：对实现了 IEnumerable<int> 的类型只写一份
// 现实：Span<int> 不实现任何接口 → 做不到

1.2 C# 13：ref struct 可以声明接口继承

// 自定义 ref struct 实现 IDisposable
ref struct Buffer : IDisposable {
    public Span<byte> Data;
    public void Dispose() => Data.Clear();
}

// 可以用 using 语句了！
using (var buf = new Buffer { Data = stackalloc byte[32] }) {
    // ... 使用 buf ...  
}  // 自动调用 Dispose()——零分配

// .NET 9 BCL：Span<T> / ReadOnlySpan<T> 已实现 IEnumerable<T> 等接口

1.3 真正用法：配合泛型约束

// 泛型方法——通过约束来消费接口
void UseBuffer<T>(T buffer) where T : IDisposable {
    using (buffer) { /* ... */ }
}

Buffer buf = new();   // ref struct
UseBuffer(buf);        // ✅ C# 13——泛型在调用点被特化，不装箱

你很少需要自己写 ref struct 实现接口。但整个 BCL 已经为 Span 做了这件事——你直接受益。

二、allows ref struct 反约束 Generic Anti-Constraint 核心

2.1 问题：泛型默认拒绝 ref struct

即使 ref struct 实现了接口，泛型参数仍然不接受它——因为编译器要确保 T 可以装箱/堆分配：

// C# 12：即使 Span 实现了 IEnumerable<int>，这里还是传不进去
void ForEach<T>(T collection) where T : IEnumerable<int> { ... }

ForEach(new[] { 1, 2, 3 });    // ✅ int[]
ForEach(new List<int> { 1, 2 }); // ✅ List<int>
// ForEach((ReadOnlySpan<int>)(...)); // ❌ Span 不能作为 T

2.2 C# 首个"反约束"

allows ref struct 不是限制 T 必须是什么，而是额外允许 T 是 ref struct——这是 C# 历史上第一个"反约束"：

// 加一行 allows ref struct
void ForEach<T>(T collection)
    where T : IEnumerable<int>
    where T : allows ref struct      // ← 反约束：扩张——放行 ref struct
{
    foreach (var item in collection)
        Console.WriteLine(item);
}

// 全都可以传！
ForEach(new[] { 1, 2, 3 });
ForEach(new List<int> { 1, 2 });
ForEach((ReadOnlySpan<int>)stackalloc int[] { 1, 2 });  // ✅ C# 13

2.3 编译器行为

标记了 allows ref struct 的泛型方法，编译器在调用点对 ref struct 做特化（specialization）——不装箱、不逃逸。和其他类型走同一套泛型代码路径，但 IL 层面有专门处理。

// 反约束与普通约束可以组合
void Work<T>(T item)
    where T : struct               // 必须是值类型
    where T : allows ref struct      // 额外放行 ref struct
{ }

// 常见组合：
// where T : IDisposable, allows ref struct
// where T : IEnumerable<TElement>, allows ref struct

三、ref / unsafe 进 async 和迭代器 ref in async & iterators 性能

3.1 过去的限制：全有或全无

C# 12：async 方法和迭代器（yield return）中完全禁止使用 ref 局部变量和 unsafe 块。哪怕你在 await 之前用完就扔了也不行。

// C# 12：编译错误 CS8344
async Task<int> ReadHeaderAsync(Stream stream) {
    Span<byte> buffer = stackalloc byte[16];  // ❌ async 方法不能有 ref struct
    await stream.ReadAsync(buffer);
    return BitConverter.ToInt32(buffer);
}

这是最令人沮丧的限制之一：你知道 buffer 不跨越 await——你只是想在读 I/O 之前临时用一下栈上的 buffer——但编译器不让你这么做。

3.2 C# 13：有条件放行

规则很简单——ref 变量不能跨越 await / yield 边界。必须在 await 之前"死亡"（最后一次引用之后），await 之后不能再访问：

async Task<int> ReadAsync(Stream s) {
    Span<byte> buf = stackalloc byte[16];
    // ❌ CS8344
}

async Task<int> ReadAsync(Stream s) {
    Span<byte> buf = stackalloc byte[16];
    s.Read(buf);                         // 同步读取——没有 await
    var r = BitConverter.ToInt32(buf);    // buf 在这里"死亡"
    // 之后不再引用 buf——安全
    await s.FlushAsync();                 // ✅ await 在 buf 死亡之后
    return r;
}

// ❌ 但仍然不能跨越 await——编译器会在 await 后将 ref 变量标记为"未赋值"
async Task Bad(Stream s) {
    Span<byte> buf = stackalloc byte[16];
    await Task.Delay(1);
    Console.WriteLine(buf[0]);  // ❌ CS4015: ref local 在 await 后已失效
}

3.3 规则速查

四、日常开发中你会用到几个？

三个特性对普通开发者的影响程度不同：

真正每天受益的是第三个。比如之前你要在 async 方法里读 header：

async Task<int> ReadHeaderAsync(Stream s) {
    byte[] buf = new byte[16];   // 堆分配——只为了 16 字节
    await s.ReadAsync(buf, 0, 16);
    return BitConverter.ToInt32(buf, 0);
}

async Task<int> ReadHeaderAsync(Stream s) {
    Span<byte> buf = stackalloc byte[16];  // 零分配
    s.Read(buf);                            // 同步读完
    var result = BitConverter.ToInt32(buf); // buf 死亡
    await s.FlushAsync();                   // 可以 await
    return result;
}

五、小测验

六、小结

七、下一步

• Lesson 20：C# 13 小特性合集——\e 转义、方法组自然类型改进、partial 属性、OverloadResolutionPriority 等。
• 实践建议：搜索项目中接受 IEnumerable<T> 的泛型方法——给它们加上 allows ref struct，然后试试传 Span。