罗罗编程学习记录
本页内容 展开查看

09.2 阶段 1:C# 语言核心

所属:全栈开发面试题库 / 学习路径 / 09 C# 与 .NET 全栈

本页目录

一、阶段定位

阶段 0 只解决"能在本机编译运行",本阶段开始真正接触 C# 的语言模型。重点不是语法清单,而是 C# 与 Java、PHP、Python 在数据表示上的三处硬差异:

  1. 值类型与引用类型是两条语义线:int、struct 赋值复制整个值,class、数组赋值只复制引用,同一块数据被两个变量指向。这决定了"改了 A 会不会影响 B"。
  2. 可空是双层概念:int?(Nullable<int>)是值类型的可空,string? 是引用类型的可空注解——后者只是编译器分析提示,运行时并不真的阻止 null。
  3. LINQ 是惰性的:Where、Select 不立即执行,每次枚举才重新跑一遍;把它当立即执行写,就会出现"查了两次库""副作用执行两次"。

本阶段与前后阶段的衔接:往下接 阶段 2 类型系统进阶与现代特性,那时讨论的是 record、模式匹配、async/await、Span<T>,前提是你已经能分清值与引用、会写委托与事件。往上承接阶段 0 的工程骨架,本阶段要在这个工程里写类库与命令行工具。跳过值/引用语义直接进现代特性,后面遇到"两个订单对象互相污染""集合里装箱导致 GC 压力"时会无从下手。

原有卡点的可判断现象依据:

  • 值类型与引用类型赋值混淆:判断标准是——把一个对象传给方法后在方法里改了字段,调用方看到的也变了,你却以为应该是副本。能复述"class 传的是引用,struct 传的是值"才算过关。
  • 可空引用类型告警被整体关掉:判断标准是——在 csproj 里加 <Nullable>disable</Nullable> 或全程 #nullable disable,却不理解警告在说什么。合格做法是逐条看警告并修代码。
  • 委托与事件说不清:判断标准是——被问到"public event EventHandler E 与 public EventHandler E 的区别"时答不出外部只能 += 不能 =。
  • 把 LINQ 当立即执行:判断标准是——对同一个 IEnumerable 枚举两次,发现里面的 Console.WriteLine 或数据库查询执行了两遍,却没意识到是延迟执行。

二、阶段目标与投入

学完本页,应当能用可观察的行为证明以下六条能力:

能力目标(可验证的行为) 验证方式
能解释并演示值类型与引用类型赋值的差异 写一个 struct 与一个 class,各传一次,对比"修改是否影响调用方"
能正确处理可空类型,区分 int? 与 string? 的运行时差异 对 int? 用 HasValue,对 string? 理解警告来源
能定义泛型方法与 where 约束,说明为什么用泛型 写一个泛型 Max<T> 并对比非泛型版本的装箱开销
能写委托、事件订阅,并在调用方正确退订 事件触发时订阅者收到通知;退订后不再收到
能用 LINQ 查询集合,并说清每次枚举发生了什么 对带副作用的枚举两次,能解释结果为何是两份
能对非托管资源实现 IDisposable 并在调用方释放 文件/连接在 using 块结束时被释放

建议学时:

  • 全职(每天有效学习 4–6 小时):2 周,约 60–70 小时。
  • 在职(每天 2 小时、周末补 4 小时):5–6 周,约 70 小时。

学时分配建议:值/引用类型与内存 20%、面向对象与接口 20%、可空与泛型 15%、委托与事件 10%、集合与 LINQ 20%、异常与 IDisposable 15%。值/引用语义与 LINQ 是面试与线上问题的重灾区,时间要给够。

三、先修自检

进入本阶段前逐条自检;任何一条做不到,先回到对应页面补齐。

先修项 合格标准 不合格时回到
dotnet CLI 可用 dotnet new console、dotnet run 能正常运行 09.1 阶段 0
解决方案结构 有 src/ 与 tests/ 的目录概念 09.1 阶段 0
变量与函数 知道变量、函数参数、返回值是什么 09.1 阶段 0
Git 提交 能把练习代码提交到仓库 09.1 阶段 0

经验判断:写过 Java 的人容易把 string 当可变类型拼接,也容易把 C# 的 struct 当 Java 没有的概念忽略掉;写过 JS 的人容易把"引用类型赋值复制引用"与"深拷贝"混淆。这两类偏差都要在练习里主动纠正。

