09.3 阶段 2:类型系统进阶与现代特性
所属:全栈开发面试题库 / 学习路径 / 09 C# 与 .NET 全栈
本页目录
一、阶段定位
阶段 1 让你分清了值/引用、会写类与集合、理解了委托与 LINQ 延迟。本阶段把这些"能跑"的代码升级为"现代 C# 写法",重点解决四件事:
- 不可变数据模型:用
record与init表达"创建后不再改"的数据,让相等性比较默认按值走,避免手写Equals。 - 分支逻辑现代化:用模式匹配与 Switch 表达式替代冗长的
if-else链,把"按形状解数据"写成声明式。 - 异步模型:
async/await不是"新开线程",而是把方法改写成状态机;Task与ValueTask的选择、ConfigureAwait的用途,必须讲清。 - 零分配内存视图:
Span<T>/stackalloc让处理一段字节或数组切片时不再复制整个数组,是高性能路径的基础。
本阶段与前后阶段的衔接:往下接 阶段 3 CLR、运行时与并发基础,那时讨论 GC 分代、线程池与锁——本阶段的 async/await 正是靠线程池与状态机运转的。往上承接阶段 1,本阶段要在已有的命令行工具上做重构。跳过 async/await 直接进 Web 框架,后面写接口时会把所有异步方法写成同步阻塞,遇到"线程池饥饿"完全无从下手。
原有卡点的可判断现象依据:
- 以为
await会新开线程:判断标准是——被问到"await Task.Delay(1000)阻塞了哪个线程"时答"新开了一个线程去等"。正确理解是 await 不占线程,任务完成后由线程池恢复。 IQueryable在内存集合上误用:判断标准是——对List<T>写.AsQueryable()后再试图解释它如何翻译成 SQL,说不出它根本没翻译、仍是内存枚举。- 把
record当普通类:判断标准是——写record Point(int X, int Y)后,被问"两个new Point(1,2)是否相等"时答"不相等,因为是 new 出来的两个对象"。正确答案是按值相等。 - 不理解 Span 为什么不能当字段:判断标准是——把
Span<T>存进类的实例字段,编译报错却说不出原因(ref struct 不能被装箱、不能跨 await、不能做长期字段)。
二、阶段目标与投入
学完本页,应当能用可观察的行为证明以下六条能力:
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
能解释协变/逆变方向,判断 List<Derived> 为何不能直接赋给 List<Base> |
写出正确的 IEnumerable<out T> 与 Action<in T> 用法 |
能用 record + with 表达不可变数据,并说明它与 class 的相等性差异 |
两个同值 record 对象用 == 判等为 true |
| 能用模式匹配重写一段 if-else 分支 | 用属性模式 + Switch 表达式实现 |
能写异步方法并说清 await 处发生了什么 |
用 await Task.Delay 验证不阻塞线程 |
能区分 Task 与 ValueTask、理解 ConfigureAwait |
说清库与应用的不同取舍 |
能用 Span<T> 处理字节切片而不复制数组 |
对 byte[] 切片后 SequenceEqual 验证不分配新数组 |
建议学时:
- 全职(每天有效学习 4–6 小时):2 周,约 60–70 小时。
- 在职(每天 2 小时、周末补 4 小时):5–6 周。
学时分配建议:协变逆变 10%、record 与 init 15%、模式匹配 15%、扩展方法与迭代器 10%、async/await 与 Task/ValueTask 25%、Span 与内存 15%、表达式树与 IQueryable 10%。异步是后续 Web 阶段的地基,时间要给够。
三、先修自检
进入本阶段前逐条自检;任何一条做不到,先回到对应页面补齐。
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| 值/引用类型语义 | 能解释 struct 与 class 赋值差异 | 09.2 阶段 1 |
| 泛型与约束 | 能写 where T : ... 泛型方法 |
09.2 阶段 1 |
| 委托与 LINQ | 能写委托、解释 LINQ 延迟执行 | 09.2 阶段 1 |
| 异常与 using | 能正确捕获异常、释放资源 | 09.2 阶段 1 |
四、知识地图
"掌握程度"分三档:了解、会用、能讲清原理。
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| 泛型进阶 | 协变 out、逆变 in、方向判断 |
能讲清原理 | 04.6 CSharp 与 .NET |
| record 与 init | record、位置记录、with、init 访问器 |
会用 | 04.6 CSharp 与 .NET |
| 模式匹配 | 常量/属性/位置模式、Switch 表达式 | 会用 | 04.6 CSharp 与 .NET |
| 扩展方法与迭代器 | this 扩展、yield 惰性产出 |
会用 | 04.6 CSharp 与 .NET |
| 异步模型 | async/await 状态机、Task/ValueTask、ConfigureAwait |
能讲清原理 | 04.6 CSharp 与 .NET |
| 高性能内存 | Span<T>、Memory<T>、stackalloc、ref struct 边界 |
能讲清原理 | 04.6 CSharp 与 .NET |
| 表达式树 | Expression<>、IEnumerable 与 IQueryable 边界 |
会用 | 04.6 CSharp 与 .NET |
进度管理建议:把这张表复制到笔记里,三档都到位再进 阶段 3。《知识点全清单》是更细的全量清单。
五、分模块精讲
5.1 泛型进阶:协变与逆变
为什么需要它:为什么 List<Dog> 不能赋给 List<Animal>?为什么 IEnumerable<Dog> 却可以?这背后是泛型参数方向(out/in)的问题,不理解就会在接口设计上反复踩"类型不安全"的坑。
核心机制:
- 协变(
out T):T 只出现在返回位置,允许"派生类型"向"基类型"转换。IEnumerable<out T>只产 T,所以IEnumerable<Dog>可赋给IEnumerable<Animal>。 - 逆变(
in T):T 只出现在参数位置,允许"基类型"向"派生类型"转换。Action<in T>只消费 T,所以Action<Animal>可赋给Action<Dog>。 - 不变:没有 out/in 的泛型接口,
List<T>是不变的,List<Dog>不能赋给List<Animal>。 - 规则:T 既是返回又是参数时(如
IList<T>)不能用 out/in,否则会类型不安全。
最小可运行示例:
class Animal { }
class Dog : Animal { }
// 协变:IEnumerable<out T>,只产 T
IEnumerable<Dog> dogs = new List<Dog>();
IEnumerable<Animal> animals = dogs; // 合法:out 允许派生到基
// 逆变:Action<in T>,只消费 T
Action<Animal> printAnimal = a => Console.WriteLine(a.GetType().Name);
Action<Dog> printDog = printAnimal; // 合法:in 允许基到派生
printDog(new Dog());
// 不变:List<Dog> 不能赋给 List<Animal>(下面这行编译错误)
// List<Animal> bad = new List<Dog>();
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
List<Dog> 赋给 List<Animal> 编译失败 |
List<T> 是不变的 |
改用 IEnumerable<Dog>(协变) |
想给接口加 out 却报错 |
T 同时出现在参数位置 | 拆成只读接口,或放弃 out |
把 Action<Dog> 赋给 Action<Animal> 失败 |
方向反了 | 理解逆变方向,应是 Action<Animal> 赋给 Action<Dog> |
面试考法:高频题是"为什么 List<Dog> 不能当 List<Animal> 用""out 和 in 的区别"。要答出:不变集合不能协变是因为它既能读又能写(写一个 Cat 进 List<Dog> 会破坏类型安全);协变用于只读产出场景,逆变用于只消费场景。
5.2 record、init 与不可变数据
为什么需要它:业务里大量数据是"DTO、事件、值对象",创建后不该变。用 class 手写 Equals、GetHashCode、构造函数样板代码又长又容易错。record 把这些做成了默认。
核心机制:
record默认是引用类型,但相等性按值比较(逐字段);record struct才是值类型记录。- 位置记录
record Point(int X, int Y)自动生成构造函数、解构、Equals、GetHashCode、ToString。 with表达式:基于现有记录复制一份并改部分字段,p with { X = 99 }。init访问器:只允许在对象初始化时赋值(new Point { X = 1 }),之后不可改,比set更严格。- record 与 class 的相等性差异:
new Point(1,2) == new Point(1,2)为 true(按值),class 默认比地址为 false。
最小可运行示例:
// 位置记录:自动生成构造、解构、按值相等
record Point(int X, int Y);
// init:初始化时可设,之后不可改
class Order
{
public string Id { get; init; } = "";
public decimal Amount { get; init; }
}
var p1 = new Point(1, 2);
var p2 = new Point(1, 2);
Console.WriteLine(p1 == p2); // True:record 按值相等
// with:复制并改字段
var p3 = p1 with { X = 99 };
Console.WriteLine(p3); // Point { X = 99, Y = 2 }
Console.WriteLine(p1.X); // 1:原记录不变
var order = new Order { Id = "A1", Amount = 100m };
// order.Amount = 200m; // 编译错误:init 之后不可赋值
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
两个同值 record 用 == 判等却不相等 |
误用了 class 而非 record | 用 record 或重写 Equals |
| record 的字段还能被改 | 用了普通 class 或 record 的可变字段 | 用位置记录 + with,或字段用 init |
record 被当成值类型拷贝 |
忘了 record 默认是引用类型 | 需要值语义时用 record struct |
面试考法:常见问法是"record 和 class 的区别""with 表达式做了什么""init 和 set 的区别"。要答出:record 默认按值相等、自动生成样板代码、不可变;with 复制后改字段;init 只在初始化器赋值。
5.3 模式匹配
为什么需要它:业务分支经常是"按类型、按属性形状解数据"。if-else 又长又漏,模式匹配把它写成声明式、编译器帮你检查是否穷尽。
核心机制:
- 常量模式:
is 42、is "ok"。 - 属性模式:
Order { Status: "Paid", Amount: > 1000 },按字段值匹配。 - 位置模式:配合记录解构,
Point(1, var y)。 - Switch 表达式:
shape switch { Circle c => ..., _ => ... },_是弃元。 when子句:在模式上加额外条件。
最小可运行示例:
record Order(string Status, decimal Amount);
// 用 Switch 表达式 + 属性模式替代 if-else
string Describe(Order o) => o switch
{
{ Status: "Paid", Amount: > 1000 } => "大额已支付",
{ Status: "Paid" } => "普通已支付",
{ Status: "Pending" } => "待支付",
_ => "未知状态"
};
// 类型模式 + 解构
string Shape(object o) => o switch
{
Point(0, 0) => "原点",
Point(var x, var y) when x == y => "对角线",
Point(var x, _) => $"X={x}",
_ => "其他"
};
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| Switch 表达式漏了分支却没报错 | 没有 _ 弃元 |
加 _ => 兜底,或让编译器检查穷尽性 |
when 条件写得太复杂 |
模式里塞业务逻辑 | 简单条件用属性模式,复杂判断抽方法 |
面试考法:常见问法是"模式匹配相比 if-else 的好处""Switch 表达式的 _ 是什么"。要答出:声明式、编译器检查穷尽、解构成更清晰;_ 是弃元表示兜底分支。
5.4 扩展方法与迭代器 yield
为什么需要它:扩展方法让你给"没有源码的类型"(如 string、IEnumerable<T>)追加方法,像挂在原类型上;迭代器 yield 让你写一个"按需产出"的序列,不用手动实现枚举器状态机。
核心机制:
- 扩展方法:定义在静态类里,第一个参数用
this修饰,调用时像实例方法。 - 迭代器:
yield return每次产出一个元素,方法被编译器改写成状态机;惰性——枚举时才走到下一个yield return。 yield break提前结束序列。
最小可运行示例:
public static class StringExtensions
{
// 扩展方法:给 string 加一个 ToWords()
public static IEnumerable<string> ToWords(this string text)
=> text.Split(' ', StringSplitOptions.RemoveEmptyEntries);
}
// 迭代器:惰性产出,不会一次性加载全部
static IEnumerable<int> Fibonacci(int count)
{
int a = 0, b = 1;
for (int i = 0; i < count; i++)
{
yield return a; // 每枚举一次才走到这里
(a, b) = (b, a + b);
}
}
// 使用扩展方法
string text = "the quick brown fox";
foreach (var w in text.ToWords()) Console.WriteLine(w);
// 使用迭代器:按需产出,不取全部就不算
foreach (var n in Fibonacci(10)) Console.Write($"{n} ");
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 迭代器方法在调用时不执行 | yield 方法是惰性的,枚举时才跑 |
需要立即执行就 ToList() |
| 扩展方法没出现 | 没在 using 里引入扩展方法所在命名空间 | using 静态类所在命名空间 |
| 循环里反复枚举迭代器,副作用重复 | 每次枚举都重跑迭代器 | 立即 ToList() 固化 |
面试考法:常见问法是"扩展方法的本质是什么""yield 是立即执行吗"。要答出:扩展方法是静态方法的语法糖,编译期按第一个参数类型绑定;yield 迭代器惰性,枚举时才推进状态机。
5.5 异步 async/await、Task 与 ValueTask
为什么需要它:Web API、数据库、HTTP 调用全是 IO 密集场景。用同步阻塞(.Result、.Wait())会吃掉线程池,导致并发上不去。async/await 是 .NET 的异步标配,但它的状态机模型必须讲清。
核心机制:
async方法被编译器改写成状态机:遇到await时,如果任务没完成,就把方法挂起(不占线程),注册一个"完成后继续"的回调;任务完成后由线程池取出后续代码执行。Task:表示一个未来的值,引用类型,每次都在堆上分配。ValueTask:值类型,可包装已完成的结果,避免分配;适合高频调用且结果常常已就绪的场景(如缓存命中)。ConfigureAwait(false):在类库中使用,告诉框架"完成后不需要回到原上下文",减少死锁与上下文切换;在应用(UI、ASP.NET Core)中一般不写。- 不要用
.Result/.Wait()——它们会阻塞线程,在有同步上下文的场景下容易造成死锁。
最小可运行示例:
// 异步方法:遇到 await 挂起,不占线程
async Task<string> FetchDataAsync(int id)
{
// 模拟 IO:这里挂起 1 秒,不阻塞任何线程
await Task.Delay(1000);
return $"data-{id}"; // 任务完成后恢复执行
}
// 并行调用多个任务
async Task RunAsync()
{
// 并行启动,再一起 await,总耗时约 1 秒而非 3 秒
var t1 = FetchDataAsync(1);
var t2 = FetchDataAsync(2);
var t3 = FetchDataAsync(3);
await Task.WhenAll(t1, t2, t3);
Console.WriteLine(t1.Result);
}
// 类库中用 ConfigureAwait(false)
async Task DoLibraryAsync()
{
await Task.Delay(100).ConfigureAwait(false);
// 这里不需要回到原上下文
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
用 .Result 导致线程池饥饿或死锁 |
同步阻塞等待异步任务 | 改用 await,一路异步到顶层 |
await 之后执行变慢、上下文切换频繁 |
库代码没写 ConfigureAwait(false) |
类库中加 ConfigureAwait(false) |
| 异步方法里抛的异常在调用方丢失 | 没 await 直接 fire-and-forget | 必须 await,或用 try/catch 包在异步方法内 |
| 高频异步方法分配过多 Task | 每次都 new Task | 高频已就绪场景用 ValueTask |
面试考法:高频题是"await 会不会新开线程""Task 和 ValueTask 的区别""什么时候用 ConfigureAwait(false)"。要答出:await 不开线程,是状态机挂起 + 回调恢复;Task 是引用类型有堆分配,ValueTask 是值类型零分配;类库用 ConfigureAwait(false) 避免依赖上下文与死锁。
5.6 Span、Memory 与零分配
为什么需要它:处理一段字节、数组切片、字符串子串时,传统做法是 ToArray()、Substring() 复制出新数组,高频路径下产生大量垃圾。Span<T> 是一段连续内存的"视图",不拥有数据,切片不复制。
核心机制:
Span<T>:ref struct,指向一段连续内存(数组、stackalloc、原生内存),是"视图",不复制。stackalloc:在栈上分配内存,方法结束自动回收,不进 GC,适合小而临时的缓冲。Span<T>的限制:因为是 ref struct,不能被装箱、不能作为类的实例字段、不能跨 await、不能被闭包捕获——这正是它"短期、栈上"的原因。Memory<T>:是Span<T>的"可长期持有"版本(包装了数组或内存管理器),可跨 await。
最小可运行示例:
// 用 Span 处理字节切片,不复制数组
byte[] buffer = { 0x01, 0x02, 0x03, 0x04, 0x05 };
// 切片是视图,不是新数组
Span<byte> slice = buffer.AsSpan(1, 3); // 指向 buffer[1..3]
slice[0] = 0xFF;
Console.WriteLine(buffer[1]); // 255:直接改了原数组
// stackalloc:在栈上分配临时缓冲,不进 GC
Span<int> numbers = stackalloc int[4];
for (int i = 0; i < numbers.Length; i++) numbers[i] = i * 10;
// numbers 不能存进类字段,也不能跨 await——ref struct 限制
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
把 Span<T> 存进类字段编译报错 |
ref struct 不能做长期字段 | 改用 Memory<T> |
| 在 async 方法里用 Span 报错 | ref struct 不能跨 await | 改用 Memory<T> |
| 以为 Span 切片复制了数组 | Span 是视图 | 需要独立副本时用 ToArray() |
面试考法:高频题是"Span
5.7 表达式树与 IEnumerable/IQueryable
为什么需要它:LINQ 查询什么时候在内存跑、什么时候翻译成 SQL?这取决于 IEnumerable 还是 IQueryable。不理解边界,就会写出"先把全表拉回内存再过滤"的灾难。
核心机制:
IEnumerable<T>:迭代器接口,查询在内存里逐个枚举执行。IQueryable<T>:带表达式树,查询会被 provider(如 EF Core)翻译成 SQL 发到数据库执行。Expression<Func<T,bool>>:把 lambda 表达式表示成数据结构(树),provider 遍历它生成 SQL;而Func<T,bool>是已编译的委托,无法翻译。- 边界:对
IQueryable的过滤要在"枚举之前"做完;一旦ToList()就拉回内存,后续Where都在内存跑。
最小可运行示例:
// IEnumerable:内存枚举
List<int> inMemory = new() { 1, 2, 3 };
var r1 = inMemory.Where(x => x > 1); // 在内存过滤
// IQueryable:带表达式树,可被翻译成 SQL
// var users = dbContext.Users.Where(u => u.Age > 18);
// 上面这句在数据库执行:SELECT * FROM Users WHERE Age > 18
// 如果先 ToList() 再 Where:就把全表拉回内存再过滤——性能灾难
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 查询把全表拉回内存再过滤 | 先 ToList() 再 Where |
把过滤条件放在 IQueryable 上,枚举前做完 |
IQueryable 翻译失败报"could not be translated" |
用了 SQL 不支持的方法 | 改为在内存里 AsEnumerable() 后再过滤 |
对 List<T> 调 .AsQueryable() 以为能翻译 |
内存集合没有翻译 provider | 理解它仍是内存枚举 |
面试考法:高频题是"IEnumerable 和 IQueryable 的区别""表达式树是什么"。要答出:IEnumerable 内存枚举,IQueryable 带表达式树可翻译成 SQL;过滤要在枚举前完成,否则全表拉回内存。
六、分层练习
三档练习逐档升级,上一档没做完不要跳。
6.1 复现型(照着做,目标是跑通 + 能解释)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 协变/逆变实验 | 写 IEnumerable<Dog> 与 Action<Animal> 转换 |
编译通过,能说清方向 | 1 小时 |
| record 相等性 | 两个同值 record 用 == 判等 |
结果为 true,并能解释 | 1 小时 |
| with 表达式 | 基于 record 复制并改字段 | 原记录不变,新记录字段正确 | 0.5 小时 |
| 模式匹配重写 | 把 if-else 链改成 Switch 表达式 | 分支穷尽,有 _ 兜底 |
1.5 小时 |
| 异步并行 | 用 Task.WhenAll 并行三个延迟任务 |
总耗时约 1 秒 | 1.5 小时 |
6.2 改造型(给出现成代码,改出正确行为)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 把同步阻塞改异步 | 给定 .Result,改成 await |
一路异步,无死锁 | 1.5 小时 |
| 消除数组切片复制 | 给定 ToArray() 切片,改用 Span<T> |
无额外数组分配 | 1.5 小时 |
| 把 if-else 改成模式匹配 | 给定类型分支,改成属性模式 | 代码更短且穷尽 | 1.5 小时 |
| 把可变 class 改成 record | 给定 DTO,改成位置记录 | 按值相等,with 可用 | 1 小时 |
| 修正 IQueryable 边界 | 给定先 ToList 后 Where,改到枚举前过滤 | 查询在数据库执行 | 1.5 小时 |
6.3 设计型(自己定方案,目标是能交付、能讲清取舍)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 异步批量调用工具 | 并发调用 N 个接口,控制并发度,带超时 | 总耗时接近并行上限;超时被捕获 | 5 小时 |
| 不可变事件模型 | 用 record 定义领域事件,with 演进状态 | 事件不可变,状态通过 with 演进 | 4 小时 |
| 零分配字节处理器 | 用 Span/stackalloc 解析协议头 | 高频路径无数组分配 | 4 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
List<Dog> 不能赋给 List<Animal> |
不变集合不能协变 | 看接口是否带 out | 改用 IEnumerable<Dog> |
| 两个同值 record 判等为 false | 误用 class | 确认是否 record | 用 record 或重写 Equals |
init 之后赋值报错 |
初始化器外不可改 | 看赋值位置 | 用 with 复制新实例 |
.Result 卡住或死锁 |
同步阻塞异步任务 | 看是否在 UI/请求上下文 | 改用 await |
| 异步异常丢失 | fire-and-forget 没 await | 看是否 await | 必须 await,或内部 try/catch |
| Span 存字段报错 | ref struct 不能长期持有 | 看声明位置 | 改用 Memory<T> |
| 查询把全表拉回内存 | 先 ToList 后 Where | 看过滤位置 | 把过滤放 IQueryable 上 |
| 模式匹配漏分支 | 没有 _ 兜底 |
检查 switch | 加 _ => 或让编译器检查穷尽 |
八、出口条件
全部勾选后再进入 阶段 3 CLR、运行时与并发基础。
- [ ] 能解释协变/逆变方向,判断
List<Dog>为何不能直接当List<Animal> - [ ] 能用 record + with 表达不可变数据,说明它与 class 的相等性差异
- [ ] 能用模式匹配重写 if-else 分支,知道
_是弃元 - [ ] 能解释
await不新开线程,能区分Task与ValueTask - [ ] 能说清
ConfigureAwait(false)用在库还是应用 - [ ] 能用 Span 处理字节切片,说明它为什么不能当字段、不能跨 await
- [ ] 能说清
IEnumerable与IQueryable的边界,避免全表拉回内存 - [ ] 排障表里的八个现象,随机抽三个能在 5 分钟内给出排查路径
自测题(先自己想,再看要点):
await Task.Delay(1000)会新开一个线程吗?- 要点:不会。它是状态机挂起 + 回调恢复,期间不占用线程。
Task与ValueTask的取舍?- 要点:Task 是引用类型有堆分配;ValueTask 是值类型零分配,适合高频且结果常已就绪(缓存命中)的场景。
- 为什么
List<Dog>不能赋给List<Animal>?- 要点:List 是不变集合,既能读又能写;若允许协变,往
List<Dog>里塞Cat会破坏类型安全。
- 要点:List 是不变集合,既能读又能写;若允许协变,往
record默认按值相等,那new Point(1,2) == new Point(1,2)结果是什么?- 要点:true。record 逐字段比较;而普通 class 默认比地址为 false。
Span<T>为什么不能存进类字段?- 要点:它是 ref struct,只能短期栈上存在,不能被装箱或长期持有;需要长期持有用
Memory<T>。
- 要点:它是 ref struct,只能短期栈上存在,不能被装箱或长期持有;需要长期持有用
IQueryable与IEnumerable的过滤位置有何讲究?- 要点:IQueryable 过滤要在枚举前完成(翻译成 SQL);一旦 ToList 拉回内存,后续过滤都在内存跑,会全表加载。
- 什么时候在类库代码里写
ConfigureAwait(false)?- 要点:类库不依赖调用方上下文,写它避免死锁与上下文切换;应用(UI、ASP.NET Core)通常不写。