Lesson 18: C# 13 — params 集合 + 新 Lock 对象

如果 Log 在热路径上被调用每秒数千次——这些数组分配会触发频繁 GC。.

1.2 解决方案：params 现在可以基于 Span

C# 13 的核心创新：params 参数可以是 ReadOnlySpan<T>——编译器在栈上构造 Span，零堆分配。

// 只能：params T[]
void Print(params int[] numbers) {
    foreach (var n in numbers)
        Console.Write(n + " ");
}

Print(1, 2, 3);
// IL: newarr    0x3
//     stloc.0  (T[])
// → 堆分配 int[3]

// 现在可以：params ReadOnlySpan<T>
void Print(params ReadOnlySpan<int> numbers) {
    foreach (var n in numbers)
        Console.Write(n + " ");
}

Print(1, 2, 3);
// IL: ldloca    _tmp (栈上 struct)
//     call  MemoryMarshal.CreateReadOnlySpan
// → 零堆分配

1.3 编译器到底生成了什么？How the Compiler Lowers This

这是用户最关心的部分——编译器做了三件事：

// 你写的代码：
Print(1, 2, 3);

// 编译器生成（概念等效）：
// ① 生成一个内联固定大小缓冲区 struct
ref struct __ValueArray3<int> {
    public int Item0, Item1, Item2;
}

// ② 在栈上分配该 struct，逐项赋值
var _tmp = new __ValueArray3<int>();
_tmp.Item0 = 1; _tmp.Item1 = 2; _tmp.Item2 = 3;

// ③ 用 MemoryMarshal 创建指向该缓冲区的 Span
var span = MemoryMarshal.CreateReadOnlySpan(
    ref _tmp.Item0, 3);
Print(span);

// 优化：同一方法内多次调用复用同一个缓冲区
// （取所有调用中参数数量最大的那一次作为缓冲区大小）

🔍 深入：编译器怎么知道"参数数量最大值"？

答案是编译时静态分析——编译器扫描调用方方法内所有的 Print(...) 调用点，逐个数字面量参数个数，取最大值。纯编译时行为，零运行时开销。

// 编译器看到 MyMethod 里有 3 个 Print 调用点：
void MyMethod()
{
    Print(1, 2, 3);          // ← 3 个参数
    Print(4, 5, 6, 7, 8);    // ← 5 个参数 → max = 5
    Print(9);                // ← 1 个参数
}
// 编译器：max = 5 → 在 MyMethod 栈帧上分配大小为 5 的缓冲区
// 三次调用复用同一块栈空间，不是每次调用都分配新的

1.4 支持的类型完整列表

1.5 实战场景一：零分配日志/格式化

// 你的日志包装器——热路径上每秒数千次调用
public static void Log(
    LogLevel level,
    [InterpolatedStringHandlerArgument("")] ref MyInterpolatedStringHandler msg)
{ ... }

public static void Log(
    LogLevel level,
    params ReadOnlySpan<object> args)  // ← 零分配！
{
    // 遍历 args 构建日志消息——不分配堆数组
    foreach (var arg in args)
        WriteArg(arg);
}

// 调用——和以前完全一样简洁
Log(LogLevel.Info, userId, operation, elapsed);
Log(LogLevel.Error, requestId, ex.Message);
Log(LogLevel.Debug);  // 空参也不分配

1.6 实战场景二：用 IEnumerable<T> 直接传 LINQ 结果

// 场景：要把 LINQ 筛选的结果传给 params 方法
void Display(params IEnumerable<string> items)
    => Console.WriteLine(string.Join(", ", items));

var users = GetUsers();

// C# 12：必须 .ToArray() — 多一次拷贝
// Display(users.Where(u => u.Active).Select(u => u.Name).ToArray());

// C# 13：直接传 LINQ 结果
Display(users.Where(u => u.Active).Select(u => u.Name));
// 省掉 .ToArray()——编译器帮你合成存储