四、知识地图

"掌握程度"分三档:了解、会用、能讲清原理。

模块 知识点 掌握程度 对应题库章节
值与引用类型 栈与堆、赋值/传参语义、== 比较的是什么 能讲清原理 04.6 CSharp 与 .NET
面向对象 类、接口、抽象类、继承多态、virtual/override 会用 04.6 CSharp 与 .NET
装箱与可空 装箱堆分配、Nullable<T>、可空引用类型与 ! 能讲清原理 04.6 CSharp 与 .NET
泛型与约束 泛型类/方法、where T : ... 约束组合 会用 04.6 CSharp 与 .NET
委托与事件 delegate、event、订阅/退订、内存泄漏 能讲清原理 04.6 CSharp 与 .NET
集合与 LINQ List<T>/Dictionary、Where/Select、延迟执行 能讲清原理 04.6 CSharp 与 .NET
字符串与异常 string 不可变、StringBuilder、异常层级、try/catch/finally、IDisposable 会用 04.6 CSharp 与 .NET

进度管理建议:把这张表复制到笔记里,每学完一个模块把"掌握程度"往下调一档;三档都到位再进 阶段 2。《知识点全清单》是更细的全量清单。

五、分模块精讲

5.1 值类型与引用类型:栈与堆的语义线

为什么需要它:这是 C# 最核心的分野。没搞清这一点,后面"两个对象互相污染""集合里频繁装箱"全部无法解释。

核心机制:

  • 值类型:int、double、bool、struct、enum。变量本身持有数据,赋值、传参、返回都复制整个值。
  • 引用类型:class、数组、string、delegate。变量持有的是"数据在堆上的地址",赋值、传参只复制地址,多个变量指向同一块堆对象。
  • == 对值类型比较内容;对引用类型默认比较"是否同一对象"(除非重载了 Equals)。
  • string 虽然是引用类型,但行为上像不可变的值:任何"修改"都产生新字符串,所以它是安全的。
  • 方法传参默认是"按值传递"——对引用类型来说,复制的是引用本身,而不是对象;ref/out 才能让方法替换调用方的变量本身。

最小可运行示例:

// struct 是值类型:赋值复制整个值
struct Point { public int X; }

// class 是引用类型:赋值复制引用
class RefPoint { public int X; }

Point s = new Point { X = 1 };
Point s2 = s;          // s2 是 s 的完整副本
s2.X = 99;
Console.WriteLine(s.X); // 1:s 不受影响

RefPoint r = new RefPoint { X = 1 };
RefPoint r2 = r;      // r2 与 r 指向同一个对象
r2.X = 99;
Console.WriteLine(r.X); // 99:改 r2 等于改 r

常见坑:

现象 原因 修法
方法里改了字段,调用方却看不到(struct) struct 传参复制了一份 把类型改为 class,或用 ref 传参
== 两个内容相同的对象判等失败 引用类型默认比较地址 重写 Equals/GetHashCode,或用 record
大 struct 做参数导致性能下降 每次传参复制整个结构体 控制 struct 大小(建议不超过 16 字节),或用 class

面试考法:高频题是"值类型和引用类型的区别""struct 和 class 怎么选"。要答出:赋值复制内容 vs 复制引用;小而频繁的值用 struct(如 DateTime、Guid),有身份、有可变状态、较大的用 class。追问常落到"string 为什么是引用类型却表现得像值"。

5.2 面向对象:类、接口、继承与多态

为什么需要它:C# 的依赖注入、策略模式、测试 Mock 全部建立在接口抽象之上。不会写接口就无法在后续阶段做可测试的设计。

核心机制:

  • class 默认继承自 object;单继承,接口多实现。
  • interface 只定义契约,不写实现;abstract class 可带部分实现。
  • virtual 允许派生类用 override 重写;sealed 禁止再被继承。
  • 多态:基类引用指向派生类实例,调用时按实际类型分派。
  • 构造函数链:派生类构造默认先调基类无参构造,有参时用 : base(args) 指定。

最小可运行示例:

// 定义一个接口契约
interface INotifier { void Send(string message); }

class EmailNotifier : INotifier
{
    public void Send(string message) => Console.WriteLine($"邮件: {message}");
}

