C# LINQ与函数式编程

0. 学习目标

本章节基于 Bloom 分类法（Bloom’s Taxonomy）将学习目标按认知层级递进组织，帮助学习者从记忆到创造逐层构建对 LINQ 与函数式编程的深度理解。

0.1 记忆层（Remember）

完成本章学习后，学习者应当能够：

• 复述 LINQ 的英文全称（Language Integrated Query）及其核心定义
• 列举 LINQ 的三大组成部分：LINQ to Objects、LINQ to XML、LINQ to SQL/Entities
• 识别查询语法（Query Syntax）与方法语法（Method Syntax）的基本结构
• 回忆标准查询运算符（Standard Query Operators）的命名空间 System.Linq
• 列举至少 10 个常用 LINQ 运算符：Where、Select、OrderBy、GroupBy、Join、SelectMany、Any、All、First、Count

0.2 理解层（Understand）

完成本章学习后，学习者应当能够：

• 解释延迟执行（Deferred Execution）与立即执行（Immediate Execution）的本质区别
• 阐述 IEnumerable 与 IQueryable 两类序列在 LINQ 处理上的差异
• 说明表达式树（Expression Tree）作为数据结构与代码可执行体之间的双重身份
• 解释函子（Functor）、应用函子（Applicative Functor）、Monad 三者之间的关系
• 阐述 LINQ 与函数式编程在历史演进中的相互影响

0.3 应用层（Apply）

完成本章学习后，学习者应当能够：

• 在生产代码中使用 LINQ 重写传统 foreach 循环逻辑，提升可读性
• 对集合数据执行筛选、投影、聚合、分组、连接等操作
• 使用 PLINQ（Parallel LINQ）对 CPU 密集型查询进行并行化加速
• 在 EF Core 中正确编写 LINQ 查询并理解其翻译为 SQL 的过程
• 应用局部函数（Local Functions）封装查询内部的辅助逻辑

0.4 分析层（Analyze）

完成本章学习后，学习者应当能够：

• 分析 LINQ 查询在运行时的执行链路与中间状态
• 比较不同 LINQ 实现的性能特征（迭代器 vs 表达式树翻译）
• 拆解复杂的 SelectMany 链式调用，识别其与 Monad bind 操作的同构性
• 分析表达式树如何在 EF Core 中被翻译为 SQL，并识别翻译失败的场景
• 识别 LINQ 查询中的多次枚举问题与性能反模式

0.5 评价层（Evaluate）

完成本章学习后，学习者应当能够：

• 评估一个 LINQ 查询在生产环境中的性能与内存开销
• 判断何时应使用查询语法而非方法语法（或反之），并给出工程依据
• 评价函数式编程范式相对于面向对象范式在特定业务场景下的优劣
• 评估 PLINQ 的并行化收益是否大于其线程调度开销
• 评估表达式树在动态查询构建场景下的适用性

0.6 创造层（Create）

完成本章学习后，学习者应当能够：

• 设计并实现自定义 LINQ 运算符，扩展 IEnumerable<T> 的查询能力
• 构建基于表达式树的动态查询生成器，支持运行时组合查询条件
• 设计自定义 Monad（如 Result、Maybe、Validation）并提供 LINQ 查询表达式支持
• 实现一个简易的 ORM 映射器，将 LINQ 表达式翻译为目标 SQL
• 创造性地将函数式编程范式与 C# 命令式特性融合，构建高可维护的生产级系统

1. 历史动机与背景

1.1 LINQ 诞生的时代背景

2007 年 11 月，Microsoft 随 .NET Framework 3.5 正式发布了 LINQ（Language Integrated Query）。这一技术的诞生并非偶然，而是对当时软件开发领域一个长期痛点的回应：对象世界与数据世界之间的阻抗失配（Impedance Mismatch）。

在 LINQ 出现之前，.NET 开发者处理数据查询面临以下割裂：

• 对象集合查询：使用 foreach 循环、临时变量、条件判断，代码冗长且易错
• 关系数据库查询：使用 SQL 字符串拼接，无编译期类型检查，重构困难
• XML 文档查询：使用 XPath 或 XQuery，与 C# 类型系统脱节
• Web 服务查询：使用 REST API 调用，结果需要手动反序列化与过滤

这种割裂导致了几个严重问题：

1. 类型安全缺失：SQL 字符串中的列名错误只能在运行时暴露
2. 代码可读性差：数据访问逻辑分散在不同层次的字符串中
3. 重构困难：数据库 schema 变更无法通过 IDE 工具链自动同步
4. 学习成本高：开发者需要同时掌握 C#、SQL、XPath 等多种查询语言

1.2 函数式编程的影响

LINQ 的设计深受函数式编程语言的影响，尤其是 Haskell 与 ML 系列。Anders Hejlsberg（C# 首席架构师）在多个场合明确表示，LINQ 的核心思想来源于：

• Haskell 的列表推导（List Comprehension）：[x*2 | x <- xs, x > 0] 这一语法糖直接启发了 LINQ 的查询语法
• SQL 的声明式查询范式：from x in xs where x > 0 select x*2 几乎是 SQL 的 C# 化表达
• ML 的高阶函数：map、filter、fold 在 LINQ 中对应为 Select、Where、Aggregate

1.3 C# 的函数式演进路径

C# 从 1.0 到 13.0 的演进可以视为逐步引入函数式编程特性的过程：

1.4 LINQ 解决的核心问题

LINQ 通过提供统一的查询模型，解决了以下工程问题：

问题 1：类型安全与编译期检查

// LINQ 之前：SQL 字符串拼接，列名错误只能运行时发现
string sql = "SELECT Name, Age FORM Users WHERE Age > 18"; // 拼写错误：FORM

// LINQ 之后：编译期类型检查
var adults = users.Where(u => u.Age > 18).Select(u => u.Name);

问题 2：跨数据源统一查询

// 同一套查询语法，适用于不同数据源
var query1 = from u in users where u.Age > 18 select u.Name;           // 对象集合
var query2 = from u in dbContext.Users where u.Age > 18 select u.Name; // 数据库
var query3 = from e in xdoc.Descendants("user") where (int)e.Attribute("age") > 18 select e.Value; // XML

问题 3：声明式优于命令式

// 命令式：描述"怎么做"，关注控制流
var names = new List<string>();
foreach (var u in users)
{
    if (u.Age > 18)
    {
        names.Add(u.Name);
    }
}

// 声明式（LINQ）：描述"做什么"，关注数据转换
var names = users.Where(u => u.Age > 18).Select(u => u.Name).ToList();