1.7 ⚠️ 重大变更：重载决议优先 Span，表达式树可能报错

C# 13 的编译器优先绑定到 params ReadOnlySpan<T> 版本（而非旧的 params T[]）。这导致一个具体问题：

// .NET 8：绑定到 string.Join(string, params string[])
// .NET 9：绑定到 string.Join(string, params ReadOnlySpan<string>)

// 表达式树中 ref struct 非法 → 编译错误！
Expression<Func<string, string, string>> join =
    (x, y) => string.Join("", x, y);
// CS8640: 表达式树不能包含 ref struct

// 修复：显式传数组，强制绑定到旧版本
Expression<Func<string, string, string>> join =
    (x, y) => string.Join("", new[] { x, y });

1.8 限制速查

对于 async/迭代器场景，退回到 params T[] 或 params IEnumerable<T>——性能差异在 I/O 场景下可忽略。

二、新 Lock 对象 System.Threading.Lock 每日用

2.1 痛点：lock(object) 的六宗罪

从 C# 1.0 起，lock 语句编译为 Monitor.Enter / Monitor.Exit。这个 20 年前的 API 有固有的设计缺陷：

// .NET 8 及以前——看起来正常：
private readonly object _sync = new();
lock (_sync) { /* 关键区 */ }

// 编译器生成（简化）：
bool lockTaken = false;
try {
    Monitor.Enter(_sync, ref lockTaken);
    /* 关键区 */
} finally {
    if (lockTaken) Monitor.Exit(_sync);
}

2.2 解决方案：System.Threading.Lock

private readonly object _sync = new();

lock (_sync)
{
    // 关键区
    _counter++;
}

// IL 生成 Monitor.Enter/Exit
// 每次 Enter ~20ns

private readonly Lock _sync = new();

lock (_sync)
{
    // 关键区——语法完全相同
    _counter++;
}

// IL 生成 using (EnterScope())
// 每次 Enter ~15ns（≈25% 更快）

2.3 编译器生成对比——这是精华

// ==================== lock (object) ====================
// 编译器生成：
object _sync = ...;
bool lockTaken = false;
try
{
    Monitor.Enter(_sync, ref lockTaken);
    /* 你的代码 */
}
finally
{
    if (lockTaken) Monitor.Exit(_sync);
}

// ==================== lock (Lock) ====================
// 编译器生成：
Lock _sync = ...;
using (Lock.Scope __scope = _sync.EnterScope())
{
    /* 你的代码 */
}
// Dispose() 自动释放锁——没有 try/finally 样板
// Lock.Scope 是 ref struct——零堆分配

2.4 迁移：一行改动

// Step 1：改字段类型
// Before:  private readonly object _sync = new();
private readonly Lock _sync = new();

// Step 2：lock 语句完全不变
lock (_sync) { /* 不变 */ }

// 就这么简单。IDE0330 代码风格规则会自动提示你改。

2.5 ⚠️ 三个陷阱

🔍 补充：SemaphoreSlim 是什么？

SemaphoreSlim 是 .NET 中的轻量级异步信号量——一个计数器，允许多个线程/任务同时进入关键区。和 Lock 的关键区别：支持 await。

private readonly Lock _sync = new();

// ❌ 不能 await——编译错误
lock (_sync) {
    await db.SaveAsync(); // 不允许
}

private readonly SemaphoreSlim _sem = new(1, 1); // 初始1, 最大1 = 互斥

// ✅ 可以 await
await _sem.WaitAsync();
try {
    await db.SaveAsync();
} finally {
    _sem.Release();  // ⚠️ 必须手动释放！
}

三、小测验

四、C# 13 本课小结

五、下一步

• Lesson 19：C# 13 剩余特性——ref struct 实现接口、\e 转义、方法组自然类型改进、partial 属性、OverloadResolutionPriority。
• 实践建议：打开现有项目，搜索 params T[] 和 object _sync——评估哪些可以升级到 C# 13 写法。