Lesson 24: C# 14 — 小特性合集 Small Features

Span 隐式转换 · 自定义复合赋值 · partial 构造/事件 · 单文件应用 · C# 14 收官

〇、四个场景 Four Specialized Tools

这四个特性不是 field 关键字那种"人人每天用"，也不是扩展成员那种"改变语言叙事"。它们是专用工具——特定场景下的生产力飞跃：

一、Span 隐式转换 First-Class Span Support

1.1 问题：Span 好用，但创建它很啰嗦

Span 自 C# 7.2 引入以来一直是高性能代码的基石。但把普通类型变成 Span 需要显式转换——每次用一个 API 都要先调用 .AsSpan() 或强制转换：

// C# 7.2~13：常见场景——每一次都多写一行
ReadOnlySpan<char> name = "Christopher".AsSpan();  // 字符串 → Span
Span<int> numbers = stackalloc[] { 1, 2, 3 };     // stackalloc 可以，但…

int[] data = { 1, 2, 3, 4, 5 };
ProcessData(data.AsSpan());                       // 数组 → Span——每次都要 .AsSpan()
ProcessData((Span<int>)data);                    // 或者显式转换

void ProcessData(Span<int> span) { ... }

问题不在于 Span 的 API 设计——问题在于 C# 语言没把 Span 当成一等公民。数组可以隐式转为 IEnumerable<T>，为什么不能隐式转为 Span<T>？

1.2 C# 14：五条隐式转换

// C# 14——这些都隐式转换，不需要 .AsSpan()
ReadOnlySpan<char> name = "Christopher";             // ① string → ROSpan<char>
Span<int> numbers = stackalloc[] { 1, 2, 3 }; // ② stackalloc → Span<T>

int[] data = { 1, 2, 3 };
Span<int> s = data;                           // ③ T[] → Span<T>
ReadOnlySpan<int> rs = data;                    // ④ T[] → ReadOnlySpan<T>
ReadOnlySpan<int> rs2 = s;                      // ⑤ Span<T> → ReadOnlySpan<T>

ProcessData(data);                              // 直接传数组——不需要 .AsSpan()！

1.3 扩展方法接收者——历史性突破

在 C# 13 中，数组不能调用 Span 的扩展方法——这是最别扭的限制之一：

// C# 13：数组不能调 Span 扩展方法 ❌
int[] arr = [1, 2, 3];
Console.WriteLine(arr.StartsWith(1));  // CS8773: 数组不能成为 Span 扩展方法的接收者

// C# 14：隐式转换让数组也能调 ✅
int[] arr = [1, 2, 3];
Console.WriteLine(arr.StartsWith(1));  // True——arr 隐式转为 ReadOnlySpan<int>

1.4 重载决议细节

int[] data = [1, 2, 3];

void Process(ReadOnlySpan<int> items) => Console.WriteLine("快路径");
void Process(IEnumerable<int> items) => Console.WriteLine("慢路径");

Process(data);  // C# 13: 走 IEnumerable 重载
                // C# 14: 走 Span 重载 ← 重载决议往高性能方向倾斜

这在 99% 的场景中正是你想要的——零分配、更快。你不需要改调用代码，升级编译器就行。这也是 C# 14 把 Span 提升为"一等公民"的真正力量：整个生态的重载决议都往高性能方向倾斜。

1.5 转换一览

二、自定义复合赋值运算符 User-Defined Compound Assignment

2.1 问题：+= 永远创建新对象

过去定义 operator + 时，编译器自动把 a += b 展开为 a = a + b——每次都创建新实例。对于大类型（矩阵、向量、BigInteger），这产生大量垃圾：

// C# 13：只能定义 operator +
public struct Vector3
{
    public decimal X, Y, Z;

    public static Vector3 operator +(Vector3 left, Vector3 right)
        => new(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
}

var v = new Vector3 { X = 1, Y = 2, Z = 3 };
v += new Vector3 { X = 4, Y = 5, Z = 6 };
// 编译器生成：v = v + other   ← v + other 创建了新 Vector3，然后赋值回 v
// 循环中反复 += → 大量临时对象 → GC 压力

2.2 C# 14：实例方法形式的复合赋值——原地修改

// C# 14：定义 void operator += —— 原地修改，零分配
public struct Vector3
{
    public decimal X, Y, Z;

    // 传统 operator +（独立的 a + b 表达式仍然可用）
    public static Vector3 operator +(Vector3 left, Vector3 right)
        => new(left.X + right.X, left.Y + right.Y, left.Z + right.Z);

    // 🆕 复合赋值——实例方法，void 返回，直接改 this
    public void operator +=(Vector3 right)
    {
        X += right.X;
        Y += right.Y;
        Z += right.Z;
    }
}

var v = new Vector3 { X = 1, Y = 2, Z = 3 };
v += new Vector3 { X = 4, Y = 5, Z = 6 };
// 编译器直接用 void operator += —— 不创建新对象

// operator + 仍然独立存在：
var v3 = v1 + v2;   // 用传统 operator + —— 创建新对象（合理——你需要新值）

2.3 编译器抉择顺序

遇到 a += b 时编译器的查找优先级：

2.4 支持的运算符一览

2.5 checked 上下文——控制溢出行为

C# 中整数运算溢出有两种处理模式：

int max = int.MaxValue;   // 2147483647
int bad = max + 1;         // -2147483648 —— unchecked 是默认，静默溢出

checked
{
    int crash = max + 1;  // 💥 OverflowException！
}

unchecked 是默认（性能优先），checked 需显式开启——用 checked 块或 /checked+ 编译选项。

复合赋值支持两种版本：

public struct IntVector
{
    public int X, Y;