2. 形式化定义

2.1 LINQ 的数学基础

LINQ 的核心抽象可以形式化定义为：给定一个数据源 $S$ 与一组查询运算符 $\Omega$，LINQ 查询 $Q$ 是一个由运算符组合而成的函数复合：

其中 $\omega_i \in \Omega$，每个运算符接受一个序列并返回一个序列（或标量值）。

2.2 IEnumerable 作为函子

在范畴论中，函子（Functor） 是从一个范畴到另一个范畴的映射，保持态射结构。在 C# 中，IEnumerable<T> 构成一个函子，其 Select 运算符实现了函子的 fmap 操作：

满足函子定律：

1. 同一律：xs.Select(x => x) ≡ xs
2. 复合律：xs.Select(f).Select(g) ≡ xs.Select(x => g(f(x)))

数学表达：

2.3 SelectMany 作为 Monad 的 bind 操作

IEnumerable<T> 不仅是一个函子，还是一个 Monad。Monad 的核心操作 bind（通常记作 >>=）在 LINQ 中对应 SelectMany：

对应 C# 签名：

// SelectMany 的核心签名
IEnumerable<U> SelectMany<T, U>(
    this IEnumerable<T> source,
    Func<T, IEnumerable<U>> selector);

Monad 必须满足三条定律：

1. 左单位律（Left Identity）：Return(x).Bind(f) ≡ f(x)
2. 右单位律（Right Identity）：m.Bind(Return) ≡ m
3. 结合律（Associativity）：m.Bind(f).Bind(g) ≡ m.Bind(x => f(x).Bind(g))

用 LINQ 语法表达：

// 左单位律
new[] { x }.SelectMany(f) ≡ f(x)

// 右单位律
xs.SelectMany(x => new[] { x }) ≡ xs

// 结合律
xs.SelectMany(f).SelectMany(g) ≡ xs.SelectMany(x => f(x).SelectMany(g))

2.4 查询表达式的形式语法

C# 查询表达式的形式语法（简化版）可定义为：

查询表达式会被编译器翻译为对扩展方法的调用，这一翻译过程遵循 C# 语言规范第 7.16 节定义的规则。

2.5 表达式树的代数结构

表达式树（Expression<TDelegate>）将代码表示为抽象语法树（AST）。形式上，表达式树可以定义为以下代数数据类型：

这种代数结构使得表达式可以被：

• 遍历（Traversal）：通过 ExpressionVisitor 递归访问每个节点
• 转换（Transformation）：将 C# 表达式翻译为 SQL、JavaScript 等
• 组合（Composition）：在运行时动态构建复杂查询

3. 理论推导

3.1 延迟执行的执行语义

LINQ 查询的延迟执行基于迭代器模式（Iterator Pattern）。考虑以下查询：

var query = numbers.Where(n => n > 0).Select(n => n * 2);

其执行过程可以形式化描述为拉取驱动（Pull-based）的协程：

1. 调用 query.GetEnumerator() 创建迭代器状态机
2. 每次调用 MoveNext() 推进状态机一个步骤
3. Current 属性返回当前元素

复杂度分析：

• 时间复杂度：$O(n \times k)$，其中 $n$ 为源序列长度，$k$ 为运算符链长度
• 空间复杂度：$O(k)$，每个运算符维护一个迭代器状态，与序列长度无关
• 总体：流式处理，单元素内存占用为常数级

3.2 查询运算符的代数性质

LINQ 运算符具有丰富的代数性质，这些性质是查询优化的理论基础：

幂等性（Idempotency）：

分配律（Distributivity）：

融合律（Fusion Law）：

这一性质在函数式编程的**融合优化（Deforestation / Stream Fusion）**中被广泛使用，可消除中间数据结构的分配开销。

3.3 复杂度分析

不同 LINQ 运算符的时间与空间复杂度：

3.4 PLINQ 的并行化分析

PLINQ 通过将输入序列分区并并行处理来加速 CPU 密集型查询。其加速比受 Amdahl 定律约束：

其中 $p$ 为可并行化的比例，$N$ 为处理器核心数。

对于完全并行的 Where 操作，理论加速比接近 $N$。但对于 OrderBy 等需要全局状态的操作，PLINQ 的开销可能超过收益。

3.5 表达式树翻译的复杂性

EF Core 将 LINQ 表达式翻译为 SQL 的过程涉及多个阶段：

1. 解析阶段：将 IQueryable 的调用链构建为表达式树
2. 规范化阶段：将 C# 表达式归约为可翻译的子集
3. 翻译阶段：将表达式映射为 SQL AST
4. 优化阶段：应用 SQL 优化规则（谓词下推、列裁剪等）
5. 生成阶段：生成目标方言的 SQL 字符串

翻译过程的复杂度为 $O(|T| \times |R|)$，其中 $|T|$ 为表达式树节点数，$|R|$ 为翻译规则数。

4. 代码示例

4.1 基础查询语法对比

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

/// <summary>
/// LINQ 基础示例：对比查询语法与方法语法
/// 演示同一个查询需求的两种表达方式
/// </summary>
public class BasicLinqDemo
{
    /// <summary>
    /// 示例数据：用户列表
    /// </summary>
    public record User(int Id, string Name, int Age, string Department, decimal Salary);

    public static void Run()
    {
        // 构造示例数据
        var users = new List<User>
        {
            new(1, "张三", 28, "工程部", 18000m),
            new(2, "李四", 35, "工程部", 25000m),
            new(3, "王五", 42, "市场部", 22000m),
            new(4, "赵六", 31, "市场部", 20000m),
            new(5, "钱七", 26, "工程部", 16000m),
            new(6, "孙八", 38, "工程部", 28000m),
            new(7, "周九", 45, "市场部", 30000m),
            new(8, "吴十", 29, "工程部", 19000m)
        };

        // 需求：查询工程部年龄大于 30 的员工姓名，按薪资降序排列

        // 方式一：查询语法（Query Syntax）—— 类似 SQL
        var querySyntax =
            from u in users
            where u.Department == "工程部" && u.Age > 30
            orderby u.Salary descending
            select u.Name;

        // 方式二：方法语法（Method Syntax）—— 基于 Lambda 与扩展方法
        var methodSyntax = users
            .Where(u => u.Department == "工程部" && u.Age > 30)
            .OrderByDescending(u => u.Salary)
            .Select(u => u.Name);

        // 两种语法编译后等价，输出相同结果
        Console.WriteLine("查询语法结果：");
        foreach (var name in querySyntax) Console.WriteLine($"  {name}");

        Console.WriteLine("方法语法结果：");
        foreach (var name in methodSyntax) Console.WriteLine($"  {name}");
    }
}

