一个统计页面白天看是 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,每叠一层都不产生新集合,直到最后需要结果时才一次性算完。这样写起来像在描述需求,而不是在指挥循环。

LINQ 查询从定义到出结果
拿到数据源
叠加 Where 等方法
得到一个查询对象
foreach 或 ToList 触发
真正读取数据源
输出结果

省掉的是中间集合。如果没有延迟执行,每叠一个 Where 都要产生一个新列表,数据量大时内存和复制成本很高。延迟执行让这些步骤合并成一次遍历,边读边筛边投影,中间不落地。

坑也在这里:查询对象不是结果,它是一段可重复执行的逻辑。下面几种写法都会让同一段逻辑跑多次:先用 Any() 判断有没有数据,再用 foreach 遍历;先 Count() 再 First();把同一个查询变量传给两个方法,每个方法内部各遍历一次。对内存列表来说只是多跑一遍循环,对数据库或网络接口来说就是多一次请求。

在循环里反复遍历同一个延迟查询,复杂度很容易从一次变成多次。如果查询背后是数据库,最坏情况下每个外层元素都触发一次查询,这就是常说的 N+1 问题。排查时先看循环体里有没有对查询变量做 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 看结果:

  1. 定义 var q = nums.Where(n => n > 1),在遍历前给 nums 加一个元素,确认输出包含新元素;然后在定义后立刻 ToList(),再改原列表,确认输出不再变化。
  2. 用 Stopwatch 包住两次对同一个查询的遍历,在查询里加一句计数输出,观察它被实际执行了几次。
  3. 写两个字段相同的 record,其中一个字段是 List<int>,分别用 == 和逐字段比较,记录差异;再把它改成元组字段,重新比较。
  4. 写一个 object 变量分别装 int 和 string,用两个 if 加 is 判断,调换判断顺序,观察哪个分支被跳过。
  5. 用 for 和 foreach 各创建三个 lambda,把它们存进列表后统一调用,记录两组输出,再在循环内复制变量修复 for 的那一组。

小结

三句话收一下:LINQ 默认延迟执行,查询对象是逻辑不是结果,遍历几次就执行几次;record 的相等性按字段走,字段里有可变引用类型时值相等会失效;模式匹配看顺序,闭包捕获的是变量本身,循环里要捕获当轮的值就得先复制。

这些特性处理的是「数据怎么筛、怎么比、怎么装」。接下来要把数据真正放进容器里:List、Dictionary、HashSet 各自适合什么场景,容量怎么增长,字符串怎么拼接才不爆内存。下一篇从一次「循环里加字符串把内存撑爆」的线上问题讲起。