LINQ

是什么，为什么存在

LINQ 是语言集成查询（Language Integrated Query）的缩写。它提供一组通用查询模式，让 C# 代码以静态类型检查的方式筛选、转换、连接、分组和汇总数据。查询的每一步仍是普通表达式，编译器可以检查属性名称、Lambda 参数类型和结果类型。

你最常遇到的是 LINQ to Objects。System.Linq.Enumerable 中的扩展方法接收 IEnumerable<T>，通过委托在当前进程中处理数组、列表和其他可枚举源。Where 保留符合条件的元素，Select 改变每个元素的形状，OrderBy 建立顺序，GroupBy 按键形成分组。

LINQ 也可以描述远程查询。System.Linq.Queryable 上的运算符接收表达式树，由 IQueryable<T> 的 查询提供程序（query provider） 解释或翻译。数据库只是其中一种可能的数据源；可用操作与执行语义由具体提供程序决定。

LINQ 解决的是查询组合问题，不是把任何循环都压成一行。短小、无副作用的数据转换通常适合管道；包含复杂状态转换、逐项异常恢复或多处分支时，普通循环往往更直接。选择依据应是行为是否清楚，而不是字符数。

查询语法与方法语法属于同一个 LINQ 模型。查询语法提供 from、where、orderby、join、group 和 select 等子句，编译器会把它们转换为方法调用。方法语法可以直接使用全部标准查询运算符，两种写法也可以在同一表达式中组合。

工作原理

管道保存操作，不一定保存结果

调用 Where 或 Select 时，通常会取得一个表示查询步骤的对象，而不是已经填好的结果集合。真正请求元素时，查询才从源头拉取数据，并按顺序应用每个运算符。这就是延迟执行；它让调用方先组合查询，再决定何时以及消费多少结果。

下面的流程表示一个 LINQ to Objects 管道首次被 foreach 消费时的拉取关系。消费者每请求一个元素，管道就向上游寻找下一个符合条件的值。

foreach、ToList、Count、First 和 Sum 都会要求结果，因此会触发相应查询执行。它们的消费方式不同：First 可以在找到元素后停止，Count 通常需要确定整个结果的数量，ToList 则把所有结果保存进新列表。不要把「触发执行」误解成所有操作都一定建立集合。

流式步骤与缓冲步骤

Where 和 Select 可以逐个处理并产出元素。Take 达到数量后可以停止读取上游，Any 找到第一个匹配项后也可以返回。这样的操作适合短路，但仍取决于上游是否也能逐步产生值。

OrderBy 必须先取得全部输入，才能知道第一个排序结果。GroupBy 也需要读取源并建立分组。它们仍可以延迟到开始枚举时才工作，但开始之后会缓冲数据；「延迟」与「逐项流式」是两项不同属性。

物化（materialization） 把查询结果写入具体容器。它固定容器成员，允许之后重复读取而不重跑上游查询，但不会递归复制元素对象。源和结果若引用同一个可变对象，修改该对象仍可从两边观察到。

查询语法经过编译器转换

查询表达式必须从 from 开始，并以 select 或 group 结束。编译器按照语言规则把子句转换成 Where、Select、OrderBy、Join 或 GroupJoin 等调用。查询语法本身不是另一套运行时查询引擎，也不会因为像 SQL 就自动远程执行。

let 子句为后续子句引入计算结果，多个排序键则映射到首个排序加后续排序。查询语法没有覆盖每个标准运算符，例如常见的 Take 与 Distinct 通常仍以方法调用追加。涉及多个范围变量或连接时，查询语法常更易读；普通筛选与投影通常用方法链更紧凑。

泛型类型连接每一步

一个 IEnumerable<Product> 经过 Where 后仍产生 Product。Select(product => product.Name) 把元素类型变为 string，因此下一步接收 string。匿名类型、记录和元组都可以作为中间投影，只要它们的生命周期不越过不适合暴露这些类型的 API 边界。

Lambda 的目标签名由运算符推断。Enumerable.Where 需要 Func<T, bool>，因此谓词必须返回布尔值；SelectMany 的选择器返回嵌套序列，并把这些序列展平成一个结果序列。编译期类型关系能阻止许多形状错误，却不能判断业务谓词是否筛错字段。

结果基数属于契约

First 表示至少要有一个元素，但允许更多元素；空结果会抛出 InvalidOperationException。Single 同时要求恰好一个元素，空结果或多个结果都会抛出。带 OrDefault 的版本只把「没有元素」变为默认值，不会让 SingleOrDefault 接受多个元素。