class SmsNotifier : INotifier
{
    public void Send(string message) => Console.WriteLine($"短信: {message}");
}

// 依赖接口而不是具体实现:便于替换与测试
class OrderService
{
    private readonly INotifier _notifier;
    public OrderService(INotifier notifier) => _notifier = notifier;

    public void Place() => _notifier.Send("订单已创建");
}

常见坑:

现象 原因 修法
派生类构造报"基类无无参构造" 基类只定义了有参构造 派生类构造用 : base(args) 显式调用
重写方法没生效 基类方法没标 virtual,或派生类用了 new 而非 override 基类加 virtual,派生类用 override
接口膨胀,实现类被迫实现用不到的方法 违反接口隔离 拆小接口,用显式实现隔离

面试考法:常见问法是"接口和抽象类怎么选""为什么要依赖接口而不是具体类"。要答出:接口定义能力契约、支持多实现,抽象类为共享实现提供模板;依赖接口是为了可替换、可 Mock、可测试。

5.3 装箱、拆箱与可空类型

为什么需要它:这是 C# 性能与"null 引用异常"的双重源头。不理解 int? 与 string? 的区别,后面写 Dictionary<string, int> 时频繁装箱,或在上线后踩 NullReferenceException。

核心机制:

  • 装箱:值类型(如 int)转成 object 或接口类型时,会在堆上分配一个包装对象,把值拷进去。拆箱是逆过程,要显式转换。
  • Nullable<T>:值类型的可空,int? 是 Nullable<int> 的语法糖,内部有 bool HasValue 与 T Value;没装箱,开销小。
  • 可空引用类型:从 C# 8 起,string? 是编译器分析注解,告诉编译器"这个引用可能是 null"。运行时它和普通 string 完全一样,不会阻止你给它赋 null。
  • !(null 宽容运算符):告诉编译器"这里我保证不是 null",绕过告警——但运行时如果真的是 null 照样抛 NullReferenceException。
  • ?.(空条件运算符):name?.Length 在 name 为 null 时返回 null 而不抛异常。

最小可运行示例:

// 装箱:int 转 object 会在堆上分配
int number = 42;
object boxed = number;   // 装箱:堆上多一个对象
int unboxed = (int)boxed; // 拆箱

// Nullable<T>:值类型可空,没有装箱
int? maybe = null;
Console.WriteLine(maybe.HasValue); // False
Console.WriteLine(maybe ?? -1);   // -1:空合并运算符

// 可空引用类型:编译期告警,运行时无差别
string? name = GetName(); // 编译器提示可能为 null
int len = name!.Length;   // ! 告诉编译器"我保证非 null",但真为 null 照样抛异常
int? safeLen = name?.Length; // 安全写法:name 为 null 时 safeLen 为 null

常见坑:

现象 原因 修法
高频装箱导致 GC 压力大 用 ArrayList 或 object 集合装值类型 改用泛型集合 List<int>
Nullable<T>.Value 抛 InvalidOperationException 对 HasValue == false 的实例取 .Value 先判 HasValue 或用 ??
把 string? 当运行时强制非空 以为 string? 会阻止 null 理解它只是编译期注解,运行时仍要判空
滥用 ! 消除告警 用 ! 压警告但运行时真为 null 用 ?. 与 ?? 做防御式判空

面试考法:高频题是"装箱是什么、代价在哪""int? 和 string? 有什么区别"。要答出:装箱是值类型转 object 的堆分配,频繁发生会产生 GC 压力;int? 是 Nullable<int> 带 HasValue,string? 只是编译期注解不改变运行时行为。追问常落到"! 运算符到底有没有用"。

5.4 泛型与约束

为什么需要它:泛型是 C# 避免装箱、保证类型安全的核心机制。不理解 where 约束,写不出通用的数据结构,也看不懂 EF Core、ASP.NET Core 的泛型 API。

核心机制:

  • 泛型让一份代码适用于多种类型,且编译期就确定类型,比 object 方案免去装箱与强制转换。
  • where T : struct 限定值类型;where T : class 限定引用类型;where T : new() 限定有无参构造;where T : IFoo 限定实现某接口。
  • 约束可以组合:where T : class, new()。
  • 泛型在运行时按具体类型共享实现(引用类型共享一份代码,值类型各一份)。

最小可运行示例:

// 泛型方法:在编译期确定 T,无装箱
T Max<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) >= 0 ? a : b;