4.2 延迟执行演示

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

/// <summary>
/// 延迟执行（Deferred Execution）深度演示
/// 展示 LINQ 查询的执行时机与多次枚举的副作用
/// </summary>
public class DeferredExecutionDemo
{
    public static void Run()
    {
        var numbers = new List<int> { 1, 2, 3, 4, 5 };
        var evaluationCount = 0;

        // 延迟执行：查询定义时不执行，枚举时才执行
        var query = numbers
            .Select(n =>
            {
                evaluationCount++;  // 副作用计数器
                return n * 2;
            });

        // 此时 evaluationCount 仍为 0，查询尚未执行
        Console.WriteLine($"查询定义后，求值次数：{evaluationCount}");

        // 第一次枚举：触发执行
        var list1 = query.ToList();
        Console.WriteLine($"第一次 ToList 后，求值次数：{evaluationCount}");

        // 第二次枚举：再次触发执行（每次枚举都重新求值）
        var list2 = query.ToList();
        Console.WriteLine($"第二次 ToList 后，求值次数：{evaluationCount}");

        // 源数据变更后，下次枚举会反映最新数据
        numbers.Add(6);
        var list3 = query.ToList();
        Console.WriteLine($"添加元素后第三次 ToList，求值次数：{evaluationCount}");
        Console.WriteLine($"第三次结果包含元素数：{list3.Count}");

        // 立即执行运算符：ToList、ToArray、Count、First、Aggregate 等
        // 一旦调用立即执行并缓存结果
        var cachedQuery = numbers
            .Select(n => n * 2)
            .ToList();  // 立即执行，结果缓存到 list

        // 之后再修改源数据，缓存结果不变
        numbers.Add(100);
        Console.WriteLine($"立即执行后源数据变更，缓存结果不变：{cachedQuery.Count}");
    }
}

4.3 SelectMany 与多层嵌套

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

/// <summary>
/// SelectMany 深度示例：处理嵌套集合，对应 Monad 的 bind 操作
/// 演示笛卡尔积、扁平化、关联查询等场景
/// </summary>
public class SelectManyDemo
{
    /// <summary>班级</summary>
    public record Class(string Name, List<Student> Students);

    /// <summary>学生</summary>
    public record Student(string Name, List<Course> Courses);

    /// <summary>课程</summary>
    public record Course(string Name, int Score);

    public static void Run()
    {
        var classes = new List<Class>
        {
            new("一班", new()
            {
                new("张三", new() { new("数学", 90), new("语文", 85) }),
                new("李四", new() { new("数学", 78), new("语文", 92) })
            }),
            new("二班", new()
            {
                new("王五", new() { new("数学", 88), new("语文", 76) }),
                new("赵六", new() { new("数学", 95), new("语文", 89) })
            })
        };

        // 场景一：扁平化所有学生
        var allStudents = classes.SelectMany(c => c.Students);
        Console.WriteLine($"所有学生数：{allStudents.Count()}");

        // 场景二：扁平化所有课程成绩
        var allScores = classes
            .SelectMany(c => c.Students)
            .SelectMany(s => s.Courses);
        Console.WriteLine($"所有成绩记录数：{allScores.Count()}");

        // 场景三：查询所有不及格成绩（< 60）
        var failed = classes
            .SelectMany(c => c.Students, (c, s) => new { Class = c.Name, Student = s.Name, s.Courses })
            .SelectMany(x => x.Courses, (x, c) => new { x.Class, x.Student, c.Name, c.Score })
            .Where(x => x.Score < 60);
        Console.WriteLine($"不及格记录数：{failed.Count()}");

        // 场景四：使用查询语法实现相同逻辑（更清晰）
        var failedQuery =
            from c in classes
            from s in c.Students
            from course in s.Courses
            where course.Score < 60
            select new { c.Name, Student = s.Name, Course = course.Name, course.Score };

        // 场景五：笛卡尔积
        var colors = new[] { "红", "蓝" };
        var sizes = new[] { "S", "M", "L" };
        var combinations = colors.SelectMany(_ => sizes, (color, size) => $"{color}-{size}");
        Console.WriteLine("颜色与尺寸的笛卡尔积：");
        foreach (var combo in combinations) Console.WriteLine($"  {combo}");
    }
}

4.4 分组与聚合

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

/// <summary>
/// GroupBy 与聚合运算符综合示例
/// 演示分组统计、多维聚合、嵌套分组等场景
/// </summary>
public class GroupByDemo
{
    public record Order(int Id, string Customer, string Product, string Category, int Quantity, decimal Price, DateTime OrderDate);

    public static void Run()
    {
        var orders = new List<Order>
        {
            new(1, "张三", "笔记本", "电子产品", 2, 5999m, new DateTime(2024, 1, 15)),
            new(2, "李四", "鼠标", "电子产品", 5, 99m, new DateTime(2024, 1, 18)),
            new(3, "张三", "键盘", "电子产品", 1, 399m, new DateTime(2024, 2, 3)),
            new(4, "王五", "T恤", "服装", 3, 199m, new DateTime(2024, 2, 10)),
            new(5, "李四", "牛仔裤", "服装", 2, 499m, new DateTime(2024, 2, 20)),
            new(6, "张三", "帽子", "服装", 4, 89m, new DateTime(2024, 3, 5)),
            new(7, "王五", "耳机", "电子产品", 1, 1299m, new DateTime(2024, 3, 12)),
            new(8, "李四", "充电器", "电子产品", 6, 79m, new DateTime(2024, 3, 25))
        };

        // 场景一：按客户分组，统计订单数与总金额
        var byCustomer = orders
            .GroupBy(o => o.Customer)
            .Select(g => new
            {
                Customer = g.Key,
                OrderCount = g.Count(),
                TotalAmount = g.Sum(o => o.Quantity * o.Price),
                AvgAmount = g.Average(o => o.Quantity * o.Price)
            });

        Console.WriteLine("按客户分组统计：");
        foreach (var stat in byCustomer)
            Console.WriteLine($"  {stat.Customer}: 订单数={stat.OrderCount}, 总金额={stat.TotalAmount:C}, 均价={stat.AvgAmount:C}");

        // 场景二：按类别与月份的多维分组
        var byCategoryAndMonth = orders
            .GroupBy(o => o.Category)
            .Select(g => new
            {
                Category = g.Key,
                MonthlyStats = g.GroupBy(o => o.OrderDate.ToString("yyyy-MM"))
                    .Select(mg => new { Month = mg.Key, Count = mg.Count(), Amount = mg.Sum(o => o.Quantity * o.Price) })
            });

        Console.WriteLine("按类别与月份的多维分组：");
        foreach (var cat in byCategoryAndMonth)
        {
            Console.WriteLine($"  [{cat.Category}]");
            foreach (var m in cat.MonthlyStats)
                Console.WriteLine($"    {m.Month}: 订单数={m.Count}, 金额={m.Amount:C}");
        }

        // 场景三：分组后取每组 Top N
        var topProductPerCategory = orders
            .GroupBy(o => o.Category)
            .Select(g => new
            {
                Category = g.Key,
                TopProduct = g.OrderByDescending(o => o.Quantity * o.Price).First()
            });

        Console.WriteLine("每类别销售额最高的商品：");
        foreach (var t in topProductPerCategory)
            Console.WriteLine($"  {t.Category}: {t.TopProduct.Product} (金额={t.TopProduct.Quantity * t.TopProduct.Price:C})");

        // 场景四：使用 Lookup 进行多次分组查询
        ILookup<string, Order> lookup = orders.ToLookup(o => o.Customer);
        // Lookup 与 Dictionary 区别：一个键可对应多个值
        Console.WriteLine($"张三的订单数：{lookup["张三"].Count()}");
    }
}