默认值可能是合法数据。对 IEnumerable<int> 调用 FirstOrDefault 得到 0 时，调用方无法仅凭返回值区分「首项是零」与「没有首项」。若这一区别属于业务契约，可使用单遍 TryGet 风格辅助方法、投影成可空值，或返回能表达存在性的领域结果。

聚合也各有空序列规则。Count 与整数 Sum 可以返回零，而 Average、Min 和 Max 对许多非可空数值序列会因没有元素而抛出。不要凭运算符名称猜测边界行为；让空、单项和多项输入进入测试。

Enumerable 与 Queryable 是执行边界

Enumerable 运算符接收委托并执行普通 .NET 代码。Queryable 运算符接收 表达式树（expression tree） ，把查询描述交给提供程序。相同的 Lambda 源码会因接收方静态类型不同而成为委托或表达式树。

AsEnumerable 本身不会物化数据。它把后续扩展方法绑定到 Enumerable，因此后续谓词在当前进程中运行；ToList 才会立即枚举并保存结果。对远程源过早调用这两个方法，影响不同，但都可能改变哪些工作由远端完成。

提供程序不需要支持所有合法 C# 表达式。一个委托在数组上运行正确，不代表相同结构能翻译成目标查询语言。远程查询必须用真实提供程序验证翻译结果、参数化、空值语义、排序和往返次数；List<T>.AsQueryable() 只能证明内存执行路径。

示例

下面四个示例使用库存与订单数据，依次展示筛选投影、延迟执行、展平分组和查询语法连接。它们均由 .NET SDK 10.0.400 编译并运行，输出来自实际进程。

筛选、排序并投影

第一个管道保留有库存且价格不低于 100m 的商品，先按价格降序，再按名称升序。最后只投影输出所需的两个字段。

Where 不改变元素类型，Select 则把 Product 投影成匿名类型。ThenBy 在价格相同时提供确定的次级顺序；若再调用一次 OrderBy，新的主排序会取代旧的主排序。

这个查询直到 foreach 才执行。循环只读取结果，没有修改源或执行外部副作用，因此执行时机清楚。若调用方需要在之后看到完全相同的成员，应在约定的边界调用 ToArray 或 ToList。

对比延迟查询与物化快照

下面先定义查询并立即取得数组快照，随后修改源列表。再次枚举原查询会看到新订单，而数组仍保留物化时的成员。

using System;
using System.Collections.Generic;
using System.Linq;

var orders = new List<Order>
{
    new("A-100", 20m),
    new("B-200", 75m)
};

IEnumerable<string> largeOrderIds = orders
    .Where(order => order.Total >= 50m)
    .Select(order => order.Id);

string[] snapshot = largeOrderIds.ToArray();

Console.WriteLine($"snapshot: {string.Join(", ", snapshot)}");

orders.Add(new("C-300", 80m));

Console.WriteLine($"deferred: {string.Join(", ", largeOrderIds)}");
Console.WriteLine($"snapshot: {string.Join(", ", snapshot)}");

public sealed record Order(string Id, decimal Total);

snapshot: B-200
deferred: B-200, C-300
snapshot: B-200

数组固定的是成员引用集合，不是元素的深复制。本例的 Order 是不可变记录，所以差异只来自列表新增；若元素本身可变，快照和源仍可能观察到同一个元素对象的变化。

查询变量的静态类型是 IEnumerable<string>，并不承诺结果已经存在内存。API 若返回这种延迟查询，应说明数据源所有权、能否重复枚举，以及源在消费前是否仍然有效。

用 SelectMany 展平，再分组汇总

每张订单包含多个明细。SelectMany 在展平时保留客户名称，GroupBy 使用明确的 SKU 大小写规则，随后计算每个 SKU 的总件数与客户集合。

using System;
using System.Linq;

Order[] orders =
[
    new("Ana",
    [
        new("BK-1", 2),
        new("PN-2", 3)
    ]),
    new("Bo",
    [
        new("bk-1", 1)
    ])
];