Console.WriteLine(Max(3, 5));        // 5
Console.WriteLine(Max("cat", "dog")); // dog

// 泛型类:带约束组合
class Repository<T> where T : class, new()
{
    public T CreateNew() => new T();
}

常见坑:

现象 原因 修法
泛型方法里想调用 T 的方法却编译失败 没有加接口约束 加 where T : ISomeInterface
new T() 编译报错 没加 new() 约束 加 where T : new()
用 object 做参数的集合,频繁装箱 泛型写得不对或退化成 object 改用 List<T>

面试考法:常见问法是"泛型相比非泛型集合的好处""where 约束有哪些"。要答出:类型安全(编译期检查)、避免装箱、代码复用;约束用于在泛型代码里安全地调用 T 的能力。

5.5 委托与事件

为什么需要它:委托与事件是 C# 实现回调、发布订阅、事件处理的基础。不理解"事件是委托的封装",后面看不懂 SignalR、UI 绑定、IHostedService 的回调模型。

核心机制:

  • 委托:一种类型安全的方法引用,delegate void Notify(string msg) 定义一个能装"参数 string、无返回"方法的类型。
  • 事件:基于委托的发布订阅封装。public event EventHandler E 让外部只能 +=/-=,不能直接 = 或调用——保护了内部委托链。
  • 事件触发时,订阅者按订阅顺序执行;某个订阅者抛异常会中断后续订阅者(除非手动处理)。
  • 退订:订阅了事件却不退订,发布者与订阅者之间形成引用,导致订阅者无法被 GC 回收——这是经典内存泄漏。

最小可运行示例:

// 定义事件参数与事件发布者
class OrderEventArgs : EventArgs { public string OrderId { get; init; } = ""; }

class OrderService
{
    // event 封装了委托:外部只能 += / -=,不能 = 或调用
    public event EventHandler<OrderEventArgs>? Created;

    public void Create(string id)
    {
        Console.WriteLine($"订单 {id} 已创建");
        // 触发事件:先判空,避免无订阅者时空引用
        Created?.Invoke(this, new OrderEventArgs { OrderId = id });
    }
}

// 订阅与退订
var svc = new OrderService();
svc.Created += OnCreated;   // 订阅
svc.Create("A001");
svc.Created -= OnCreated;   // 退订:避免订阅者被长期持有
svc.Create("A002");        // 这次不触发

static void OnCreated(object? sender, OrderEventArgs e)
    => Console.WriteLine($"收到通知: {e.OrderId}");

常见坑:

现象 原因 修法
订阅者对象无法被 GC 回收 订阅了事件却没退订,发布者持有订阅者引用 用完 -= 退订,或用弱事件模式
外部能 = 覆盖事件订阅 用了 public EventHandler E 而非 public event 改成 public event EventHandler E
无订阅者时触发事件抛 NullReferenceException Created(this, ...) 在无订阅时委托为 null 用 Created?.Invoke(...)

面试考法:高频题是"委托和事件的区别""事件为什么要退订"。要答出:委托是方法引用类型,事件是对委托的封装(外部只能订阅/退订);不退订会让发布者持有订阅者引用,阻止其被 GC 回收,造成内存泄漏。

5.6 常用集合与 LINQ 基础

为什么需要它:集合与 LINQ 是日常代码用得最多的部分。不理解 LINQ 的延迟执行,就会反复踩"查了两次""副作用跑两遍"。

核心机制:

  • List<T>:动态数组,按索引访问 O(1),末尾追加均摊 O(1),中间插入 O(n)。
  • Dictionary<TKey,TValue>:哈希表,查找/增删平均 O(1);键不可变(用作键后不要改其 GetHashCode)。
  • HashSet<T>:哈希集合,去重、判存在 O(1)。
  • LINQ 延迟执行:Where、Select、OrderBy 只是"描述查询",不立即执行;只有 foreach、ToList、Count 等枚举时才真正跑一遍。
  • 立即执行算子:ToList、ToArray、Count、First、ToArray 会立刻枚举并固化结果。

最小可运行示例:

var numbers = new List<int> { 1, 2, 3, 4, 5 };

// 延迟执行:这里还没真正过滤
IEnumerable<int> query = numbers.Where(n =>
{
    Console.WriteLine($"过滤 {n}");
    return n % 2 == 0;
});

