---
title: CSharp-01-环境与基础语法
aliases:
  - C# 入门
  - CSharp 基础语法
  - .NET SDK 入门
tags:
  - 编程语言/CSharp
  - 类型/教程
created: 2026-10-11
updated: 2026-10-11
level: 入门
prerequisites:
  - "[[00-索引]]"
  - "[[计算机组成原理]]"
sources:
  - https://learn.microsoft.com/en-us/dotnet/standard/clr
  - https://learn.microsoft.com/en-us/dotnet/standard/components
  - https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet
  - https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/built-in-types
  - https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/program-structure/top-level-statements
  - https://dotnet.microsoft.com/en-us/download
---

# CSharp-01-环境与基础语法

> [!abstract] 这篇讲什么
> C# 不是一个"单独的语言"，它长在 **.NET 平台**上：语言负责语法，运行时负责执行，基础类库（Base Class Library, BCL）负责提供现成的类型。本篇先讲清这三者的边界与协作方式（为什么理解它会让你少踩一半的坑），再逐条过一遍基础语法：变量与 `var`、内置类型与取值范围、值类型与引用类型、装箱、可空值类型、类型转换的安全写法、字符串与 `StringBuilder`、运算符与控制流、数组与 `foreach` 的实现原理。
> 阅读前提：机器上已安装 .NET SDK（本笔记以 **.NET SDK 10.0.401**、C# 13 语法为基准；语言与框架版本更新较快，细节以官方最新文档为准）。

---

## 一、是什么：.NET 平台的组成

初学者最容易被几个词绕晕：`.NET`、`.NET Framework`、`.NET Core`、`CLR`、`SDK`、`BCL`、`C# 语言规范`。它们不是同义词，而是**不同层次的组件**。

| 名称 | 层次 | 职责 | 类比 |
|---|---|---|---|
| C# 语言规范（C# Language Specification） | 语言 | 定义语法与语义：什么写得出来、写出来是什么意思 | 交通法规 |
| 编译器（Roslyn / `csc`） | 工具 | 把 C# 源码翻译成中间语言（Intermediate Language, IL） | 翻译官 |
| CLR（Common Language Runtime） | 运行时 | 加载 IL、JIT 编译成本机码、管理内存与异常、GC | 发动机 |
| BCL / 运行时库 | 库 | `System.*` 命名空间下的现成类型：`List<T>`、`string`、`File` | 标准零件库 |
| SDK | 工具集 | 编译器 + 运行时 + 模板 + `dotnet` CLI + MSBuild | 整车工具套装 |
| 运行时（Runtime） | 安装包 | 只包含执行程序所需的东西，不含编译器 | 只有发动机 |

> [!important] 一句话抓住边界
> **语言 ≠ 运行时 ≠ 库**。`C# 13` 是新语法，`.NET 10` 是运行时与库的版本，两者独立演进：同一份 C# 代码可以编译到不同的目标框架（Target Framework），同一个运行时也能跑用不同 C# 版本写的程序。
> 这就是为什么你能在 `.NET 10` 上把 `LangVersion` 设为 `12`，用的却是 `.NET 10` 的 BCL。

### 1.1 编译执行流程：C# → IL → 本机码

```
 源码 A.cs
    │  csc / Roslyn 编译
    ▼
 IL + 元数据（metadata）  ← 存在 .dll / .exe 里，与平台无关
    │  运行时加载（dotnet run / dotnet MyApp.dll）
    ▼
 ┌──────────────┬─────────────────────────────┐
 │ JIT 即时编译  │ AOT 提前编译                 │
 │ 方法首次调用时 │ 发布时整体编译成机器码        │
 │ 编译成机器码   │（NativeAOT，启动快、体积小）  │
 └──────────────┴─────────────────────────────┘
    ▼
 本机码在 CPU 上执行
```

**为什么要有 IL 这一层？** 直接编译成机器码（像 C 那样）不是更简单吗？IL 的存在换来四件事：

1. **跨平台**：IL 与 CPU 无关，同一份程序集在 x64、Arm64、Linux、Windows 上都能跑，JIT 在目标机器上生成对应机器码。
2. **跨语言**：C#、F#、VB.NET 都编译成 IL，可以互相引用——`F#` 写的库能被 C# 直接 `using`。
3. **运行时优化**：JIT 知道真实 CPU 特性（AVX2、AVX-512）和真实调用热点，可以做"运行时特化"，这在编译期是拿不到的信息。
4. **安全与自描述**：IL 带完整元数据（类型、成员、签名），运行时能在加载时做类型安全检查、反射、GC 精确标记对象引用。

> [!note] 代价是什么
> IL + JIT 换来灵活性，代价是**启动时的编译开销**和**首次调用的延迟**。对启动时间敏感的场景（CLI 工具、Serverless）用 **NativeAOT** 把 IL 提前编译成机器码；对启动延迟敏感但不想放弃动态特性时，可以用 **ReadyToRun（R2R）** 预编译。三种模式的取舍见 [[CSharp-07-dotnet项目与工具链]]。

### 1.2 .NET Framework / .NET Core / .NET 5+ 的历史关系

这段历史必须搞清，否则你会看不懂一堆过时教程里的 `System.Web`、`packages.config`、`web.config`。

| 对比项 | .NET Framework | .NET Core 1.x–3.1 | .NET 5 及以后（含 .NET 8/9/10） |
|---|---|---|---|
| 首发年份 | 2002 | 2016 | 2020 起，每年 11 月一个大版本 |
| 平台支持 | 仅 Windows | Windows / Linux / macOS | 同上，另含容器、WASM、移动端（经 .NET MAUI） |
| 交付方式 | 随 Windows 系统组件 | 独立安装、可并排 | 独立安装、可并排，支持自包含发布 |
| 开源 | 部分 | 完全开源（MIT） | 完全开源 |
| 项目文件 | 复杂 MSBuild，需逐文件列出 | SDK 风格，隐式包含源文件 | SDK 风格（延续至今） |
| 包管理 | `packages.config` / NuGet | NuGet（`PackageReference`） | NuGet（`PackageReference`） |
| 状态（2026） | 仅 4.8.x 维护，不再加新功能 | 已全部停止支持 | **主线，持续演进** |

历史脉络一句话：**.NET Framework → .NET Core（重写、跨平台）→ .NET 5+（去掉 "Core" 字样，成为唯一主线）**。`.NET Core 4.x` 这个版本号被跳过，就是为了避免和 `.NET Framework 4.x` 混淆——从 4.8 直接跳到 5.0。