    // 无标记版本——跟随调用方的 checked/unchecked 上下文
    public void operator +=(IntVector r) { X += r.X; Y += r.Y; }

    // 🆕 checked 版本——不管调用方什么上下文，溢出必须抛异常
    public void operator checked +=(IntVector r)
    {
        X = checked(X + r.X);
        Y = checked(Y + r.Y);
    }
}

编译器在 checked 上下文中优先选 checked 版本，否则选无标记版本。这和 C# 11 引入的 operator checked + 是同一套机制。（注意课里的 Vector3 用 decimal——decimal 始终是 checked 的，不需要显式声明。）

三、partial 构造和事件 Partial Constructors & Events

3.1 问题：源生成器只能生成方法，不能生成构造

C# 2 引入 partial class，C# 3 引入 partial method，C# 9 引入 partial property。但构造和事件——两种最常见的代码生成目标——一直不能 partial。

这对源生成器（Source Generator）是一个真实限制。比如你写了一个 [WeakEvent] 特性，希望源生成器自动生成事件的基础设施代码——做不到，因为事件不能 partial。你只能用手写方式绕路。

3.2 C# 14：partial 构造

// ──── 你写的代码（定义声明） ────
public partial class User
{
    public partial User(string name);           // ← 声明——只有签名，没有体
}

// ──── 源生成器产生的代码（实现声明） ────
public partial class User
{
    public partial User(string name)             // ← 实现——实际体
    {
        Name = name ?? throw new ArgumentNullException(nameof(name));
    }

    public string Name { get; }
}

关键规则：

• 仅实现声明可以有 : base(...) 或 : this(...) 初始化器
• 仅一个 partial 声明可以有主构造函数语法
• 参数签名必须完全一致
• 不支持 static 构造和终结器

3.3 partial 事件

// ──── 你写的代码（定义声明） ────
public partial class Service
{
    [WeakEvent]
    public partial event EventHandler? OnChange;  // ← 字段式声明
}

// ──── 源生成器产生的代码（实现声明） ────
public partial class Service
{
    private readonly WeakEvent _onChange = new();

    public partial event EventHandler? OnChange
    {
        add    => _onChange.Add(value);            // 必须同时写 add 和 remove
        remove => _onChange.Remove(value);
    }
}

四、单文件应用 File-Based Apps

4.1 问题：一个 .cs 文件也需要 .csproj

想写一个快速脚本——读取文件、发个 HTTP 请求、格式化输出——需要先 dotnet new console，改 .csproj 加 NuGet 包，然后才能写代码。相比之下 Python 的 python script.py 零体力。

4.2 C# 14：直接 dotnet run 一个 .cs 文件

// ──── script.cs —— 一个文件，零项目文件 ────
#!/usr/bin/env dotnet
#:package Spectre.Console@*

using Spectre.Console;

AnsiConsole.MarkupLine("[bold green]Hello from a single file![/]");

var files = Directory.GetFiles(".", "*.cs");
AnsiConsole.Write(new BarChart()
    .AddItem("C# Files", files.Length, Color.Green));

# 运行——不需要 .csproj，不需要 sln
dotnet run script.cs

# Unix/Mac——加执行权限后直接运行
chmod +x script.cs
./script.cs

4.3 四个 #: 指令

4.4 dotnet run vs dotnet publish——产出完全不同

这是最容易误解的地方——两者的编译目标不是一回事：

dotnet run app.cs

走常规 JIT 构建→运行，不开启 Native AOT（否则改一行等几十秒）。SDK 在内存中生成虚拟 .csproj，恢复 NuGet 包，Roslyn 编译为 IL 程序集，输出到系统临时目录：

# 构建输出位置（几乎不会手动去看）
<temp>/dotnet/runfile/app-<hash>/bin/Debug/net10.0/
├── app.dll                  ← IL 程序集
├── app.runtimeconfig.json
├── app.deps.json            ← 依赖图
├── Spectre.Console.dll      ← NuGet 包（如有）
└── ...

dotnet publish app.cs

默认开启 Native AOT——产出单个自包含原生二进制，无需 .NET 运行时：

# 发布输出——源码旁边的 artifacts/ 目录
artifacts/publish/app/
└── app.exe    ← 单文件原生二进制（Windows）
                   ≈8–15 MB，含你的代码 + NuGet 包 + 运行时子集
                   扔到任何一台没装 .NET 的机器上直接跑

4.5 定位——不是替代项目，是替代脚本

单文件应用不是让你把整个生产项目塞进一个文件。它的定位是：

这不意味着 C# 成了脚本语言——它仍然是编译型、强类型的。只是绕过了项目文件的仪式，让 C# 在"临时写个东西"的赛道上可以一用。

五、测验 Quiz

struct V { public void operator +=(V r) => X += r.X; }

六、C# 14 全回顾 C# 14 Retrospective

C# 14 是 .NET 10 LTS 的语言——10 个新特性，从"改变叙事"到"消除纸割伤"：

七、C# 8~14 全部学完。下一步？What's Next After C# 14?

25 节课，7 个 C# 版本（8→14），覆盖了从 .NET Framework 4.8 到 .NET 10 LTS 的完整语言演进。你已具备在现代 .NET 项目中自信编码的能力。

接下来的学习路径取决于你的兴趣方向：

📖 NRT 速查 · ← L23: 中等特性合集 · 🎯 回顾 Mission