// 第一次枚举:才真正执行过滤
Console.WriteLine("--- 第一次枚举 ---");
Console.WriteLine(query.Count());   // 打印 5 次"过滤 n",结果 2

// 第二次枚举:又从头跑一遍
Console.WriteLine("--- 第二次枚举 ---");
Console.WriteLine(query.Count());   // 又打印 5 次"过滤 n"

// 用 ToList 固化结果,避免重复执行
List<int> cached = query.ToList();

常见坑:

现象 原因 修法
同一个查询执行了两遍 LINQ 延迟执行,每次枚举都重跑 立即 ToList() 固化
修改了源集合后,后续枚举结果变了 延迟执行,枚举时读的是当前源 固化结果,或确认业务上是否要实时读
Dictionary 键被修改后查不到 键对象的 GetHashCode 变了 键用不可变类型(如 string),或改完后重建字典
First() 在空集合上抛异常 无元素 用 FirstOrDefault()

面试考法:高频题是"LINQ 是立即执行还是延迟执行""IEnumerable 与 IQueryable 的区别"。要答出:标准查询算子是延迟执行,只有枚举才跑;IEnumerable 是内存枚举,IQueryable 带表达式树可被翻译成 SQL(这一点阶段 2 展开)。追问常到"多次枚举为什么危险"。

5.7 字符串、异常层级与 IDisposable

为什么需要它:字符串拼接、异常处理、资源释放是三个"看着简单、实际全是坑"的日常。string 不可变、异常该 catch 什么、IDisposable 何时调,都必须讲清。

核心机制:

  • string 不可变:任何"修改"(Replace、Substring、+)都产生新字符串,循环拼接会产生大量中间对象。
  • 高频拼接用 StringBuilder,预分配容量减少扩容。
  • 异常层级:Exception 是基类,派生如 ArgumentException、InvalidOperationException、IOException;catch 应捕获具体类型,不要 catch (Exception) 兜一切。
  • finally 无论是否异常都会执行;using 是 try/finally 的语法糖,在退出时自动调 Dispose()。
  • IDisposable:持有非托管资源(文件句柄、网络连接)的类型应实现它,调用方用 using 确保释放。

最小可运行示例:

// 高频拼接用 StringBuilder,不要用 +=
var sb = new StringBuilder();
sb.AppendLine("订单明细");
for (int i = 0; i < 100; i++) sb.AppendLine($"行 {i}");
string report = sb.ToString();

// 用 using 确保资源释放,等价于 try/finally
try
{
    using var reader = new StreamReader("data.txt");
    string content = reader.ReadToEnd();
    Console.WriteLine(content.Length);
} // reader.Dispose() 在这里自动调用
catch (IOException ex)
{
    // 捕获具体异常类型,带上上下文
    Console.WriteLine($"读取失败: {ex.Message}");
}

常见坑:

现象 原因 修法
循环里 str += part 后内存暴涨 每次拼接产生新字符串 用 StringBuilder
catch (Exception ex) 吞掉了所有错误 捕获过宽,掩盖 bug 只捕获能处理的具体异常
文件句柄/连接没释放 没写 using 用 using var 包裹资源对象
Dispose 后继续用对象 释放后再访问 释放后丢弃引用,不要复用

面试考法:常见问法是"string 为什么不可变""using 和 try/finally 的关系""什么时候该实现 IDisposable"。要答出:不可变让字符串安全共享、可做字典键;using 是 try/finally 的语法糖;持有非托管资源时实现 IDisposable。

六、分层练习

三档练习逐档升级,上一档没做完不要跳。

6.1 复现型(照着做,目标是跑通 + 能解释)

练习 要求 验收标准 预计耗时
值/引用语义实验 写一个 struct 和一个 class,各赋值一次对比 能说出 struct 副本不受影响、class 互相影响 1 小时
装箱实验 把 int 装进 ArrayList 与 List<int> 对比 能说清前者有装箱、后者没有 1 小时
可空类型处理 对 int? 与 string? 分别判空 HasValue、?.、?? 都用对 1 小时
事件订阅与退订 写一个发布者,订阅后触发,再退订 退订后事件不再通知订阅者 1.5 小时
LINQ 延迟执行实验 写一个带 Console.WriteLine 的 Where,枚举两次 能解释为什么过滤打印了两遍 1 小时