> [!warning] 别再学的过时东西
> - `web.config` / `app.config` 的 `system.web` 配置段 → 现代用 `appsettings.json` + `Microsoft.Extensions.Configuration`
> - `packages.config` → 现代用 `<PackageReference>`
> - `ASP.NET Web Forms` / `WCF`（服务端） → 现代用 [[后端-03-ASPNET-Core]]、gRPC
> - `.NET Framework` 里的 `System.Configuration.ConfigurationManager` → 现代用选项模式（Options Pattern）

### 1.3 安装 SDK 与验证

三种安装方式，选一种即可：

| 方式 | 命令/入口 | 适用场景 |
|---|---|---|
| 官方安装包 | [dotnet.microsoft.com/download](https://dotnet.microsoft.com/en-us/download) | 个人开发机，最省事 |
| Windows 包管理器 | `winget install Microsoft.DotNet.SDK.10` | 自动化装机 |
| 脚本 | `dotnet-install.ps1` / `dotnet-install.sh` | CI 环境、无管理员权限 |

```powershell
# 一次性把 SDK 和运行时信息全部打印出来：排查环境问题第一命令
dotnet --info

# 只列出已安装的 SDK（一台机器可以并排装多个版本）
dotnet --list-sdks

# 只列出已安装的运行时（SDK 自带运行时，但可能装了额外的运行时）
dotnet --list-runtimes
```

典型输出（`dotnet --list-sdks`）：

```
10.0.401 [C:\Program Files\dotnet\sdk]
```

> [!tip] 版本策略：装哪个？
> - **LTS**（长期支持，如 .NET 8、.NET 10）支持 3 年，生产环境首选。.NET SDK 10.0.401 对应的 .NET 10 是 LTS，支持到 2028-11。
> - **STS**（标准期限支持，如 .NET 9）支持 18 个月，适合追新特性。
> - 官方支持策略：[.NET Support Policy](https://dotnet.microsoft.com/en-us/platform/support/policy/dotnet-core)（以官方最新页面为准）。

### 1.4 `dotnet` CLI 常用命令

| 命令 | 作用 | 常用参数 |
|---|---|---|
| `dotnet new <模板>` | 从模板创建项目 | `console`、`classlib`、`webapi`、`sln`；`-n 名称`、`-o 目录`、`-f net10.0` |
| `dotnet new list` | 列出本机所有模板 | `dotnet new list console` 可过滤 |
| `dotnet build` | 编译（默认 Debug） | `-c Release`、`--no-restore` |
| `dotnet run` | 编译并运行 | `--project 路径`、`-- 传给程序的参数` |
| `dotnet test` | 运行测试项目 | `--filter`、`--collect:"XPlat Code Coverage"` |
| `dotnet add package <名>` | 添加 NuGet 包引用 | `--version 1.2.3`、`--prerelease` |
| `dotnet add reference <项目>` | 添加项目引用 | 无 |
| `dotnet publish` | 产出可部署产物 | `-c Release -o out`、`-r win-x64 --self-contained`、`-p:PublishAot=true` |
| `dotnet restore` | 还原 NuGet 依赖 | `--locked-mode`（CI 用） |
| `dotnet format` | 按规则格式化代码 | `--verify-no-changes`（CI 用） |
| `dotnet tool install -g <名>` | 安装全局工具 | `dotnet-ef`、`dotnet-format` |
| `dotnet clean` | 删除编译产物 | `-c Release` |

> [!tip] `--` 的意义
> `dotnet run -- --name Alice` 里，第一个 `--` 之后的参数才是**传给程序的**，前面的属于 `dotnet run` 自己。少了这个 `--`，`--name` 会被 CLI 当成自己的选项而报错。

### 1.5 项目文件 `.csproj` 与 SDK 风格项目

老式项目文件要把每个 `.cs` 文件写进 `<Compile Include="...">`；**SDK 风格**项目靠约定自动包含：`**/*.cs`、`.resx`、`wwwroot` 等，只需声明"例外"。

```xml
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <!-- 目标框架：决定能用到哪些 BCL API。net10.0 表示 .NET 10 -->
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <!-- 让编译器按最新语言版本解析语法糖；不写则按目标框架的默认版本 -->
    <LangVersion>latest</LangVersion>
    <!-- 开启可空引用类型静态分析：把"可能为 null"变成编译期警告 -->
    <Nullable>enable</Nullable>
    <!-- 隐式 using：自动引入 System、System.Linq 等常用命名空间 -->
    <ImplicitUsings>enable</ImplicitUsings>
    <RootNamespace>Demo.App</RootNamespace>
    <AssemblyName>Demo.App</AssemblyName>
  </PropertyGroup>

  <ItemGroup>
    <!-- 例外声明：测试或工具模板文件不参与编译 -->
    <Compile Remove="Scripts/**/*.cs" />
  </ItemGroup>

  <ItemGroup>
    <!-- PackageReference 取代了旧的 packages.config，依赖写进项目文件本身 -->
    <PackageReference Include="Serilog" Version="4.2.0" />
  </ItemGroup>

</Project>
```

| 属性 | 默认值 | 建议 |
|---|---|---|
| `TargetFramework` | 模板决定 | 生产用 LTS（`net10.0`）；类库可多目标 `net8.0;net10.0` |
| `Nullable` | 新模板为 `enable` | 新项目一律 `enable` |
| `ImplicitUsings` | 新模板为 `enable` | 小项目开启；库项目可关闭以免污染 |
| `TreatWarningsAsErrors` | `false` | CI 里设 `true`，让警告无法被忽略 |
| `InvariantGlobalization` | `false` | 容器里可设 `true` 减小体积，但会丢失区域性行为 |

---

## 二、为什么这样设计

### 2.1 为什么 C# 是静态类型、编译型语言

| 维度 | C#（静态 + 编译） | Python（动态 + 解释） |
|---|---|---|
| 类型检查时机 | 编译期 | 运行期 |
| 错误暴露 | 写错属性名 → 编译不过 | 运行到那一行才 `AttributeError` |
| 性能 | 类型信息已知，JIT 可去虚化、内联、栈分配 | 每次属性访问都要查字典 |
| 重构 | IDE 可靠改名 | 靠文本搜索，易漏 |
| 灵活性 | 需要泛型/委托/反射补齐 | 天生灵活 |
| 开发速度 | 前期慢、后期稳 | 前期快、大型项目易失控 |

C# 的取舍是"用编译期的约束换运行期的确定"。类型系统还顺带解决了**重构安全**和**工具支持**（自动补全、跳转定义、找引用）——这是大型项目里最贵的东西。

### 2.2 为什么有 `var` 却仍推荐显式类型

`var` 是**编译期类型推断**，不是动态类型：`var x = 1;` 里 `x` 依然是 `int`，之后 `x = "abc";` 编译不过。它的设计目的是消除**重复的类型名**，而不是逃避类型：

```csharp
// 类型在右侧已经写得清清楚楚，左侧再写一遍是噪音 → 用 var
var users = new Dictionary<string, List<int>>();
var sw = System.Diagnostics.Stopwatch.StartNew();

// 右侧看不出类型（工厂方法、LINQ、字面量）→ 显式写出来，读者不用猜
List<Order> pending = repo.GetPendingOrders();
IEnumerable<int> evens = numbers.Where(n => n % 2 == 0);  // 元素类型重要，别写 var
decimal total = 0m;   // 0 是 int、0m 是 decimal、0.0 是 double，这里必须显式
```

> [!important] `var` 的三条硬规则
> 1. 必须**同时初始化**：`var x;` 编译不过。
> 2. 初始化表达式不能是 `null`，也不能是方法组/匿名方法：`var f = SomeMethod;` 编译不过。
> 3. 推断出的类型是**静态的**：`var i = 1; i = "s";` 编译不过。它不是 JavaScript 的 `let`。

---

## 三、核心内容

### 3.1 命名空间与 `using`

命名空间（Namespace）是**类型的全名前缀**，用来避免重名冲突、组织代码；`using` 指令只是**简化书写**，不影响运行时行为（编译后类型名仍是全名）。

```csharp
namespace Demo.App.Core;   // 文件范围命名空间（C# 10+），整个文件都属于它

using System.Text;                  // 引入命名空间
using SysList = System.Collections.Generic.List<int>;  // 别名，解决重名
using static System.Math;           // 静态引入：可直接写 Sqrt(2) 而不是 Math.Sqrt(2)

public class Widget
{
    public void Show()
    {
        var sb = new StringBuilder();   // 来自 using System.Text
        Console.WriteLine(Sqrt(16));    // 来自 using static System.Math
    }
}
```

| 写法 | 作用 | 注意 |
|---|---|---|
| `using System.Text;` | 引入命名空间下所有类型 | 不引入子命名空间的类型 |
| `using static System.Math;` | 引入类型的静态成员 | 过度使用会降低可读性 |
| `using Alias = X.Y.Z;` | 起别名 | 也可给泛型起别名 |
| `global using System;` | 全局 using，整个项目可见 | 通常放在 `GlobalUsings.cs` |
| `<ImplicitUsings>enable</ImplicitUsings>` | 由 SDK 自动生成一组全局 using | 生成的列表随 SDK 版本变化 |

> [!warning] `using` 的两个身份
> `using` 指令（引入命名空间）和 `using` 语句（`using var f = File.OpenRead(...)`，见 [[CSharp-02-面向对象]]）是完全不同的东西，只是关键字撞名。看到 `using` 先看后面跟的是**命名空间**还是**表达式**。

### 3.2 顶级语句（Top-level statements）

C# 9 起，`Program.cs` 可以不写 `class Program` 和 `static void Main`：编译器会自动生成它们。

```csharp
// Program.cs —— 整个文件就是 Main 的方法体，编译器自动包裹
Console.WriteLine("Hello, .NET 10");

// args 是自动提供的命令行参数数组（隐含名为 args）
if (args.Length > 0)
{
    Console.WriteLine($"收到参数：{args[0]}");
}

// 若需要返回值，直接 return；返回值成为进程退出码
return 0;
```

等价的传统写法（编译器实际生成的结构）：

```csharp
internal static class Program
{
    private static int Main(string[] args)   // 顶级语句的 return 值对应这里
    {
        Console.WriteLine("Hello, .NET 10");
        return 0;
    }
}
```

> [!note] 顶级语句的约束
> - 一个项目里**只有一个文件**能有顶级语句。
> - 隐式生成的 `Main` 是 `private static`，所以其他类型调用不到它。
> - 顶级语句里可以声明**局部函数**，也可以在其后声明类型，但类型必须写在所有语句之后。
> - 若同一项目里已有显式 `Main`，再写顶级语句会报错（两个入口点）。

### 3.3 内置类型：取值范围与默认值

| C# 关键字 | .NET 类型 | 字节 | 取值范围 | 默认值 | 字面量示例 |
|---|---|---|---|---|---|
| `sbyte` | `System.SByte` | 1 | $-128$ ~ $127$ | `0` | `(sbyte)-1` |
| `byte` | `System.Byte` | 1 | $0$ ~ $255$ | `0` | `(byte)200` |
| `short` | `System.Int16` | 2 | $-32768$ ~ $32767$ | `0` | `(short)-5` |
| `ushort` | `System.UInt16` | 2 | $0$ ~ $65535$ | `0` | `(ushort)60000` |
| `int` | `System.Int32` | 4 | $-2^{31}$ ~ $2^{31}-1$ | `0` | `42` |
| `uint` | `System.UInt32` | 4 | $0$ ~ $2^{32}-1$ | `0` | `42u` |
| `long` | `System.Int64` | 8 | $-2^{63}$ ~ $2^{63}-1$ | `0L` | `42L` |
| `ulong` | `System.UInt64` | 8 | $0$ ~ $2^{64}-1$ | `0UL` | `42UL` |
| `nint` | `System.IntPtr` | 平台相关 | 32/64 位指针宽度 | `0` | `(nint)1` |
| `float` | `System.Single` | 4 | $\pm 1.5\times10^{-45}$ ~ $\pm3.4\times10^{38}$，7 位有效数字 | `0f` | `1.5f` |
| `double` | `System.Double` | 8 | $\pm5.0\times10^{-324}$ ~ $\pm1.7\times10^{308}$，15–17 位有效数字 | `0d` | `1.5` |
| `decimal` | `System.Decimal` | 16 | $\pm1.0\times10^{-28}$ ~ $\pm7.9\times10^{28}$，28–29 位有效数字 | `0m` | `19.99m` |
| `bool` | `System.Boolean` | 1 | `true` / `false` | `false` | `true` |
| `char` | `System.Char` | 2 | UTF-16 码元 `U+0000` ~ `U+FFFF` | `'\0'` | `'A'`、`'\n'`、`'\u4E2D'` |
| `string` | `System.String` | 引用类型 | 不可变 Unicode 序列 | `null` | `"hi"`、`@"C:\t"` |
| `object` | `System.Object` | 引用类型 | 所有类型的根 | `null` | `new object()` |

> [!warning] `float` / `double` 不能表示精确小数
> `0.1 + 0.2 != 0.3`（二进制浮点无法精确表示 0.1）。**涉及金额、税率、单价一律用 `decimal`**。反过来说，科学计算、图形、机器学习用 `double`，因为 `decimal` 慢得多（软件实现）且范围小。

整数类型的大小换算关系（`n` 位有符号整数）：

$$
\text{范围} = \left[-2^{\,n-1},\; 2^{\,n-1}-1\right]
$$

### 3.4 值类型与引用类型

这是 C# 类型系统的分水岭。

| 维度 | 值类型（Value Type） | 引用类型（Reference Type） |
|---|---|---|
| 包括 | `struct`、`enum`、所有内置数值/`bool`/`char`、`record struct`、`ValueTuple` | `class`、`interface`、`delegate`、`string`、`object`、数组、`record`（默认）、`dynamic` |
| 变量存什么 | **数据本身** | **指向对象的引用**（地址） |
| 赋值语义 | 复制整个值（副本独立） | 复制引用（两个变量指向同一对象） |
| 可为 `null` | 默认不可以（`int?` 可以） | 可以 |
| 存放位置 | 通常是栈，或**包含它的对象字段**里 | 托管堆 |
| 继承 | 隐式继承 `System.ValueType`，不能自定义继承 | 支持继承 |
| 相等性默认 | 逐字段比较（`ValueType.Equals`） | 引用相等（`Object.ReferenceEquals`） |
| 典型用途 | 小数据、数学值、性能敏感 | 有身份、有生命周期的大对象 |

**"栈和堆"到底指什么？** 精确的说法是：

- **栈（Stack）**：每个线程一个，存**局部变量**和**调用帧**。方法返回时帧被弹出，所以栈上的数据**不需要 GC**。栈很小（默认 1 MB 左右），放不下大对象。
- **托管堆（Managed Heap）**：所有线程共享，存**引用类型对象**，由垃圾回收（Garbage Collection, GC）负责回收。
- 关键细节：**值类型不一定在栈上**。如果它是某个类的字段、或是数组的元素、或是被装箱、或是 lambda 的闭包捕获，它就活在堆上。所以严格的说法是"值类型**内联存储**在它所属的位置"，而不是"值类型在栈上"。

```csharp
// 值语义：赋值即复制，两份数据互不影响
struct Point { public int X; public int Y; }

Point a = new Point { X = 1, Y = 2 };
Point b = a;      // 复制了 8 个字节
b.X = 99;
Console.WriteLine(a.X);   // 1 —— a 没被改动

// 引用语义：赋值即复制引用，指向同一个对象
class Box { public int X; public int Y; }

Box c = new Box { X = 1, Y = 2 };
Box d = c;        // 只复制了引用（地址）
d.X = 99;
Console.WriteLine(c.X);   // 99 —— c 和 d 是同一个对象
```

**为什么这么设计？** 值类型给"纯数据"（坐标、金额、复数）提供低开销的复制语义；引用类型给"有身份的对象"（用户、连接、窗口）提供共享语义。选错了会出现两类 bug：用 `struct` 表示可变的大对象 → 改了半天改的是副本；用 `class` 表示数学值 → 两个"相等的点"却不 `==`。

#### 装箱与拆箱（Boxing / Unboxing）

把值类型转成 `object`（或它实现的接口）叫**装箱**：在堆上分配一个包装对象，把值复制进去。反向叫**拆箱**：检查类型后把值复制出来。

```csharp
int n = 42;
object boxed = n;      // 装箱：堆分配 + 复制（有 GC 压力）
int back = (int)boxed; // 拆箱：类型检查 + 复制

// 更隐蔽的装箱：ArrayList 只接受 object
var legacy = new System.Collections.ArrayList();
legacy.Add(1);         // 装箱
legacy.Add(2);         // 装箱
int sum = 0;
foreach (int x in legacy)  // 每次迭代都拆箱
    sum += x;

// 现代写法：List<int> 是泛型，元素就是 int 本身，全程无装箱
var modern = new List<int> { 1, 2 };
```

| 场景 | 是否装箱 |
|---|---|
| `int` → `object` / `interface` | 是 |
| `List<int>` 存取元素 | 否（泛型在运行时有专属代码） |
| `string.Format("{0}", 1)` | 是（参数是 `object`） |
| `$"{1}"` 插值（`int`） | 通常否，C# 10+ 用 `DefaultInterpolatedStringHandler` 直接写字符 |
| `enum` 用作 `Dictionary<TKey,...>` 的键 | 否（泛型）；用非泛型 `Hashtable` 则**是** |

> [!important] 避免装箱的三种手段
> 1. **用泛型集合**替代 `ArrayList` / `Hashtable`：`List<int>`、`Dictionary<MyEnum, string>`。
> 2. **接口约束也要泛型**：`void Foo<T>(T x) where T : IComparable<T>` 不装箱；写成 `void Foo(IComparable x)` 传 `int` 就装箱。
> 3. **比较时用泛型接口**：`EqualityComparer<T>.Default` 而不是 `object.Equals(a, b)`。
> 装箱本身是 $O(1)$，但每次分配都增加 GC 压力；在每秒百万次的热路径上，它是可测量的性能问题。

### 3.5 可空值类型 `int?`

值类型默认不能为 `null`（因为它没有"空引用"的概念）。`int?` 是 `System.Nullable<T>` 的语法糖，给值类型加一个 `HasValue` 标志位。

```csharp
int? maybeAge = null;              // 等价于 Nullable<int> maybeAge = null

if (maybeAge.HasValue)             // 显式检查
    Console.WriteLine(maybeAge.Value);

// 或者用模式匹配一次完成"判空 + 取值"
if (maybeAge is int age)
    Console.WriteLine($"年龄 {age}");

// 空合并运算符：左边为 null 时取右边
int display = maybeAge ?? 0;

// 空合并赋值：仅在为 null 时赋值
maybeAge ??= 18;

// 对可空类型做算术：结果仍是可空；null 会向上传播
int? a = 5, b = null;
Console.WriteLine(a + b);          // 输出空行——表达式的值是 null
Console.WriteLine(a + b ?? -1);    // -1
```

| 表达式 | 语义 | 结果 |
|---|---|---|
| `x.HasValue` | 是否有值 | `bool` |
| `x.Value` | 取值；`null` 时抛 `InvalidOperationException` | `T` |
| `x ?? d` | 为 `null` 时用默认值 | `T` |
| `x ??= d` | 为 `null` 时赋值 | — |
| `x?.Member` | 有值才访问成员，否则 `null` | 可空 |
| `x.GetValueOrDefault()` | 取值或 `default(T)`，**不抛异常** | `T` |

> [!warning] 可空值类型 ≠ 可空引用类型
> `int?` 是**运行时**概念（真的多一个标志位）。`string?`（C# 8 起的可空引用类型）只是**编译期静态分析**的注解，运行时里 `string` 和 `string?` 完全一样。详见 [[CSharp-06-现代CSharp特性]]。

### 3.6 `const` 与 `readonly`

| 对比项 | `const` | `readonly`（字段） | `static readonly` |
|---|---|---|---|
| 求值时机 | **编译期** | 运行期（构造时） | 运行期（类型初始化时） |
| 允许的类型 | 只能是编译期常量（基元类型、`string`、`enum`、`null`） | 任意类型 | 任意类型 |
| 能否用 `new` 初始化 | 不能 | 能 | 能 |
| 存储位置 | 调用处**内联**替换（`literal`） | 字段本身 | 静态字段 |
| 跨程序集版本问题 | **有**（见下） | 无 | 无 |
| 可变对象的成员 | 不适用 | 引用不可变，**内容仍可变** | 同左 |

```csharp
public class Limits
{
    // 编译期常量：所有引用它的代码里会被替换成字面量 100
    public const int MaxRetries = 100;

    // 运行期常量：可以在构造时计算，可以 new
    public static readonly DateTime Epoch = new(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
    public static readonly string MachineName = Environment.MachineName;

    // readonly 只锁住"引用"，不锁住对象内容
    public readonly List<int> Buffer = new();
    public void Add(int v) => Buffer.Add(v);   // 合法：没有重新赋值
    // public void Reset() => Buffer = new();  // 编译错误：不能给 readonly 字段赋值
}
```

> [!danger] `const` 的跨程序集陷阱
> `public const int MaxRetries = 100;` 被**编译进调用方**的程序集。如果 A 程序集引用 B 的 `MaxRetries`，之后把 B 里的值改成 `200` 并只重新编译 B，A 仍然用着 `100`——必须重编译 A 才生效。
> **公共 API 里优先用 `static readonly`；`const` 只用于永远不变的真常量**（如 `Math.PI` 那类、或 `private const`）。

### 3.7 类型转换：四种手段的安全等级

| 手段 | 语法 | 失败行为 | 适用场景 |
|---|---|---|---|
| 隐式转换 | `long x = 5;` | 不存在失败 | 无精度损失的加宽转换 |
| 显式转换（强制） | `int y = (int)3.9;` | 编译通过，可能溢出/截断（`unchecked` 下静默） | 确定安全时的窄化 |
| `Convert.ToXxx` | `Convert.ToInt32("42")` | 抛 `FormatException` / `OverflowException` | 已有可信数据，失败即 bug |
| `Parse` | `int.Parse("42")` | 同上 | 同上，类型化更直接 |
| `TryParse` | `int.TryParse(s, out var v)` | **返回 `false`，不抛异常** | **用户输入、外部数据 —— 首选** |
| `as` + 判空 | `var s = o as string;` | 失败返回 `null` | 引用类型、可空值类型 |

```csharp
using System.Globalization;

// 1) 用户输入 → 永远用 TryParse，别用异常做流程控制
string input = "12abc";
if (int.TryParse(input, NumberStyles.Integer, CultureInfo.InvariantCulture, out int parsed))
    Console.WriteLine(parsed);
else
    Console.WriteLine("不是合法整数");      // 走这里，且没有异常开销

// 2) 浮点数解析要指定区域性：某些区域用逗号做小数点
bool ok = double.TryParse("3.14", NumberStyles.Float,
                          CultureInfo.InvariantCulture, out double pi);

// 3) 引用类型向下转型：as 失败给 null，强制转换失败抛 InvalidCastException
object o = "hello";
string? s1 = o as string;          // "hello"
string s2 = (string)o;             // 也可以
// int bad = (int)o;               // 运行期抛 InvalidCastException

// 4) 溢出检查：checked 让静默溢出变成 OverflowException
int big = int.MaxValue;
unchecked { Console.WriteLine(big + 1); }        // -2147483648（回绕）
try { checked { Console.WriteLine(big + 1); } }
catch (OverflowException) { Console.WriteLine("溢出被捕获"); }

// 5) 现代模式匹配转换，比 as + 判空更简洁
if (o is string text && text.Length > 0)
    Console.WriteLine(text.ToUpperInvariant());
```

> [!warning] 数值转换的三种"静默错误"
> 1. `(int)3.99` 得到 `3`（向零截断），不是四舍五入。要四舍五入用 `Math.Round`（并注意它的**银行家舍入**：`Math.Round(2.5)` 是 `2`；要"四舍五入"用 `MidpointRounding.AwayFromZero`）。
> 2. `(int)double.NaN` 在 `unchecked` 下得到 `0` 或 `int.MinValue`（平台相关），务必先判 `double.IsNaN`。
> 3. `int.Parse("")` 抛 `FormatException`；`Convert.ToInt32(null)` 返回 `0` 而不是抛异常——空值与 `null` 的处理策略不同。

### 3.8 字符串：不可变性的后果

`string` 是**不可变（immutable）**的引用类型：任何"修改"操作都返回新字符串。

```csharp
string a = "hello";
string b = a.ToUpperInvariant();   // 新对象，a 本身不变
Console.WriteLine($"{a} / {b}");   // hello / HELLO

// 每次 += 都新建一个字符串：n 次拼接产生 O(n^2) 的字节复制量
string slow = "";
for (int i = 0; i < 10_000; i++)
    slow += i.ToString();          // 每次都重新分配 + 复制前缀

// StringBuilder 内部是可扩容的字符缓冲区，追加是均摊 O(1)
var sb = new System.Text.StringBuilder(capacity: 10_000);  // 预设容量可避免扩容
for (int i = 0; i < 10_000; i++)
    sb.Append(i);
string fast = sb.ToString();
```

拼接 $n$ 个片段的代价对比（设每次总长近似为 $k$）：

$$
\text{朴素拼接} = \sum_{i=1}^{n} O(i) = O(n^2) \qquad \text{StringBuilder 追加} = O(n) \ \text{（均摊）}
$$

| 场景 | 推荐做法 |
|---|---|
| 固定几个片段 | `+` 或 `$""`（编译器常合并为一次 `String.Concat`） |
| 循环内累积（次数未知或很多） | `StringBuilder` |
| 拼接集合元素 | `string.Join(separator, items)` |
| 只判断/查找/替换少量内容 | `Contains` / `IndexOf` / `Replace`（注意 `Replace` 也返回新串） |
| 高性能解析、避免分配 | `ReadOnlySpan<char>` + `string.Create`（见 [[CSharp-06-现代CSharp特性]]） |

#### 插值字符串、逐字字符串、原始字符串

```csharp
string name = "阿伟";
int score = 95;

// 插值字符串：可读性最好，且不像 string.Format 那样装箱
Console.WriteLine($"{name} 得分 {score}，等级 {(score >= 90 ? "A" : "B")}");

// 插值里对齐与格式：,10 表示右对齐宽度 10，:F2 表示两位小数
Console.WriteLine($"[{score,10:F2}]");

// 逐字字符串（verbatim，@ 前缀）：不处理转义，可跨行；内部双引号写成 ""
string path = @"C:\logs\app";
string multi = @"第一行
第二行";

// 原始字符串字面量（Raw string literal，C# 11+）：多行、无需转义、缩进自动剥离
string json = """
    {
      "name": "阿伟",
      "tags": ["csharp", "dotnet"]
    }
    """;
Console.WriteLine(json);

// 内容里需要出现三个连续引号时，用四个引号来界定（开闭定界符必须一样长）
string quotes = """" 他说 """你好""" 内容结束 """";
```

> [!tip] 什么时候一定要用原始字符串
> 写 JSON、正则表达式、SQL、Windows 路径时。对比一下可读性：
> `"C:\\logs\\" + "\\d{2}"` → `@"C:\logs\" + @"\d{2}"` → `"""C:\logs\\d{2}"""`（原始字符串里反斜杠就是反斜杠）。
> **注意**：$ 与 """ 可组合成 `$$"""..."""`，此时用 `{{ }}` 表示插值，方便在 JSON 里写花括号。

### 3.9 运算符与优先级

| 优先级（高 → 低） | 运算符 | 结合性 |
|---|---|---|
| 1 | `x.y`、`f(x)`、`a[i]`、`x++`/`x--`（后缀）、`new`、`typeof`、`nameof`、`?.`、`!`（null 包容） | 左 |
| 2 | `+x`、`-x`、`!x`、`~x`、`++x`/`--x`（前缀）、`(T)x` | 右 |
| 3 | `*`、`/`、`%` | 左 |
| 4 | `+`、`-` | 左 |
| 5 | `<<`、`>>`、`>>>` | 左 |
| 6 | `<`、`>`、`<=`、`>=`、`is`、`as` | 左 |
| 7 | `==`、`!=` | 左 |
| 8 | `&`（按位与 / 逻辑与，`bool` 上不短路） | 左 |
| 9 | `^` | 左 |
| 10 | `\|` | 左 |
| 11 | `&&` | 左 |
| 12 | `\|\|` | 左 |
| 13 | `??` | 右 |
| 14 | `?:`（三元） | 右 |
| 15 | `=`、`+=`、`??=` 等赋值 | 右 |

```csharp
// 位运算：判断奇偶比 % 更快，但可读性优先，除非在热路径
bool isOdd = (n & 1) == 1;

// 逻辑运算符的短路特性常常就是正确性的一部分
if (list != null && list.Count > 0) { /* 安全：前半为假就不会访问 Count */ }

// 位标志组合（配合 [Flags] 枚举，见 CSharp-02）
var options = FileOptions.A | FileOptions.B;
bool hasA = (options & FileOptions.A) != 0;

// 三元与 ?? 的优先级陷阱：?? 比 ?: 高，但混合时务必加括号
int v = (maybe ?? 0) > 0 ? 1 : -1;
```

> [!warning] 最容易出错的三个优先级问题
> 1. `a & b` 与 `a && b`：对 `bool` 而言前者**不短路**，`x != null & x.Length > 0` 会抛 `NullReferenceException`。
> 2. `1 + 2 * 3` 是 `7` 不是 `9`——这不是 C# 的坑，但配合 `??`、`?:`、`is` 混用时极易读错。
> 3. **`&&` 和 `||` 的优先级**：`a || b && c` 等价于 `a || (b && c)`。拿不准就加括号，括号不要钱。

### 3.10 流程控制

```csharp
int score = 87;

// if / else if / else：分支少时最直观
if (score >= 90) Console.WriteLine("A");
else if (score >= 80) Console.WriteLine("B");
else Console.WriteLine("C");

// switch 语句：分支多、判断同一个表达式时更清晰；必须有 break/return/goto 结尾
switch (score / 10)
{
    case 10:
    case 9:
        Console.WriteLine("A");   // 多个标签共用一个分支
        break;
    case 8:
        Console.WriteLine("B");
        break;
    default:
        Console.WriteLine("C");
        break;
}

// switch 表达式（C# 8+）：返回值、无贯穿、可配合模式
string grade = score switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    _ => "D"        // _ 是弃元：兜底分支
};
Console.WriteLine(grade);

// 循环三兄弟
for (int i = 0; i < 3; i++) Console.Write(i);          // 计数循环，索引可控
int j = 0;
while (j < 3) { Console.Write(j); j++; }               // 条件循环，次数未知
int k = 0;
do { Console.Write(k); k++; } while (k < 3);           // 至少执行一次

// break 结束整个循环；continue 跳过本次迭代
foreach (int v in new[] { 1, 2, 3, 4, 5 })
{
    if (v == 2) continue;   // 跳过 2
    if (v == 4) break;      // 到 4 就整体结束
    Console.Write(v);       // 输出 1 3
}
```

| 场景 | 推荐 | 理由 |
|---|---|---|
| 2–3 个分支 | `if` / 三元 | 最短最直白 |
| 同值多分支、需要副作用 | `switch` 语句 | 编译器会做跳转表优化 |
| 同值多分支、需要结果 | `switch` 表达式 | 强制穷尽、无贯穿、可表达式化 |
| 模式判断（类型、属性、范围） | `switch` 表达式 + 模式 | 见 [[CSharp-06-现代CSharp特性]] |
| 遍历集合 | `foreach` | 无需手写下标，也不易越界 |
| 需要下标或反向 | `for` | `foreach` 不暴露下标 |

### 3.11 数组与 `foreach` 的实现原理

```csharp
// 一维数组：长度固定，索引 O(1)，元素连续存储（缓存友好）
int[] numbers = new int[5];                 // 全部元素为 0
int[] literal = { 1, 2, 3 };                // 隐式长度
int[] init = new int[] { 1, 2, 3 };
int[] modern = [1, 2, 3];                   // 集合表达式（C# 12+）

// 二维数组（矩形数组）：每行长度相同
int[,] grid = new int[2, 3];
grid[1, 2] = 7;
Console.WriteLine(grid.GetLength(0));       // 2 —— 用 GetLength 而不是 Length

// 交错数组（jagged）：数组的数组，每行长度可不同
int[][] jagged = [new[] { 1 }, new[] { 2, 3 }];
Console.WriteLine(jagged[1][1]);            // 3

// 常用成员
Console.WriteLine(numbers.Length);          // 5
Array.Sort(literal);                        // 原地排序，O(n log n)
Array.Reverse(literal);
int idx = Array.IndexOf(literal, 2);        // 找不到返回 -1
Array.Clear(numbers);                       // 清零
```

`foreach` 不是语法糖到"下标循环"，而是糖到**枚举器模式**。编译器把下面的 `foreach`：

```csharp
foreach (int v in numbers)
    Console.WriteLine(v);
```

改写成（概念上的等价形式）：

```csharp
// 编译器生成的等价代码（示意）
var e = numbers.GetEnumerator();     // 1) 取枚举器
try
{
    while (e.MoveNext())             // 2) 逐个前进
    {
        int v = e.Current;           // 3) 取当前元素
        Console.WriteLine(v);
    }
}
finally
{
    (e as IDisposable)?.Dispose();   // 4) 若枚举器可释放则释放（如文件、DB 游标）
}
```

三点关键含义：

1. **可枚举不等于实现 `IEnumerable`**。`foreach` 用的是"模式匹配"：只要类型有公开的 `GetEnumerator()`，且返回类型有 `MoveNext()` 与 `Current`，就能 `foreach`。数组就是靠这个特例（`SZArrayHelper`）避免装箱的。
2. **遍历中不能修改集合**。`List<T>` 的枚举器带 `_version` 字段，`Add`/`Remove` 会让版本号加一，下次 `MoveNext` 抛 `InvalidOperationException: Collection was modified`。
3. **`foreach` 的迭代变量是只读的**（`in` 语义，C# 8+ 起对 `struct` 还能加 `ref readonly`），不能 `v = 10;`。想在遍历中改数组内容，用 `for`。

```csharp
var list = new List<int> { 1, 2, 3 };
try
{
    foreach (int v in list)
        list.Add(v);            // 抛 InvalidOperationException
}
catch (InvalidOperationException ex)
{
    Console.WriteLine(ex.Message);
}

// 正确做法一：先收集要改的内容，遍历结束后统一应用
var toAdd = new List<int>();
foreach (int v in list) toAdd.Add(v * 10);
list.AddRange(toAdd);

// 正确做法二：需要边遍历边删就倒着用 for
for (int i = list.Count - 1; i >= 0; i--)
    if (list[i] % 2 == 0) list.RemoveAt(i);
```

---

## 四、怎么用：一个可运行的完整示例

下面这个程序把本篇的核心点串起来：顶级语句、可空类型、`TryParse` 安全解析、`switch` 表达式、`StringBuilder`、数组与 `foreach`。

```csharp
// 文件名：Program.cs；项目：dotnet new console -n GradeBook
using System.Globalization;
using System.Text;

// 一组原始分数，其中混入了非法输入——真实数据总是脏的
string[] rawScores = ["95", "87", "abc", "72", "100", ""];

var valid = new List<int>();       // 泛型集合：不会装箱
var invalid = new List<string>();

foreach (string raw in rawScores)
{
    // TryParse 而不是 Parse：非法输入是可预期的业务分支，不该用异常表达
    if (int.TryParse(raw, NumberStyles.Integer, CultureInfo.InvariantCulture, out int s)
        && s is >= 0 and <= 100)   // 模式匹配同时完成两次范围判断
    {
        valid.Add(s);
    }
    else
    {
        invalid.Add(string.IsNullOrWhiteSpace(raw) ? "(空)" : raw);
    }
}

// switch 表达式把"分数 → 等级"的映射写成一个值，天然无贯穿
static string ToGrade(int score) => score switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    >= 60 => "D",
    _     => "F",
};

// StringBuilder：循环内累积文本，避免 O(n^2) 的字符串复制
var report = new StringBuilder();
foreach (int s in valid)
    report.AppendLine($"{s,4} → {ToGrade(s)}");

double avg = valid.Count > 0 ? valid.Sum() / (double)valid.Count : 0.0;

Console.WriteLine(report.ToString());
Console.WriteLine($"有效 {valid.Count} 条，无效 {invalid.Count} 条：{string.Join(", ", invalid)}");
Console.WriteLine($"平均分 {avg:F2}，最高 {valid.Max()}");
```

关键行解释：

- `int.TryParse(...)` 放在 `if` 里：解析成功才继续，失败走 `else`，**不用 try/catch 做流程控制**（异常在 .NET 里很贵，且会掩盖真正的 bug）。
- `s is >= 0 and <= 100`：关系模式（relational pattern），比 `s >= 0 && s <= 100` 更紧凑，且不会写错成 `0 <= s <= 100`（那在 C# 里是编译错误，但在 C 里是经典 bug）。
- `valid.Sum() / (double)valid.Count`：注意 `(double)` 强制转换放在除法前，否则会做整数除法丢掉小数。
- `report.AppendLine(...)` 用 `StringBuilder` 而不是 `+=`：循环体内的字符串拼接是性能杀手。

运行：

```powershell
dotnet new console -n GradeBook
# 用上面的内容替换 Program.cs
cd GradeBook
dotnet run
```

预期输出（节选）：

```
  95 → A
  87 → B
  72 → C
 100 → A
有效 4 条，无效 2 条：abc, (空)
平均分 88.50，最高 100
```

---

## 五、注意事项与常见坑

> [!warning] 新手最高频的十个坑
> 1. **用 `double` 算钱**：`0.1 + 0.2 != 0.3`。金额一律 `decimal`，并且字面量要带 `m`。
> 2. **整数除法丢精度**：`5 / 2 == 2`。要么先转 `double`/`decimal`，要么用 `Math.DivRem`。
> 3. **`int.Parse` 处理用户输入**：非法输入直接抛异常。外部数据一律 `TryParse`。
> 4. **`string +=` 放在循环里**：$O(n^2)$。累积用 `StringBuilder` 或 `string.Join`。
> 5. **遍历中修改集合**：抛 `InvalidOperationException`。倒序 `for` 或先收集再改。
> 6. **`const` 用作公共 API**：调用方内联了值，改库不重编译调用方不生效。公共 API 用 `static readonly`。
> 7. **以为值类型都在栈上**：类字段里的 `struct`、数组元素、闭包捕获的 `struct` 都在堆上。
> 8. **`(int)` 强转掩盖溢出**：默认 `unchecked` 会静默回绕。关键计算用 `checked` 或改宽类型。
> 9. **用 `==` 比较字符串却忽略区域性**：默认 `==` 是**序数（ordinal）**比较，这通常是你要的；但 `ToLower() == "abc"` 这种写法在土耳其语区域会出 bug，用 `string.Equals(a, b, StringComparison.OrdinalIgnoreCase)`。
> 10. **`switch` 语句忘写 `break`**：C# 不允许隐式贯穿，编译会报错——这是好事，但迁移自 C/C++ 的人会不适应。

> [!tip] 工程实践建议
> - 新项目一律 `<Nullable>enable</Nullable>` + `<TreatWarningsAsErrors>true</TreatWarningsAsErrors>`，把"可能为 null"变成编译期问题。
> - 用 `dotnet format` 和 `.editorconfig` 统一风格，CI 里用 `dotnet format --verify-no-changes` 卡住。
> - 数值输入边界一律显式校验范围，别指望类型转换替你做业务校验。
> - 学习期多用 `dotnet script` 式的短程序验证行为，别靠记忆猜。

---

## 六、练习题

1. **基础题**：写一个程序，把用户输入的一行以空格分隔的数字求和，忽略非法片段，最后输出总和与非法片段个数。要求用 `TryParse`、`StringBuilder`，并对空输入给出提示。
2. **基础题**：给定 `int[] data = { 3, 1, 4, 1, 5, 9, 2, 6 }`，用 `switch` 表达式实现一个 `Describe(int)` 方法：负数返回 `"负"`，`0` 返回 `"零"`，`1..9` 返回 `"个位"`，其余返回 `"大数"`；再用 `foreach` 打印每个元素的描述。
3. **进阶题**：实现 `bool TryAverage(int[] values, out double avg)`，要求：数组为 `null` 或长度为 0 时返回 `false` 且 `avg = 0`；否则用 `long` 累加避免 `int` 溢出，返回真实平均值（注意整数除法陷阱）。
4. **进阶题**：解释并验证下面代码的输出，然后改成正确版本：
   ```csharp
   object o = 42;
   Console.WriteLine(o == (object)42);   // ？
   Console.WriteLine((int)o == 42);      // ？
   Console.WriteLine(o.ToString() == "42");
   ```
   提示：先想清楚哪一步发生装箱、`object` 的 `==` 比较的是什么。
5. **思考题**：为什么 `string` 要设计成不可变？请从**线程安全**、**哈希表键的稳定性**、**字符串驻留（interning）**、**安全（作为路径/连接串传入时不被篡改）** 四个角度各写一句话。再举一个不可变性带来成本的场景。

---

## 七、常见问题（FAQ）

**Q1：`.NET 10` 和 `C# 13` 是什么关系？我需要分别安装吗？**
A：不需要分别安装。C# 版本由**编译器**决定，编译器随 SDK 一起发布；`.NET 10` 指运行时与 BCL 的版本。装一个 .NET SDK 10.0.401，就同时得到了对应版本的 C# 编译器和 `net10.0` 的 BCL。你也可以通过 `<LangVersion>` 用旧语法编译，或在旧 SDK 上（受限于该 SDK 支持的 C# 版本）用新语法。语言与框架版本对照表见 [C# 语言版本](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-versioning)（以官方最新文档为准）。

**Q2：`var` 是不是"弱类型"？会不会影响性能？**
A：都不是。`var` 只是让编译器替你写类型名，编译后的 IL 与显式写类型**完全一致**，没有额外开销。它也不是动态类型：`var x = 1;` 之后 `x` 就是 `int`，赋 `string` 会编译报错。真正的动态类型是 `dynamic`（运行期解析，有反射开销）。

**Q3：`int?` 和 `Nullable<int>` 有什么区别？为什么 `int?` 不能直接和 `int` 相加？**
A：完全等价，`int?` 是 `System.Nullable<int>` 的语法糖。`int?` 与 `int` 混用时会先做"提升"（lifting）：运算符被提升到可空版本，`null + 1` 的结果是 `null` 而不是异常。所以 `int? a = null; int b = a + 1;` 会编译报错（不能把 `int?` 隐式赋给 `int`），而 `int? c = a + 1;` 合法且 `c` 为 `null`。

**Q4：为什么我的 `foreach` 遍历 `List<T>` 时 `Remove` 会抛异常，但遍历数组时改元素却没问题？**
A：两者的枚举器实现不同。`List<T>` 的枚举器为了保护一致性维护了版本号（`_version`），结构变化（`Add`/`Remove`/`Clear`）会让 `MoveNext` 抛 `InvalidOperationException`。数组没有枚举器对象（编译器走索引特例），修改**元素值**不改变长度，因此不会触发检查；但 `foreach` 的迭代变量本身是只读的，要改元素得用 `for`。

---

## 相关笔记

- [[CSharp-02-面向对象]]：类型系统之上的类、struct、record、接口与多态
- [[CSharp-03-集合与LINQ]]：泛型集合、迭代器与查询，`foreach` 的进阶用法
- [[CSharp-07-dotnet项目与工具链]]：`.csproj`、NuGet、构建与发布、AOT/JIT 的选择
- [[编程语言对比]]：C# 与 Python、JavaScript 在类型与运行方式上的差异
- [[计算机组成原理]]：栈、堆、CPU 缓存与 IL/JIT 的硬件视角

## 参考来源

- [Common Language Runtime (CLR) overview](https://learn.microsoft.com/en-us/dotnet/standard/clr)
- [.NET architectural components](https://learn.microsoft.com/en-us/dotnet/standard/components)
- [dotnet command](https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet)
- [C# built-in types](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/built-in-types)
- [Top-level statements](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/program-structure/top-level-statements)
- [Boxing and unboxing](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/types/boxing-and-unboxing)
- [Nullable value types](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/nullable-value-types)
- [Raw string literals](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/raw-string)
- [string and reference types](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/reference-types)
- [Parsing numeric strings](https://learn.microsoft.com/en-us/dotnet/standard/base-types/parsing-numeric)
- [Download .NET](https://dotnet.microsoft.com/en-us/download)
- [.NET Support Policy](https://dotnet.microsoft.com/en-us/platform/support/policy/dotnet-core)
- 说明：语言版本、SDK 版本号、支持周期等信息易过时，以官方最新文档为准。
