一个统计页面白天看是 12 条,晚上再看变成 11 条,重启程序又恢复。查日志发现同一个查询在数据库里被执行了两次,两次之间刚好有一条数据被另一个操作删掉了。写查询的同事很委屈:代码里明明只写了一遍 Where,怎么会有两次?
原因在于 LINQ 的查询默认不是立刻执行的,它只是一段「还没跑的说明」。你拿着这段说明遍历一次,它才去查一次;遍历两次,它就查两次。中间数据变了,两次结果自然不一样。这个特性叫延迟执行,它既是 LINQ 省事的地方,也是很多奇怪问题的源头。
这一篇讲 C# 里几个用得非常多的语言特性:LINQ 的延迟执行与多次枚举、模式匹配的判断顺序、record 的相等性、自动属性和 init,以及闭包捕获循环变量。每个特性都从「它到底在什么时候做什么」入手,不只讲语法。示例在本机 .NET 8 控制台项目里跑过,输出照实贴出。
先复现那个「查询跑了两次」的场景
把问题缩小成一个列表。创建一个查询变量,先不遍历,往原列表里加一个元素,最后才遍历查询:
using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
static void Main()
{
var nums = new List<int> { 1, 2, 3 };
var q = nums.Where(n => n > 1);
nums.Add(4);
Console.WriteLine("deferred: " + string.Join(",", q.ToArray()));
}
}
本机运行结果:
dotnet run
deferred: 2,3,4
查询变量 q 定义的时候只有 1、2、3,真正遍历时列表已经变成 1、2、3、4,结果里就多了一个 4。这说明 Where 没有在定义时把数据筛出来,它只是把「怎么筛」记录了下来,等 ToArray 或 foreach 触发时才去读原集合。
如果这个 nums 不是内存里的列表,而是一个数据库查询、一个文件流、一个网络接口,那么「定义查询」和「遍历查询」之间隔了多久,中间数据变了多少,结果就可能差多少。更麻烦的是,遍历两次就会产生两次真实请求,日志、性能、计费都会翻倍。
从类型上看,Where 返回的是一个 IEnumerable<T>。这个接口只承诺「可以被逐个读取」,没承诺数据已经准备好。你可以把它理解成一张取货单,不是货架上的货。只有调用 GetEnumerator 开始逐个读取时,背后的数据源才真正被访问。C# 的 foreach、ToList、Count、First 都会触发这个过程。
延迟执行到底省了什么,又坑在哪
延迟执行的设计初衷是组合。你可以一层一层往上叠 Where、Select、OrderBy,每叠一层都不产生新集合,直到最后需要结果时才一次性算完。这样写起来像在描述需求,而不是在指挥循环。
省掉的是中间集合。如果没有延迟执行,每叠一个 Where 都要产生一个新列表,数据量大时内存和复制成本很高。延迟执行让这些步骤合并成一次遍历,边读边筛边投影,中间不落地。
坑也在这里:查询对象不是结果,它是一段可重复执行的逻辑。下面几种写法都会让同一段逻辑跑多次:先用 Any() 判断有没有数据,再用 foreach 遍历;先 Count() 再 First();把同一个查询变量传给两个方法,每个方法内部各遍历一次。对内存列表来说只是多跑一遍循环,对数据库或网络接口来说就是多一次请求。
Any、Count、First 这类立即执行操作。看一个更典型的写法:
var q = nums.Where(n => n > 1);
Console.WriteLine(q.Count()); // 第一次遍历
Console.WriteLine(q.First()); // 第二次遍历
Count() 要把所有元素数一遍,First() 又要从头开始读一遍。对内存列表只是多跑一轮,对数据库就是两条 SQL。很多人以为 Count() 是读缓存,其实它照样会触发查询。把这两行改成先 var list = q.ToList();,后面用 list.Count 和 list[0],就只剩一次读取。
解决办法不是「永远不用 LINQ」,而是明确在哪个位置把结果固定下来。需要多次使用时,在源头调用 ToList() 或 ToArray() 物化一次;只需要遍历一次时,保持延迟执行反而更省内存。关键是知道自己在做哪一种。
record 看起来像 class,相等性却不一样
record 是 C# 9 引入的一种类型声明方式,主要用来表示「一组数据」。编译器会自动给它生成构造器、属性、Equals、GetHashCode 和 ToString。最直接的差别是:两个字段相同的 record 实例,用 == 比较会得到 true;两个字段相同的普通 class 实例,默认得到 false。
普通 class
默认按引用比较。除非你手动重写 Equals 和 GetHashCode,否则两个 new 出来的对象永远不相等。适合有身份、有生命周期、需要被共享修改的对象。
record
按字段内容比较。适合数据传输对象、查询结果、配置快照这类「内容即身份」的数据。它默认不可变,修改要生成新对象,正好配合值相等的语义。
record Person(string Name, int Age);
record Bad(string Name, List<int> Scores);
class Program
{
static void Main()
{
var p1 = new Person("A", 20);
var p2 = new Person("A", 20);
Console.WriteLine($"record == : {p1 == p2}");
var b1 = new Bad("A", new List<int> { 1 });
var b2 = new Bad("A", new List<int> { 1 });
Console.WriteLine($"record list == : {b1 == b2}");
}
}
本机输出:
record == : True
record list == : False
第二个结果很容易让人困惑:两个 record 的 Name 都是 A,Scores 里也都是一个 1,为什么不相等?因为 record 自动生成的相等比较是逐字段调用 Equals,而 List<int> 的 Equals 还是引用比较。两个不同的 List 实例,哪怕内容一样,也不相等。
这就是 record 最常见的坑:字段里放了可变引用类型,值相等的承诺就断了。要修,要么把字段换成不可变类型、数组换成元组或专门的不可变集合,要么自己重写 Equals。仅仅把类改成 record,不会自动帮你比较集合内容。
record 还有一个常见用法是 with 表达式,用来在保留大部分字段的前提下生成一个新对象:
var p3 = p1 with { Age = 21 };
Console.WriteLine(p3); // Person { Name = A, Age = 21 }
p1 本身没有被修改,p3 是新的实例。如果字段里还有引用类型,with 只复制引用,新旧对象会共享同一个列表。这种「浅复制」在配置合并、事件传递里很方便,但要清楚共享的那部分仍然会互相影响。
模式匹配:判断顺序就是优先级
模式匹配让你在 if 和 switch 里直接检查类型和结构,不用先转型再判断。常见写法有类型模式 is int n、属性模式 is Person { Age: > 18 }、常量模式和解构模式。
最容易出错的是顺序。模式是从上往下匹配的,第一个匹配成功的分支会吃掉后面所有可能。比如先写 is object 再写 is string,字符串永远进不了第二个分支,因为所有字符串都满足 object。编译器有时会给警告,有时不会,尤其是用了 when 条件之后。
object boxed = 42;
if (boxed is int num) Console.WriteLine($"pattern int: {num}");
if (boxed is string text && text.Length > 0) Console.WriteLine("string");
else Console.WriteLine("string branch skipped");
输出是 pattern int: 42 和 string branch skipped。这里的 is int num 同时完成了类型检查和赋值,num 在 if 体内就是 int,不需要再强转。注意模式变量只在匹配成功的分支里有效,出了分支就不能用了。
属性模式适合做数据校验,比如 if (order is { Total: > 0, Status: "paid" })。它读起来接近自然语言,但嵌套太深时可读性会迅速下降。判断条件复杂到需要写注释解释顺序时,老实写成几个布尔变量更清楚。
switch 表达式可以把多分支判断写成一个返回值,适合把「输入状态、输出字符串」这类映射收在一处:
static string Describe(int score) => score switch
{
>= 90 => "优秀",
>= 60 => "及格",
_ => "不及格"
};
这里的 _ 是兜底模式,必须放在最后。分支仍然从上往下匹配,所以写 >= 60 一定要放在 >= 90 后面,否则 95 分会先命中「及格」。switch 表达式要求每个分支返回同一种类型,并且编译器会尽量检查是否覆盖了所有情况。
自动属性与 init:少写样板,但别以为什么都能改
自动属性把「字段加 get/set 方法」压缩成一行:public string Name { get; set; }。编译器会在背后生成一个私有字段,外部通过属性访问。它省掉了手写 getter/setter 的样板代码,但不会改变封装原则,该私有化的东西还是要私有化。
C# 6 之后还可以只写 get,表示只读属性,值只能在构造器里赋。C# 9 加了 init,表示「对象初始化时能赋值,之后不能改」:
class Config
{
public string Name { get; init; } = "";
public int Retry { get; init; } = 3;
}
class Program
{
static void Main()
{
var c = new Config { Name = "api" };
// c.Name = "other"; // 编译错误:init-only 属性不能在初始化后赋值
}
}
init 的价值是让对象在创建完成后进入不可变状态,同时保留对象初始化器的写法。它比全用构造器参数灵活,尤其是参数多、很多都有默认值的时候。但它不是深不可变:属性如果是 List,你仍然可以往列表里加元素,只是不能把属性指向另一个列表。
自动属性并不是完全没有逻辑。需要校验时,可以写成带方法体的属性,在 set 里检查参数:
class Config
{
private int _retry = 3;
public int Retry
{
get => _retry;
set
{
if (value < 0) throw new ArgumentOutOfRangeException(nameof(value));
_retry = value;
}
}
}
这样写比在构造器里校验更可靠,因为任何赋值路径都会经过 set。代价是代码变长,而且属性里做重活会让调用方难以察觉。属性应该像字段一样轻,复杂逻辑放到方法里。
另一个细节是 with 表达式。record 和部分结构体支持 with,它会复制原对象并修改指定属性,生成一个新实例。原对象不变,这正好符合值语义。对普通 class 默认不支持 with,除非自己实现。
闭包捕获:循环变量为什么会「记住最后一个值」
闭包是指 lambda 或匿名方法引用了外部的局部变量。编译器会把这些变量「提升」到一个隐藏对象里,让 lambda 能活过当前方法。被捕获的是变量本身,不是变量当时的值。理解这一点,才能解释下面两种循环的差别。
var fns = new List<Func<int>>();
for (int idx = 0; idx < 3; idx++) fns.Add(() => idx);
Console.WriteLine("closure(for): " + string.Join(",", fns.Select(f => f())));
var fns2 = new List<Func<int>>();
foreach (var item in new[] { 0, 1, 2 }) fns2.Add(() => item);
Console.WriteLine("closure(foreach): " + string.Join(",", fns2.Select(f => f())));
本机输出:
closure(for): 3,3,3
closure(foreach): 0,1,2
for 循环里的 idx 在整个循环中只有一个变量,三个 lambda 捕获的是同一个变量。循环结束后 idx 变成 3,所以三个委托调用都返回 3。foreach 在 C# 5 之后每次迭代都会创建一个新的迭代变量,三个 lambda 捕获的是三个不同的变量,所以输出 0、1、2。
如果确实需要在 for 循环里捕获每一轮的值,就在循环体内部复制一份:var copy = idx; 然后让 lambda 捕获 copy。这个写法在异步代码里同样重要,循环里启动多个任务时,捕获错了变量会让所有任务用同一个参数。
看一个异步版本的例子:
var tasks = new List<Task>();
for (int i = 0; i < 3; i++)
tasks.Add(Task.Run(() => Console.WriteLine($"worker {i}")));
await Task.WhenAll(tasks);
三个任务打印出来的可能全是 worker 3,因为它们捕获的是同一个 i,真正执行时循环已经结束。把 Task.Run 那一行改成先 var id = i; 再在 lambda 里用 id,才能每个任务拿到自己的编号。这个问题在压测和并发任务里很常见,输出看起来像「参数传错了」,其实是闭包捕获错了变量。
这些特性在真实项目里会怎么出问题
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 同一个查询在日志里出现两次 | 延迟查询被遍历了两次,或先 Any 再 foreach | 在查询定义处加 ToList() 物化,再看日志次数 |
| 第二次遍历结果比第一次少 | 两次遍历之间数据源被修改,延迟查询读到了新状态 | 确认查询对象和遍历点之间有没有写操作 |
| 遍历时抛集合已修改异常 | 延迟执行把修改推迟到遍历时才暴露 | 先把结果 ToList(),再遍历副本 |
| 同内容的两个 record 判为不相等 | 字段里有 List 等引用类型,比较退化成引用比较 | 检查 record 字段类型,换成不可变集合或重写相等逻辑 |
| 模式匹配走了意料之外的分支 | 宽泛模式写在前面,把后面的精确模式挡住了 | 按窄到宽调整顺序,检查 when 条件 |
| 给 init 属性再次赋值编译失败 | init-only 属性只允许在对象初始化时赋值 | 改用构造器参数、with 表达式,或把属性改成 set |
| 循环里创建的回调都用同一个参数 | 闭包捕获了共享的循环变量 | 在循环体内复制变量后再捕获 |
| 查询链看起来很短,内存却很高 | 延迟执行不减少原始集合,物化时又生成一份新集合 | 确认数据源大小,评估是否该分页或流式处理 |
这张表里的问题有一个共同点:代码本身都能编译,语法也没错,错的是对「什么时候执行」和「比较什么」的理解。C# 的特性越方便,越需要知道它背后替你做了什么。
边界与代价
这些特性不是越多越好,每一种都有适用边界:
- LINQ 适合表达「做什么」,不适合替代所有循环:简单的遍历、需要索引、需要提前 break 的场景,普通 for 或 foreach 更直接。把五层 LINQ 嵌套写成一行,调试时很难看出中间结果。
- 延迟执行让生命周期变得模糊:查询对象持有数据源的引用,数据源可能因此活得比预期久。长生命周期的查询对象还可能读到已经变化的数据,必要时早点物化。
- record 的相等性依赖字段类型:字段全是不可变值类型或 string 时最可靠。字段里有集合、数组、可变对象时,要么自己实现相等,要么不要依赖自动生成的比较。
- 模式匹配的顺序是隐式契约:调整分支顺序可能改变行为,而且编译器不一定提醒。分支超过四五个时,考虑用多态或字典分派。
- init 和不可变只到第一层:属性不能重新指向别的对象,不代表对象内部的内容不能改。真正的不可变需要每一层都不可变。
- 闭包会延长变量生命周期:被捕获的变量从栈上的局部变量变成堆上的对象字段,量大时有分配开销,也会让大对象无法及时回收。
性能上也要有基本判断:LINQ 的每一层都会带来一点委托调用和迭代器开销,在热路径里可能明显,但大多数业务代码里不是瓶颈。不要因为「LINQ 慢」就全部改回手写循环,先用测量确认瓶颈在哪,再决定要不要优化。
当天能自己验证的练习
下面的练习都在一个控制台项目里完成,改完 Program.cs 后执行 dotnet run 看结果:
- 定义
var q = nums.Where(n => n > 1),在遍历前给nums加一个元素,确认输出包含新元素;然后在定义后立刻ToList(),再改原列表,确认输出不再变化。 - 用
Stopwatch包住两次对同一个查询的遍历,在查询里加一句计数输出,观察它被实际执行了几次。 - 写两个字段相同的 record,其中一个字段是
List<int>,分别用==和逐字段比较,记录差异;再把它改成元组字段,重新比较。 - 写一个
object变量分别装 int 和 string,用两个if加is判断,调换判断顺序,观察哪个分支被跳过。 - 用
for和foreach各创建三个 lambda,把它们存进列表后统一调用,记录两组输出,再在循环内复制变量修复for的那一组。
小结
三句话收一下:LINQ 默认延迟执行,查询对象是逻辑不是结果,遍历几次就执行几次;record 的相等性按字段走,字段里有可变引用类型时值相等会失效;模式匹配看顺序,闭包捕获的是变量本身,循环里要捕获当轮的值就得先复制。
这些特性处理的是「数据怎么筛、怎么比、怎么装」。接下来要把数据真正放进容器里:List、Dictionary、HashSet 各自适合什么场景,容量怎么增长,字符串怎么拼接才不爆内存。下一篇从一次「循环里加字符串把内存撑爆」的线上问题讲起。