4.5 Join 操作

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

/// <summary>
/// LINQ Join 操作示例
/// 演示内连接、分组连接、左连接的实现方式
/// </summary>
public class JoinDemo
{
    public record Department(int Id, string Name);
    public record Employee(int Id, string Name, int DeptId, decimal Salary);

    public static void Run()
    {
        var departments = new List<Department>
        {
            new(1, "工程部"),
            new(2, "市场部"),
            new(3, "人事部")
        };

        var employees = new List<Employee>
        {
            new(1, "张三", 1, 18000m),
            new(2, "李四", 1, 25000m),
            new(3, "王五", 2, 22000m),
            new(4, "赵六", 2, 20000m),
            new(5, "钱七", 1, 16000m),
            // 注意：孙八的 DeptId=99 在 departments 中不存在（孤儿数据）
            new(6, "孙八", 99, 15000m)
        };

        // 场景一：内连接（Inner Join）—— 只匹配部门存在的员工
        var innerJoin = departments.Join(
            employees,
            d => d.Id,
            e => e.DeptId,
            (d, e) => new { Department = d.Name, Employee = e.Name, e.Salary });

        Console.WriteLine("内连接结果（孙八不出现，因为部门不存在）：");
        foreach (var r in innerJoin) Console.WriteLine($"  {r.Department} - {r.Employee}: {r.Salary:C}");

        // 场景二：分组连接（Group Join）—— 每个部门对应一组员工
        var groupJoin = departments.GroupJoin(
            employees,
            d => d.Id,
            e => e.DeptId,
            (d, emps) => new { Department = d.Name, Employees = emps, Count = emps.Count() });

        Console.WriteLine("分组连接结果：");
        foreach (var g in groupJoin)
        {
            Console.WriteLine($"  [{g.Department}] 员工数：{g.Count}");
            foreach (var e in g.Employees) Console.WriteLine($"    - {e.Name}: {e.Salary:C}");
        }

        // 场景三：左连接（Left Join）—— 通过 DefaultIfEmpty 实现
        var leftJoin = from d in departments
                       join e in employees on d.Id equals e.DeptId into empGroup
                       from e in empGroup.DefaultIfEmpty()
                       select new
                       {
                           Department = d.Name,
                           Employee = e?.Name ?? "（无员工）",
                           Salary = e?.Salary ?? 0m
                       };

        Console.WriteLine("左连接结果（人事部无员工，显示默认值）：");
        foreach (var r in leftJoin) Console.WriteLine($"  {r.Department} - {r.Employee}: {r.Salary:C}");

        // 场景四：交叉连接（Cross Join）—— 笛卡尔积
        var crossJoin = from d in departments
                        from e in employees
                        select new { d.Name, e.Name };
        Console.WriteLine($"交叉连接总数：{crossJoin.Count()}");

        // 场景五：使用查询语法实现内连接
        var innerJoinQuery =
            from d in departments
            join e in employees on d.Id equals e.DeptId
            where e.Salary > 18000m
            orderby e.Salary descending
            select new { Department = d.Name, Employee = e.Name, e.Salary };
    }
}

4.6 表达式树构建与翻译

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

/// <summary>
/// 表达式树（Expression Tree）深度示例
/// 演示运行时动态构建查询条件，对应函数式编程中的 AST 操作
/// </summary>
public class ExpressionTreeDemo
{
    public record Product(int Id, string Name, string Category, decimal Price, int Stock);

    /// <summary>
    /// 动态查询条件构建器：根据多个可选参数组合 Where 条件
    /// 利用表达式树的组合性，实现运行时查询生成
    /// </summary>
    public static class ProductQueryBuilder
    {
        /// <summary>
        /// 构建动态查询：支持按类别、价格区间、库存过滤
        /// </summary>
        public static Expression<Func<Product, bool>> BuildFilter(
            string? category = null,
            decimal? minPrice = null,
            decimal? maxPrice = null,
            int? minStock = null)
        {
            // 起始条件：恒真
            Expression<Func<Product, bool>> predicate = p => true;

            // 逐个组合条件（逻辑与）
            if (!string.IsNullOrEmpty(category))
                predicate = CombineAnd(predicate, p => p.Category == category);

            if (minPrice.HasValue)
                predicate = CombineAnd(predicate, p => p.Price >= minPrice.Value);

            if (maxPrice.HasValue)
                predicate = CombineAnd(predicate, p => p.Price <= maxPrice.Value);

            if (minStock.HasValue)
                predicate = CombineAnd(predicate, p => p.Stock >= minStock.Value);

            return predicate;
        }

        /// <summary>
        /// 组合两个表达式为逻辑与
        /// 核心：使用 ExpressionVisitor 重写参数引用，确保参数一致
        /// </summary>
        private static Expression<Func<T, bool>> CombineAnd<T>(
            Expression<Func<T, bool>> left,
            Expression<Func<T, bool>> right)
        {
            var parameter = Expression.Parameter(typeof(T), "p");

            // 使用visitor将左右表达式的参数统一为同一个 parameter
            var leftBody = new ParameterReplacer(left.Parameters[0], parameter).Visit(left.Body);
            var rightBody = new ParameterReplacer(right.Parameters[0], parameter).Visit(right.Body);

            var body = Expression.AndAlso(leftBody, rightBody);
            return Expression.Lambda<Func<T, bool>>(body, parameter);
        }