var totals = orders
    .SelectMany(
        order => order.Lines,
        (order, line) => new { order.Customer, line.Sku, line.Quantity })
    .GroupBy(row => row.Sku, StringComparer.OrdinalIgnoreCase)
    .Select(group => new
    {
        Sku = group.Key,
        Units = group.Sum(row => row.Quantity),
        Customers = string.Join("/", group
            .Select(row => row.Customer)
            .Distinct()
            .OrderBy(name => name))
    })
    .OrderBy(total => total.Sku, StringComparer.OrdinalIgnoreCase);

foreach (var total in totals)
{
    Console.WriteLine($"{total.Sku}: {total.Units} units ({total.Customers})");
}

public sealed record Order(string Customer, Line[] Lines);
public sealed record Line(string Sku, int Quantity);

BK-1: 3 units (Ana/Bo)
PN-2: 3 units (Ana)

结果选择器把订单上下文与明细放进同一行对象，避免展平后丢失客户信息。分组沿用第一次出现的键作为 Key，所以显示为 "BK-1"；大小写相等规则不等于显示规范化策略。

GroupBy 在枚举开始后读取输入并建立分组。若输入可能包含巨大或无限序列，这项缓冲需求会改变 API 能接受的数据源；应在边界明确限制，而不是期待 Take 放在分组后就能减少分组前的读取。

用查询语法表达分组连接

查询语法适合同时命名客户、订单组和小计。分组连接保留没有订单的客户，where 再筛掉总额不足的结果。

using System;
using System.Globalization;
using System.Linq;

Customer[] customers =
[
    new(1, "Alice"),
    new(2, "Bob"),
    new(3, "Cara")
];

Order[] orders =
[
    new(101, 1, 40m),
    new(102, 1, 65m),
    new(103, 2, 30m)
];

var summaries =
    from customer in customers
    join order in orders on customer.Id equals order.CustomerId into customerOrders
    let total = customerOrders.Sum(order => order.Amount)
    where total >= 50m
    orderby total descending, customer.Name
    select new { customer.Name, Total = total };

foreach (var summary in summaries)
{
    string total = summary.Total.ToString("F2", CultureInfo.InvariantCulture);
    Console.WriteLine($"{summary.Name}: {total}");
}

public sealed record Customer(int Id, string Name);
public sealed record Order(int Id, int CustomerId, decimal Amount);

Alice: 105.00

编译器会把 join ... into 转换为分组连接，并为 let 和后续子句构造相应投影。Sum 对空的 decimal 序列返回零，因此 Cara 会在 where 处被过滤，而不是在聚合处失败。

这里的源是数组，所以委托在内存中执行。若范围变量来自 IQueryable<T>，相同语法会绑定到 Queryable；这时必须确认提供程序能翻译分组连接、聚合与排序组合。

陷阱

把查询变量当成快照

修复方法： 先决定调用方需要实时视图还是稳定快照。需要快照就只在明确边界物化一次，并说明这是容器快照还是元素深复制；需要延迟查询就让源的生命周期覆盖完整消费过程。

重复枚举带有工作或副作用的源

修复方法： 若契约需要一组稳定结果，物化一次后使用集合的 Count 和迭代。若源刻意是流，则设计单次消费接口，不要为了探测是否为空而预先枚举；可以在一次枚举中处理首项与后续项。

用元素运算符隐藏基数错误

修复方法： 从领域约束选择 First、Single 及其 OrDefault 版本，并分别测试零项、一项和多项。默认值也是合法数据时，不要让一个裸值同时表示「缺失」与真实结果。

用第二个 OrderBy 丢失主排序

修复方法： 第一个键使用 OrderBy 或 OrderByDescending，后续键使用 ThenBy 或 ThenByDescending。用主键相同而次键不同、以及主键不同但次键相同的数据断言完整顺序。

在枚举中修改源集合

修复方法： 先把要改的项目收集到独立结果，再在枚举结束后应用变更；或者使用集合提供的专用批量操作。若确实需要边读边改，应选明确定义这种行为的数据结构与算法。

在提供程序边界意外切回内存

修复方法： 标出 IQueryable<T> 到 IEnumerable<T> 的边界，把可翻译的筛选、投影与限制留在边界之前。用真实提供程序检查生成的查询和结果；无法翻译的逻辑要么重写，要么在有明确数据上限后显式转入内存。

延伸阅读

• Microsoft Learn：LINQ 概览
• Microsoft Learn：查询表达式基础
• Microsoft Learn：标准查询运算符
• Microsoft Learn：延迟执行与惰性求值
• Microsoft Learn：IEnumerable<T> 接口
• Microsoft Learn：IQueryable<T> 接口