6.2 改造型(给出现成代码,改出正确行为)

练习 要求 验收标准 预计耗时
消除装箱 把 ArrayList 装值类型改成 List<int> 无装箱,代码编译通过 1 小时
修一个"改了不生效"的方法 给定 struct 参数方法,改 class 或用 ref 调用方能看到修改 1.5 小时
把字符串拼接改成 StringBuilder 给定循环 +=,改为预分配的 StringBuilder 拼接结果一致,中间对象减少 1 小时
修复事件内存泄漏 给定订阅不退订的代码,加退订 订阅者可被回收 1.5 小时
收窄异常捕获 给定 catch (Exception),改为具体异常 只捕获能处理的类型 1 小时

6.3 设计型(自己定方案,目标是能交付、能讲清取舍)

练习 要求 验收标准 预计耗时
CSV 数据统计命令行工具 读取 CSV,按字段聚合,支持错误输入 非法输入被捕获并给出明确提示;资源用 using 6 小时
待办事项列表 增删改查,数据用集合管理,事件通知变更 操作通过事件通知;集合选择有理由 5 小时
类型安全的缓存结构 用泛型 + 约束写一个简单缓存 编译期类型安全;能讲清 where 约束 4 小时

七、排障表

现象 可能原因 排查步骤 解决办法
修改 struct 字段后调用方看不到 struct 传参复制了一份 确认类型是 struct 还是 class 改 class 或用 ref 传参
两个内容相同对象判等为 false 引用类型默认比地址 看是否重写了 Equals 重写 Equals/GetHashCode 或用 record
高频装箱导致 GC 压力大 用了 ArrayList/object 集合 检查集合类型 改用 List<T>
对 Nullable<T>.Value 抛 InvalidOperationException 对 HasValue 为 false 的实例取 Value 先判 HasValue 用 ?? 或判空
事件订阅者无法回收 订阅了事件没退订 检查是否有 -= 用完退订
LINQ 副作用执行了两次 延迟执行,枚举两遍 看是否枚举两次 立即 ToList() 固化
循环字符串拼接内存暴涨 += 产生中间字符串 看循环内拼接 用 StringBuilder
资源没释放 没写 using 检查资源对象 用 using var 包裹

八、出口条件

全部勾选后再进入 阶段 2 类型系统进阶与现代特性。

  • [ ] 能画出 struct 与 class 赋值后"谁复制了谁",并解释 == 比较的是什么
  • [ ] 能说清装箱发生在什么场景,并用泛型集合避免它
  • [ ] 能区分 int? 与 string? 的运行时差异,正确使用 ?.、??、!
  • [ ] 能写泛型方法与 where 约束,说明为什么用泛型
  • [ ] 能写委托与事件,说明外部为什么不能 = 覆盖、为什么要退订
  • [ ] 能解释 LINQ 延迟执行,遇到"执行两次"能一次定位
  • [ ] 能对资源实现 IDisposable 并用 using 释放
  • [ ] 排障表里的八个现象,随机抽三个能在 5 分钟内给出排查路径

自测题(先自己想,再看要点):

  1. int 与自定义 struct 赋值,和 class 赋值,行为有什么不同?
    • 要点:struct/int 复制整个值;class 复制引用,多变量指向同一对象。
  2. int? 与 string? 在运行时有区别吗?
    • 要点:有。int? 是 Nullable<int> 带 HasValue;string? 只是编译期注解,运行时与普通 string 一样,不阻止 null。
  3. 为什么 public event EventHandler E 比 public EventHandler E 安全?
    • 要点:event 封装了委托链,外部只能 +=/-=,不能 = 覆盖别人的订阅、也不能外部触发。
  4. 为什么订阅了事件不退订会内存泄漏?
    • 要点:发布者持有委托,委托持有订阅者方法,使订阅者无法被 GC 回收。
  5. LINQ 的 Where 在什么时候真正执行?
    • 要点:枚举时(foreach、ToList、Count 等)才执行;多次枚举会重跑。
  6. 为什么 string 拼接在循环里要用 StringBuilder?
    • 要点:string 不可变,每次 + 都产生新字符串,循环里产生大量中间对象;StringBuilder 可变缓冲。
  7. using var reader = ... 在什么时候调用 Dispose()?
    • 要点:离开所在代码块(方法/作用域)时自动调用,等价于 try/finally。