        /// <summary>
        /// 表达式参数替换器：将表达式中的参数引用替换为统一参数
        /// 这是表达式树操作的核心工具类
        /// </summary>
        private class ParameterReplacer : ExpressionVisitor
        {
            private readonly ParameterExpression _oldParam;
            private readonly ParameterExpression _newParam;

            public ParameterReplacer(ParameterExpression oldParam, ParameterExpression newParam)
            {
                _oldParam = oldParam;
                _newParam = newParam;
            }

            protected override Expression VisitParameter(ParameterExpression node)
            {
                return node == _oldParam ? _newParam : base.VisitParameter(node);
            }
        }
    }

    public static void Run()
    {
        var products = new List<Product>
        {
            new(1, "笔记本", "电子产品", 5999m, 10),
            new(2, "鼠标", "电子产品", 99m, 50),
            new(3, "T恤", "服装", 199m, 100),
            new(4, "耳机", "电子产品", 1299m, 20),
            new(5, "牛仔裤", "服装", 499m, 30)
        };

        // 场景一：动态构建查询条件
        var filter = ProductQueryBuilder.BuildFilter(
            category: "电子产品",
            minPrice: 100m,
            minStock: 15);

        // 查看生成的表达式树结构
        Console.WriteLine($"生成的表达式：{filter.Body}");

        // 应用查询
        var result = products.AsQueryable().Where(filter).ToList();
        Console.WriteLine($"查询结果数：{result.Count}");
        foreach (var p in result) Console.WriteLine($"  {p.Name}: 价格={p.Price}, 库存={p.Stock}");

        // 场景二：表达式树的 introspection
        Expression<Func<int, int>> expr = x => (x + 1) * 2;
        Console.WriteLine($"表达式类型：{expr.NodeType}");
        Console.WriteLine($"表达式体类型：{expr.Body.NodeType}");
        Console.WriteLine($"表达式体：{expr.Body}");

        // 遍历表达式树
        var visitor = new ExpressionPrinter();
        visitor.Visit(expr);
    }

    /// <summary>
    /// 表达式树打印器：递归遍历并打印每个节点
    /// </summary>
    private class ExpressionPrinter : ExpressionVisitor
    {
        private int _indent = 0;

        public override Expression Visit(Expression node)
        {
            if (node != null)
            {
                Console.WriteLine($"{new string(' ', _indent * 2)}{node.NodeType} ({node.GetType().Name})");
                _indent++;
            }
            var result = base.Visit(node);
            if (node != null) _indent--;
            return result;
        }
    }
}

4.7 PLINQ 并行查询

using System;
using System.Linq;
using System.Diagnostics;

/// <summary>
/// PLINQ（Parallel LINQ）并行查询示例
/// 演示 AsParallel 的使用场景与适用边界
/// </summary>
public class PlinqDemo
{
    /// <summary>
    /// 模拟 CPU 密集型计算
    /// </summary>
    private static int HeavyCompute(int n)
    {
        // 模拟复杂计算：判断素数
        if (n < 2) return 0;
        for (int i = 2; i * i <= n; i++)
            if (n % i == 0) return 0;
        return n;
    }

    public static void Run()
    {
        // 生成大数据集
        var numbers = Enumerable.Range(1, 1_000_000).ToArray();

        // 串行 LINQ
        var sw = Stopwatch.StartNew();
        var sequentialPrimes = numbers
            .Select(HeavyCompute)
            .Where(x => x > 0)
            .Count();
        sw.Stop();
        Console.WriteLine($"串行 LINQ：找到 {sequentialPrimes} 个素数，耗时 {sw.ElapsedMilliseconds}ms");

        // 并行 PLINQ
        sw.Restart();
        var parallelPrimes = numbers
            .AsParallel()                              // 启用并行
            .WithDegreeOfParallelism(Environment.ProcessorCount)
            .Select(HeavyCompute)
            .Where(x => x > 0)
            .Count();
        sw.Stop();
        Console.WriteLine($"并行 PLINQ：找到 {parallelPrimes} 个素数，耗时 {sw.ElapsedMilliseconds}ms");

        // PLINQ 注意事项
        // 1. 顺序敏感操作（如 Take、Skip）并行后可能性能下降
        // 2. 有副作用操作必须确保线程安全
        // 3. 小数据集并行化收益小于开销
        // 4. AsOrdered() 保持顺序但增加开销

        // 场景：并行 + 合并选项
        var orderedResult = numbers
            .AsParallel()
            .AsOrdered()                                // 保持原始顺序
            .Select(HeavyCompute)
            .Take(100)
            .ToArray();
        Console.WriteLine($"有序并行查询前 100 个结果已生成");
    }
}

4.8 自定义 LINQ 运算符

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

/// <summary>
/// 自定义 LINQ 运算符示例
/// 通过扩展方法为 IEnumerable 添加新能力，体现 LINQ 的可扩展性
/// </summary>
public static class CustomLinqOperators
{
    /// <summary>
    /// 批处理运算符：将序列按指定大小分批
    /// 常用于分页、批量插入数据库等场景
    /// </summary>
    /// <typeparam name="T">元素类型</typeparam>
    /// <param name="source">源序列</param>
    /// <param name="batchSize">每批大小</param>
    /// <returns>批处理后的序列的序列</returns>
    public static IEnumerable<IEnumerable<T>> Batch<T>(
        this IEnumerable<T> source,
        int batchSize)
    {
        if (source == null) throw new ArgumentNullException(nameof(source));
        if (batchSize <= 0) throw new ArgumentOutOfRangeException(nameof(batchSize), "批大小必须为正数");

        using var enumerator = source.GetEnumerator();
        while (enumerator.MoveNext())
        {
            yield return TakeBatch(enumerator, batchSize);
        }
    }

    private static IEnumerable<T> TakeBatch<T>(IEnumerator<T> enumerator, int batchSize)
    {
        int count = 0;
        do
        {
            yield return enumerator.Current;
            count++;
        } while (count < batchSize && enumerator.MoveNext());
    }

    /// <summary>
    /// 区间采样运算符：按步长采样序列
    /// 用于降采样、抽样统计等场景
    /// </summary>
    public static IEnumerable<T> Sample<T>(
        this IEnumerable<T> source,
        int step)
    {
        if (step <= 0) throw new ArgumentOutOfRangeException(nameof(step));
        int index = 0;
        foreach (var item in source)
        {
            if (index % step == 0) yield return item;
            index++;
        }
    }

