Lesson 16: C# 12 — ref readonly 参数 + 内联数组 Inline Arrays

补全参数传递的语义三角 + 安全代码里的固定大小缓冲区

第一部分：ref readonly 参数

一、语义三角——ref / ref readonly / in 各管什么

在 C# 12 之前，引用传递只有两个选项：ref（可写引用）和 in（只读引用，可能复制）。中间缺了一格——"我需要原始内存位置，但不会修改它"。

二、in 不够用的场景

// 场景 1：需要内存地址的方法——in 不能保证
bool IsNull<T>(ref readonly T value) => Unsafe.IsNullRef(ref value);
// ↑ 如果 value 是 in，编译器可能复制到一个临时变量——IsNullRef 就判断错了

// 场景 2：更新旧 API——ref 改成 ref readonly 不是 Breaking Change
// 旧：void Process(ref LargeStruct data) { /* 只读 */ }
// 新：void Process(ref readonly LargeStruct data) { /* 只读 */ }
// 调用方已经写了 ref，行为不变——但现在编译器会阻止方法内意外修改

// 场景 3：in 能传字面量——但你不需要这个灵活性
M(in 42);  // ✅——但 42 被复制到临时变量，不是原始位置
M(ref readonly 42);  // ❌ 编译错误——字面量没有地址

深入：in 的"可能复制"——防御性拷贝详解 Defensive Copy

根本原因：可变 struct 的方法可能修改自身

C# 的 struct 是值类型，但其实例方法可以修改自身。编译器看到 in 参数时面临一个矛盾：

• in 承诺"方法不能改参数"
• 但你调用的 struct 方法可能会改——编译器无法静态分析所有方法体（它们可能在别的程序集里）

编译器的保守策略：先复制一份，在副本上操作。这就是防御性拷贝Defensive Copy。

什么操作会触发防御性拷贝？

代码演示：何时复制、何时不复制

struct Point { public int X, Y; public int Sum => X + Y; }  // 可变 struct

void Example(in Point p)
{
    var a = p.X;          // ❌ 不复制——直接字段访问，编译器确定安全
    var b = p.Sum;        // ⚡ 复制！Sum 是 getter（属性），编译器不信任
}

// ———————————————————
readonly struct ReadOnlyPoint { public int X { get; } public int Y { get; } }

void Example2(in ReadOnlyPoint p)
{
    var a = p.X;          // ❌ 不复制——readonly struct 不会变，编译器完全信任
}

// ———————————————————
struct Mixed  // 可变 struct，但个别成员标了 readonly
{
    public int X { get => field; set => field = value; }
    public readonly double Length => Math.Sqrt(X * X);  // 承诺不修改
}

void Example3(in Mixed m)
{
    var a = m.X;          // ⚡ 复制！getter 没标 readonly
    var b = m.Length;     // ❌ 不复制——Length 标了 readonly
}

IL 层面：防御性拷贝长什么样？

// C#: void Bad(in Point p) { Console.WriteLine(p.X); }   ← X 是属性 getter
// 生成的 IL：
//   ldarg.1          加载 in 参数的地址
//   ldobj Point      从地址复制整个 struct 到栈 ← 防御性拷贝
//   stloc.0          存入临时变量
//   ldloca.s 0       加载临时变量的地址
//   call get_X()     在临时变量上调用 getter

完整速查表见 in 防御性拷贝参考文档——含决策树、IL 对比、最佳实践。

三、调用方写 ref——不是 ref readonly

这是最反直觉的点：

void Print(ref readonly int x) => Console.WriteLine(x);

var v = 42;
Print(ref v);            // ✅ 调用方写 ref
Print(ref readonly v);    // ❌ 编译错误——调用方没有 ref readonly 语法
Print(v);               // ❌ 编译错误——必须写 ref
Print(ref 42);           // ⚠ 编译警告——字面量创建临时变量，ref 失去意义

第二部分：内联数组 Inline Arrays

四、问题——高性能缓冲区总要 unsafe

以前在 struct 里嵌入固定大小数组，只能用 unsafe fixed：

// ❌ 旧世界：unsafe 是硬门槛
unsafe struct Buffer
{
    public fixed int items[10];  // 只能在 unsafe 上下文中使用
}
// 使用也必须 unsafe
unsafe { var x = buffer.items[0]; }

五、C# 12 的答案——[InlineArray] 属性

一个属性 + 一个 struct + 一个字段 = 固定大小的安全数组：

// ✅ C# 12：纯 safe code
[System.Runtime.CompilerServices.InlineArray(10)]
public struct Buffer10
{
    private int _element0;  // "哨兵字段"——编译器据此推断元素类型和布局
}

// 使用：和普通数组完全一样
var buf = new Buffer10();
for (int i = 0; i < 10; i++) buf[i] = i;  // 索引器
foreach (var v in buf) Console.WriteLine(v);   // foreach

// 关键：零开销转 Span
Span<int> span = buf;  // 隐式转换——struct 直接在内存中就是 Span 指向的区域

六、编译器做了什么？

// 你写：
[InlineArray(3)]
public struct Triple { private int _e0; }

// 编译器生成：
// 1. struct Triple 的大小 = 3 × sizeof(int) = 12 字节
// 2. 索引器：public ref int this[int index] { get { ... } }
// 3. GetEnumerator() → 支持 foreach
// 4. 隐式转换 → Span<int> / ReadOnlySpan<int>
//
// 本质上 = 把 unsafe fixed size buffer 包装成安全特性

七、vs stackalloc——什么时候用哪个？

八、小测验

九、下一步

• 深入 in：查阅 in 防御性拷贝参考文档——含决策树、IL 对比、与 ref readonly 的详细对比。in 是 C# 7.2 特性（课前基线），本课新增的"深入：防御性拷贝详解"章节也覆盖了核心概念。
• 阅读：ref readonly 设计提案 · InlineArray 运行时源码
• 下一课：Lesson 17 — C# 12 小特性集（Lambda 默认参数、Alias Any Type、Experimental、Interceptors）。