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>接口