    /// <summary>
    /// 滑动窗口运算符：生成大小为 windowSize 的滑动窗口
    /// 用于时间序列分析、移动平均等场景
    /// </summary>
    public static IEnumerable<IEnumerable<T>> Window<T>(
        this IEnumerable<T> source,
        int windowSize)
    {
        if (windowSize <= 0) throw new ArgumentOutOfRangeException(nameof(windowSize));

        var window = new Queue<T>(windowSize);
        foreach (var item in source)
        {
            window.Enqueue(item);
            if (window.Count == windowSize)
            {
                yield return window.ToArray();
                window.Dequeue();
            }
        }
    }

    /// <summary>
    /// 移动平均运算符：基于 Window 实现
    /// </summary>
    public static IEnumerable<double> MovingAverage(
        this IEnumerable<double> source,
        int windowSize)
    {
        return source.Window(windowSize).Select(w => w.Average());
    }

    /// <summary>
    /// DistinctBy 运算符：按键去重（.NET 6+ 已内置，此处演示自定义实现）
    /// </summary>
    public static IEnumerable<T> DistinctByCustom<T, TKey>(
        this IEnumerable<T> source,
        Func<T, TKey> keySelector)
    {
        var seen = new HashSet<TKey>();
        foreach (var item in source)
        {
            if (seen.Add(keySelector(item))) yield return item;
        }
    }

    /// <summary>
    /// ForEach 运算符：对每个元素执行操作（注意：会破坏延迟执行）
    /// </summary>
    public static void ForEach<T>(
        this IEnumerable<T> source,
        Action<T> action)
    {
        foreach (var item in source) action(item);
    }
}

/// <summary>
/// 自定义运算符使用示例
/// </summary>
public class CustomOperatorsDemo
{
    public static void Run()
    {
        var numbers = Enumerable.Range(1, 20);

        // 批处理：每 5 个一批
        Console.WriteLine("批处理示例：");
        var batches = numbers.Batch(5);
        foreach (var batch in batches)
            Console.WriteLine($"  [{string.Join(", ", batch)}]");

        // 滑动窗口：大小为 3
        Console.WriteLine("滑动窗口示例：");
        var windows = numbers.Window(3);
        foreach (var w in windows)
            Console.WriteLine($"  [{string.Join(", ", w)}]");

        // 移动平均
        var prices = new[] { 10.0, 12.0, 15.0, 14.0, 16.0, 18.0, 17.0 };
        var ma = prices.MovingAverage(3);
        Console.WriteLine($"移动平均（窗口=3）：[{string.Join(", ", ma.Select(x => x.ToString("F2")))}]");

        // 按键去重
        var people = new[]
        {
            (Name: "张三", Age: 28),
            (Name: "李四", Age: 35),
            (Name: "张三", Age: 42)  // 同名，会被去重
        };
        var distinctByName = people.DistinctByCustom(p => p.Name);
        Console.WriteLine($"按键去重结果数：{distinctByName.Count()}");
    }
}

4.9 函数式编程实践

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

/// <summary>
/// 函数式编程在 C# 中的实践示例
/// 演示 Maybe Monad、Result Monad 与 LINQ 风格的组合
/// </summary>
public class FunctionalProgrammingDemo
{
    /// <summary>
    /// Maybe Monad：封装可能不存在的值
    /// 实现 LINQ 查询表达式支持，可使用 from ... select 语法
    /// </summary>
    public readonly struct Maybe<T> : IEquatable<Maybe<T>>
    {
        private readonly T _value;
        public bool HasValue { get; }
        public T Value => HasValue ? _value : throw new InvalidOperationException("Maybe has no value");
        public static Maybe<T> None => new();

        private Maybe(T value)
        {
            _value = value;
            HasValue = true;
        }

        public static Maybe<T> Some(T value) => value == null ? None : new Maybe<T>(value);

        /// <summary>Map 操作（函子）</summary>
        public Maybe<U> Select<U>(Func<T, U> f) => HasValue ? Maybe<U>.Some(f(_value)) : Maybe<U>.None;

        /// <summary>Bind 操作（Monad）—— 对应 SelectMany</summary>
        public Maybe<U> SelectMany<U>(Func<T, Maybe<U>> f) => HasValue ? f(_value) : Maybe<U>.None;

        /// <summary>SelectMany 的重载：支持 LINQ 查询语法</summary>
        public Maybe<V> SelectMany<U, V>(Func<T, Maybe<U>> f, Func<T, U, V> g)
        {
            if (!HasValue) return Maybe<V>.None;
            var intermediate = f(_value);
            return intermediate.HasValue ? Maybe<V>.Some(g(_value, intermediate.Value)) : Maybe<V>.None;
        }

        /// <summary>模式匹配风格的 Match</summary>
        public TResult Match<TResult>(
            Func<T, TResult> some,
            Func<TResult> none) => HasValue ? some(_value) : none();

        public bool Equals(Maybe<T> other)
        {
            if (!HasValue && !other.HasValue) return true;
            if (HasValue != other.HasValue) return false;
            return EqualityComparer<T>.Default.Equals(_value, other._value);
        }

        public override bool Equals(object? obj) => obj is Maybe<T> other && Equals(other);
        public override int GetHashCode() => HasValue ? _value?.GetHashCode() ?? 0 : 0;
        public static bool operator ==(Maybe<T> left, Maybe<T> right) => left.Equals(right);
        public static bool operator !=(Maybe<T> left, Maybe<T> right) => !left.Equals(right);
    }

    /// <summary>
    /// 用户仓储：返回 Maybe 表示可能不存在的查询
    /// </summary>
    public class UserRepository
    {
        private readonly Dictionary<int, string> _users = new()
        {
            { 1, "张三" },
            { 2, "李四" }
        };

        public Maybe<string> FindName(int id) =>
            _users.TryGetValue(id, out var name) ? Maybe<string>.Some(name) : Maybe<string>.None;
    }

    /// <summary>
    /// 订单仓储
    /// </summary>
    public class OrderRepository
    {
        private readonly Dictionary<string, decimal> _orders = new()
        {
            { "张三", 999m },
            { "王五", 100m }
        };

        public Maybe<decimal> FindAmount(string name) =>
            _orders.TryGetValue(name, out var amount) ? Maybe<decimal>.Some(amount) : Maybe<decimal>.None;
    }

    public static void Run()
    {
        var userRepo = new UserRepository();
        var orderRepo = new OrderRepository();

        // 传统方式：层层嵌套的 null 检查
        string TraditionallyGetOrderAmount(int userId)
        {
            var name = userRepo.FindName(userId);
            if (!name.HasValue) return "用户不存在";
            var amount = orderRepo.FindAmount(name.Value);
            if (!amount.HasValue) return "订单不存在";
            return $"订单金额：{amount.Value}";
        }

        // Monad 方式：使用 LINQ 查询表达式优雅组合
        Maybe<string> MonadicGetOrderAmount(int userId) =>
            from name in userRepo.FindName(userId)
            from amount in orderRepo.FindAmount(name)
            select $"订单金额：{amount}";

        // 测试不同场景
        foreach (var id in new[] { 1, 2, 3 })
        {
            var result = MonadicGetOrderAmount(id);
            var output = result.Match(s => s, () => "查询失败");
            Console.WriteLine($"用户ID={id}: {output}");
        }

        // 函数组合：柯里化与部分应用
        Func<int, Func<int, int>> add = a => b => a + b;
        var add5 = add(5);
        Console.WriteLine($"柯里化示例：add5(3) = {add5(3)}");

        // 不可变数据流：使用 LINQ 构建纯函数管道
        var pipeline = new Func<int[], int[]>(
            data => data
                .Where(x => x > 0)         // 过滤正数
                .Select(x => x * x)          // 平方
                .OrderBy(x => x)             // 排序
                .Distinct()                  // 去重
                .ToArray());

        var input = new[] { -1, 2, 3, -4, 2, 3, 5 };
        var output2 = pipeline(input);
        Console.WriteLine($"管道处理结果：[{string.Join(", ", output2)}]");
    }
}

4.10 局部函数与闭包

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

/// <summary>
/// 局部函数（Local Functions）示例
/// 演示在 LINQ 查询中封装辅助逻辑，避免闭包开销
/// </summary>
public class LocalFunctionDemo
{
    public static void Run()
    {
        // 场景一：使用局部函数封装复杂查询逻辑
        var numbers = Enumerable.Range(1, 100).ToList();

        // 错误方式：在 lambda 中嵌入复杂逻辑，可读性差
        var badResult = numbers.Where(n =>
        {
            if (n < 2) return false;
            if (n == 2) return true;
            if (n % 2 == 0) return false;
            for (int i = 3; i * i <= n; i += 2)
                if (n % i == 0) return false;
            return true;
        }).ToList();

        // 正确方式：提取为局部函数
        var goodResult = numbers.Where(IsPrime).ToList();

        // 局部函数定义：可读性更好，且可被多处复用
        bool IsPrime(int n)
        {
            if (n < 2) return false;
            if (n == 2) return true;
            if (n % 2 == 0) return false;
            for (int i = 3; i * i <= n; i += 2)
                if (n % i == 0) return false;
            return true;
        }

        Console.WriteLine($"素数数量：{goodResult.Count}");

        // 场景二：静态局部函数避免闭包
        // 非静态局部函数会捕获外部变量，产生闭包分配
        // 静态局部函数禁止捕获，性能更优
        var data = Enumerable.Range(1, 1000).ToList();
        var filtered = data.Where(IsEvenStatic).ToList();  // 使用静态局部函数

        // 静态局部函数：无闭包，性能最优
        static bool IsEvenStatic(int n) => n % 2 == 0;

        // 场景三：递归局部函数
        var fib = Fibonacci(10);
        Console.WriteLine($"斐波那契数列前 10 项：[{string.Join(", ", fib)}]");

        IEnumerable<int> Fibonacci(int count)
        {
            if (count <= 0) yield break;
            yield return 0;
            if (count == 1) yield break;
            yield return 1;

            var a = 0;
            var b = 1;
            for (int i = 2; i < count; i++)
            {
                var c = a + b;
                yield return c;
                a = b;
                b = c;
            }
        }

        // 场景四：局部函数在迭代器中的异常前置
        // 错误：参数检查延迟到枚举时执行
        IEnumerable<int> BadRange(int start, int count)
        {
            if (count < 0) throw new ArgumentOutOfRangeException(nameof(count));
            for (int i = 0; i < count; i++) yield return start + i;
        }

        // 正确：使用局部函数包装，参数检查立即执行
        IEnumerable<int> GoodRange(int start, int count)
        {
            if (count < 0) throw new ArgumentOutOfRangeException(nameof(count));
            return GoodRangeImpl(start, count);

            IEnumerable<int> GoodRangeImpl(int s, int c)
            {
                for (int i = 0; i < c; i++) yield return s + i;
            }
        }
    }
}

5. 对比分析

5.1 LINQ 与传统命令式循环对比

5.2 IEnumerable 与 IQueryable 对比

5.3 函数式范式与面向对象范式对比

5.4 查询语法与方法语法选择策略

// 场景一：简单查询 —— 方法语法更简洁
var result1 = users.Where(u => u.Age > 18).Select(u => u.Name);

// 场景二：多表连接 —— 查询语法更清晰
var result2 = from u in users
              join d in departments on u.DeptId equals d.Id
              where u.Age > 18
              select new { u.Name, d.Name as DeptName };

// 场景三：复杂分组 —— 查询语法更易读
var result3 = from u in users
              group u by u.Department into g
              where g.Count() > 5
              select new { Dept = g.Key, Count = g.Count() };

// 场景四：链式自定义运算符 —— 方法语法必需
var result4 = users.Where(...).Batch(100).Select(...);

5.5 与其他语言查询机制对比

6. 常见陷阱与反模式

6.1 多次枚举导致重复计算

生产事故案例：某电商系统在订单统计模块中，对同一个 IEnumerable 查询进行了多次枚举（Count、Sum、ToList），导致数据库被查询了 4 次，高峰期数据库连接池耗尽。

// 反模式：多次枚举同一查询
public class BadStatsService
{
    public void Process(IEnumerable<Order> orders)
    {
        Console.WriteLine($"订单总数：{orders.Count()}");                    // 第一次枚举
        Console.WriteLine($"总金额：{orders.Sum(o => o.Amount)}");          // 第二次枚举
        Console.WriteLine($"最大金额：{orders.Max(o => o.Amount)}");        // 第三次枚举

        foreach (var o in orders) { /* ... */ }                             // 第四次枚举
    }
}

// 正确模式：一次性物化，后续复用
public class GoodStatsService
{
    public void Process(IEnumerable<Order> orders)
    {
        var list = orders.ToList();  // 一次性物化
        Console.WriteLine($"订单总数：{list.Count}");
        Console.WriteLine($"总金额：{list.Sum(o => o.Amount)}");
        Console.WriteLine($"最大金额：{list.Max(o => o.Amount)}");
        foreach (var o in list) { /* ... */ }
    }
}

6.2 闭包捕获循环变量

经典陷阱：在循环中创建 lambda 时捕获循环变量，所有 lambda 引用的是同一个变量，导致结果与预期不符。

// 反模式：捕获循环变量
public List<Func<int>> BadClosure()
{
    var funcs = new List<Func<int>>();
    for (int i = 0; i < 5; i++)
    {
        funcs.Add(() => i);  // 所有 lambda 捕获同一个 i
    }
    return funcs;
    // 调用 funcs[0]() 到 funcs[4]() 全部返回 5
}

// 正确模式：在循环内创建局部变量
public List<Func<int>> GoodClosure()
{
    var funcs = new List<Func<int>>();
    for (int i = 0; i < 5; i++)
    {
        int local = i;  // 每次迭代创建新变量
        funcs.Add(() => local);
    }
    return funcs;
    // C# 5.0+ 中 foreach 已修复此问题，但 for 循环仍需注意
}

6.3 在 Where 中执行副作用

反模式：在 Where 谓词中执行 IO 操作或修改状态，破坏纯函数性与延迟执行语义。

// 反模式：Where 中执行数据库查询
var result = users.Where(u =>
{
    var orders = db.GetOrders(u.Id);  // 副作用：N+1 查询问题
    return orders.Count > 0;
}).ToList();

// 正确模式：先获取所需数据，再在内存中过滤
var userIdsWithOrders = db.GetOrders().Select(o => o.UserId).ToHashSet();
var result = users.Where(u => userIdsWithOrders.Contains(u.Id)).ToList();

6.4 在 EF Core 中使用无法翻译的方法

生产事故：EF Core 3.0+ 默认不再自动客户端求值，调用无法翻译的方法会抛出异常。

// 反模式：自定义方法无法翻译为 SQL
var result = dbContext.Users
    .Where(u => IsValidUser(u))  // EF Core 无法翻译，抛出异常
    .ToList();

// 正确模式：将逻辑内联为可翻译的表达式
var result = dbContext.Users
    .Where(u => u.IsActive && u.Age >= 18 && u.Email != null)
    .ToList();

6.5 OrderBy 后再 Where 的性能陷阱

// 反模式：先排序后过滤，对全量数据排序
var result = users.OrderBy(u => u.Name).Where(u => u.Age > 18).ToList();

// 正确模式：先过滤后排序，减少排序数据量
var result = users.Where(u => u.Age > 18).OrderBy(u => u.Name).ToList();

6.6 SelectMany 导致笛卡尔积爆炸

// 反模式：未限制的 SelectMany 可能导致结果集爆炸
var allCombinations = users.SelectMany(u => products.Select(p => (u, p)));
// 若 users 有 10000 条，products 有 1000 条，结果为 1000 万条

// 正确模式：添加限制条件
var validCombinations = users
    .SelectMany(u => products.Where(p => p.SuitableFor(u)).Take(10).Select(p => (u, p)));

6.7 使用 First 而非 FirstOrDefault 导致异常

// 反模式：未处理空序列场景
var user = users.First(u => u.Id == targetId);  // 若不存在则抛异常

// 正确模式：使用 FirstOrDefault + 空检查
var user = users.FirstOrDefault(u => u.Id == targetId);
if (user == null) throw new KeyNotFoundException($"用户 {targetId} 不存在");

6.8 ToList 滥用导致内存峰值

// 反模式：在管道中间多次 ToList，浪费内存
var result = source
    .Where(x => x > 0)
    .ToList()                    // 不必要的物化
    .Select(x => x * 2)
    .ToList()                    // 不必要的物化
    .Where(x => x > 10)
    .ToList();

// 正确模式：只在最终需要时物化
var result = source
    .Where(x => x > 0)
    .Select(x => x * 2)
    .Where(x => x > 10)
    .ToList();                   // 仅最后一次物化

7. 工程实践

7.1 生产级 LINQ 查询封装

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

/// <summary>
/// 生产级分页查询封装
/// 统一处理分页、排序、过滤等通用需求
/// </summary>
public class PagedQuery<T>
{
    public int PageIndex { get; set; } = 1;
    public int PageSize { get; set; } = 20;
    public string? SortField { get; set; }
    public bool SortDescending { get; set; }
    public Expression<Func<T, bool>>? Filter { get; set; }
}

/// <summary>
/// 分页结果
/// </summary>
public class PagedResult<T>
{
    public IReadOnlyList<T> Items { get; init; } = Array.Empty<T>();
    public int TotalCount { get; init; }
    public int PageIndex { get; init; }
    public int PageSize { get; init; }
    public int TotalPages => (int)Math.Ceiling(TotalCount / (double)PageSize);
    public bool HasPrevious => PageIndex > 1;
    public bool HasNext => PageIndex < TotalPages;
}

/// <summary>
/// 查询执行器：封装分页查询的通用逻辑
/// </summary>
public static class QueryExecutor
{
    /// <summary>
    /// 执行分页查询
    /// 性能要点：先 Count 再 Skip/Take，避免加载全量数据
    /// </summary>
    public static PagedResult<T> ExecutePaged<T>(
        IQueryable<T> source,
        PagedQuery<T> query)
    {
        // 应用过滤条件
        if (query.Filter != null)
            source = source.Where(query.Filter);

        // 先获取总数（触发一次数据库查询）
        var totalCount = source.Count();

        // 应用排序
        if (!string.IsNullOrEmpty(query.SortField))
            source = ApplySort(source, query.SortField, query.SortDescending);

        // 应用分页
        var items = source
            .Skip((query.PageIndex - 1) * query.PageSize)
            .Take(query.PageSize)
            .ToList();

        return new PagedResult<T>
        {
            Items = items,
            TotalCount = totalCount,
            PageIndex = query.PageIndex,
            PageSize = query.PageSize
        };
    }

    /// <summary>
    /// 动态排序：通过反射构建排序表达式
    /// </summary>
    private static IQueryable<T> ApplySort<T>(
        IQueryable<T> source,
        string fieldName,
        bool descending)
    {
        var param = Expression.Parameter(typeof(T), "x");
        var property = Expression.Property(param, fieldName);
        var lambda = Expression.Lambda(property, param);

        var methodName = descending ? "OrderByDescending" : "OrderBy";
        var method = typeof(Queryable).GetMethods()
            .First(m => m.Name == methodName && m.GetParameters().Length == 2)
            .MakeGenericMethod(typeof(T), property.Type);

        return (IQueryable<T>)method.Invoke(null, new object[] { source, lambda })!;
    }
}