1
// 命令式（告诉计算机"怎么做"）
2
var results = new List<string>();
3
foreach (var player in players)
4
{
5
    if (player.Score > 1000)
6
    {
7
        results.Add(player.Name.ToUpper());
8
    }
9
}
10
results.Sort();
11

12
// 声明式（告诉计算机"我要什么"）
13
var results = players
14
    .Where(p => p.Score > 1000)
15
    .Select(p => p.Name.ToUpper())
16
    .OrderBy(n => n)
17
    .ToList();

1
// === 你写的 ===
2
IEnumerable<int> GetNumbers()
3
{
4
    yield return 1;
5
    yield return 2;
6
    yield return 3;
7
}
8

9
// === 编译器生成的（反编译简化） ===
10
class GetNumbers_d__0 : IEnumerator<int>
11
{
12
    private int __state;     // 状态机位置（-2: 初始, 0~2: 各 yield, -1: 结束）
13
    private int __current;   // 当前值
14

15
    public bool MoveNext()
16
    {
17
        switch (__state)
18
        {
19
            case 0:
20
                __current = 1;   // yield return 1
21
                __state = 1;
22
                return true;
23
            case 1:
24
                __current = 2;   // yield return 2
25
                __state = 2;
26
                return true;
27
            case 2:
28
                __current = 3;   // yield return 3
29
                __state = -1;
30
                return true;
31
            default:
32
                return false;    // 结束
33
        }
34
    }
35

36
    public int Current => __current;
37
    // ... Reset, Dispose 等省略
38
}

1
// ❌ 直觉陷阱：LINQ 返回的不是"结果集合"，而是"查询计划"
2
var query = players.Where(p => p.Score > 1000);
3
// 此时没有任何遍历！Where 返回的是一个迭代器对象
4

5
// 只有"消费"时，查询才真正执行：
6
foreach (var p in query) { }  // ← 此时才遍历
7
var list = query.ToList();    // ← 此时才遍历
8
int count = query.Count();    // ← 此时才遍历（而且是重新遍历！）
9

10
// ⚠️ 最经典的坑：两次遍历
11
var highScores = players.Where(p => p.Score > 1000);
12
Console.WriteLine($"人数: {highScores.Count()}");  // 第一次遍历
13
foreach (var p in highScores)                       // 第二次遍历！
14
{
15
    Process(p);
16
}

1
// 你写的 LINQ 链：
2
var result = data
3
    .Where(x => x > 0)
4
    .Select(x => x * 2);
5

6
// 编译器生成的等价代码(简化)：
7
// Where 迭代器包装原始迭代器，Select 迭代器包装 Where 迭代器
8
class WhereIterator : IEnumerable<int>
9
{
10
    private IEnumerable<int> _source;  // 指向 data
11
    private Func<int, bool> _predicate;
12

13
    public IEnumerator<int> GetEnumerator()
14
    {
15
        foreach (var item in _source)       // 遍历 data
16
            if (_predicate(item))            // 执行 x > 0
17
                yield return item;           // 产出满足条件的
18
    }
19
}
20

21
class SelectIterator : IEnumerable<int>
22
{
23
    private IEnumerable<int> _source;  // 指向 WhereIterator
24
    private Func<int, int> _selector;
25

26
    public IEnumerator<int> GetEnumerator()
27
    {
28
        foreach (var item in _source)       // 遍历 WhereIterator
29
            yield return _selector(item);    // 执行 x * 2
30
    }
31
}
32

33
// 调用链：
34
// foreach → SelectIterator.GetEnumerator()
35
//         → MoveNext → WhereIterator.GetEnumerator()
36
//                     → MoveNext → data.GetEnumerator()
37
//                                → MoveNext → 返回原始元素
38
//                     → 检查 predicate
39
//         → 执行 selector
40
//         → 返回最终结果
41

42
// 结论：每一次迭代都要穿越整条调用链。链越长，每元素的开销越大。
43
// 但这是 O(元素数 × 链长度)，不是 O(元素数²)，因为每层只是多了一次虚调用

1
// GroupBy 是缓冲操作 —— 面试重点
2
// 和 Where/Select 不同，GroupBy 必须在第一次 MoveNext 时读取全部源数据
3
var groups = data.GroupBy(x => x.Category);
4
// ↑ 此时还没有遍历！
5

6
foreach (var group in groups)  // ← 第一次 MoveNext 时，GroupBy 内部：
7
{
8
    // 1. 遍历整个 data，填充内部 Dictionary<TKey, List<T>>
9
    // 2. 把分组结果缓存起来
10
    // 3. 以后每次 MoveNext 直接从 Dictionary 中取
11
}
12

13
// 为什么 GroupBy 必须缓冲？
14
// 因为你在遍历第一个组时，还没读到的元素可能属于第一个组！
15
// 不读完整个源数据，GroupBy 不敢确定每个组有哪些成员。
16
//
17
// OrderBy / Reverse / ToList 同理 —— 它们都是"缓冲"操作

1
// IEnumerable<T> 的 Where：在内存中遍历过滤
2
// IQueryable<T> 的 Where：构建表达式树，由 Provider 最终翻译执行
3

4
// 关键区别：
5
IEnumerable<Player> memQuery = players.Where(p => p.Score > 1000);
6
// → 编译器生成委托: Func<Player, bool>
7
// → 运行时在内存中逐一遍历过滤
8

9
IQueryable<Player> dbQuery = db.Players.Where(p => p.Score > 1000);
10
// → 编译器生成表达式树: Expression<Func<Player, bool>>
11
// → Provider (EF Core) 遍历表达式树 → 翻译为 SQL：
12
//   SELECT * FROM Players WHERE Score > 1000
13

14
// IQueryable 的核心：Expression Tree 提供了"看一眼代码结构"的能力
15
// 这就是为什么 db.Players.Where(...).Select(...).ToList()
16
// 可以被整体翻译为一条 SQL，而不是 N+1 查询

1
// 表达式树的递归遍历：自己实现一个简单的 Where 翻译器
2
string TranslateWhere<T>(Expression<Func<T, bool>> predicate)
3
{
4
    if (predicate.Body is BinaryExpression bin)
5
    {
6
        string left = GetMemberName(bin.Left);   // 如 "Score"
7
        string op = bin.NodeType switch          // 如 GreaterThan
8
        {
9
            ExpressionType.GreaterThan => ">",
10
            ExpressionType.Equal => "=",
11
            _ => "??"
12
        };
13
        object right = GetConstantValue(bin.Right); // 如 1000
14
        return $"{left} {op} {right}";
15
    }
16
    return string.Empty;
17
}
18

19
var sql = TranslateWhere<Player>(p => p.Score > 1000);
20
// sql = "Score > 1000"

1
// === 第一层：延迟执行（返回 IEnumerable） ===
2
// 这些操作符不触发遍历，只构建查询链
3
players.Where(p => p.Score > 1000)              // 过滤
4
       .Select(p => p.Name)                      // 投影
5
       .SelectMany(p => p.Items)                 // 扁平化
6
       .Take(10)                                 // 取前 N 个
7
       .Skip(5)                                  // 跳过 N 个
8
       .Distinct()                               // 去重
9
       .OrderBy(p => p.Score)                    // 排序（但这是"延迟"的吗？）
10

11
// ⚠️ 注意：OrderBy 也是延迟的！但它是"缓冲"操作——
12
//       它需要读取全部数据才能排序，所以第一次 MoveNext 时会遍历整个源
13

14
// === 第二层：立即执行（返回具体类型） ===
15
players.Count()                                  // 遍历后返回 int
16
players.ToList()                                 // 遍历后返回 List
17
players.ToArray()                                // 遍历后返回 Array
18
players.First()                                  // 取第一个（源为空抛异常）
19
players.FirstOrDefault()                         // 取第一个（源为空返回 default）
20
players.Any(p => p.Score > 1000)                 // 是否存在
21
players.All(p => p.IsAlive)                      // 是否全部满足

1
// SelectMany 将嵌套结构"拍平"
2
class Player
3
{
4
    public string Name;
5
    public List<Item> Inventory;  // 每个玩家有一个物品列表
6
}
7

8
// 任务：获取所有玩家的所有物品（扁平列表）
9
// 不用 LINQ：
10
var allItems = new List<Item>();
11
foreach (var p in players)
12
    foreach (var item in p.Inventory)
13
        allItems.Add(item);
14

15
// 用 SelectMany：一行搞定
16
var allItems = players.SelectMany(p => p.Inventory).ToList();
17

18
// SelectMany 内部等价于：
19
IEnumerable<Item> SelectMany_Impl(IEnumerable<Player> players)
20
{
21
    foreach (var p in players)
22
        foreach (var item in p.Inventory)
23
            yield return item;  // 一个 yield return 搞定两层嵌套
24
}

1
// Lambda 的两个身份：
2
// 1. 委托（Func<T>）    → 编译为 IL，可以直接执行
3
// 2. 表达式树（Expression<T>） → 编译为数据结构，描述表达式的 AST
4

5
// 同一个 Lambda，取决于目标类型：
6
Func<int, bool> isEven = x => x % 2 == 0;         // 委托
7
Expression<Func<int, bool>> expr = x => x % 2 == 0; // 表达式树
8

9
// 表达式树的内部结构（简化示意）：
10
// LambdaExpression
11
//   ├── Parameters: [ParameterExpression("x")]
12
//   └── Body: BinaryExpression(Equal)
13
//       ├── Left: BinaryExpression(Modulo)
14
//       │   ├── Left: ParameterExpression("x")
15
//       │   └── Right: ConstantExpression(2)
16
//       └── Right: ConstantExpression(0)
17

18
// 表达式树的作用：让代码可以被程序化地分析、转换、执行
19
// 这是 Entity Framework 的核心机制：
20
// db.Players.Where(p => p.Score > 1000)
21
// ↑ 这里的 Lambda 被编译为 Expression，然后被 EF 翻译为 SQL

1
// 两种语法，底层完全等价（编译器将查询语法翻译为方法调用）
2

3
// 查询语法（像 SQL）
4
var result = from p in players
5
             where p.Score > 1000
6
             orderby p.Score descending
7
             select p.Name;
8

9
// 方法语法（Lambda + 扩展方法）
10
var result = players
11
    .Where(p => p.Score > 1000)
12
    .OrderByDescending(p => p.Score)
13
    .Select(p => p.Name);
14

15
// 编译器将查询语法翻译为方法语法（反编译结果完全一样）
16
// 哪些功能查询语法不支持？
17
// - Take / Skip / Distinct
18
// - 自定义扩展方法
19
// → 方法语法是 LINQ 的"完整版"

1
// ❌ 经典陷阱：LINQ 中的 Lambda 也受闭包影响
2
var filters = new List<Func<int, bool>>();
3
var thresholds = new[] { 10, 20, 30 };
4

5
// ❌ 所有 filter 共享同一个 t → 全部用 30
6
foreach (var t in thresholds)  // C# 5+ foreach 修复了这个问题
7
    filters.Add(x => x > t);
8

9
// ✅ 安全写法（防御性）：
10
foreach (var t in thresholds)
11
{
12
    int local = t;
13
    filters.Add(x => x > local);
14
}
15

16
// 或者用 LINQ 本身避免问题：
17
var filters = thresholds.Select<int, Func<int, bool>>(t => x => x > t).ToList();
18
// ↑ 每个 Select 迭代，t 是不同的参数绑定

1
// ❌ Update 中使用 LINQ —— 分配迭代器 + Lambda 委托
2
void Update()
3
{
4
    var alive = enemies.Where(e => e.HP > 0).ToList();
5
    // 堆分配：Where 迭代器对象 + ToList 的新 List + Lambda 委托（如果没缓存）
6
}
7

8
// ✅ 手动遍历，零分配（在预分配的 List 上工作）
9
private List<Enemy> _aliveCache = new(64);
10

11
void Update()
12
{
13
    _aliveCache.Clear();
14
    foreach (var e in enemies)
15
        if (e.HP > 0)
16
            _aliveCache.Add(e);
17
}

1
class SkillNode
2
{
3
    public int ID;
4
    public string Name;
5
    public int RequiredLevel;
6
    public List<int> PrerequisiteIDs;  // 前置技能 ID
7
    public bool Unlocked;
8
}
9

10
// 获取玩家可解锁的技能（所有前置技能都已解锁）
11
var unlockable = skillTree
12
    .Where(s => !s.Unlocked)
13
    .Where(s => s.PrerequisiteIDs.All(preId =>
14
        skillTree.Any(pre => pre.ID == preId && pre.Unlocked)))
15
    .OrderBy(s => s.RequiredLevel)
16
    .ToList();

1
class InventoryItem
2
{
3
    public int ItemID;
4
    public string Category;   // "Weapon", "Potion", "Material"
5
    public int Count;
6
    public int Price;
7
}
8

9
// 按类别统计总价值
10
var categoryValue = inventory
11
    .GroupBy(i => i.Category)
12
    .Select(g => new {
13
        Category = g.Key,
14
        TotalValue = g.Sum(i => i.Price * i.Count),
15
        ItemCount = g.Count(),
16
        TopItem = g.OrderByDescending(i => i.Price).First().ItemID
17
    })
18
    .OrderByDescending(c => c.TotalValue)
19
    .ToList();

1
// 在场景中查找所有距离玩家 50 米内、生命值低于 30% 的敌人
2
var nearbyWeakEnemies = entities
3
    .OfType<Enemy>()                          // 类型筛选
4
    .Where(e => e.IsAlive)
5
    .Where(e => Vector3.Distance(e.Position, player.Position) < 50f)
6
    .Where(e => (float)e.HP / e.MaxHP < 0.3f)
7
    .OrderBy(e => Vector3.Distance(e.Position, player.Position))
8
    .Take(5)                                   // 最多取 5 个（锁敌上限）
9
    .ToList();
10

11
// ⚠️ Distance 被调用了至少两次（OrderBy 再次计算）
12
// ✅ 优化：先投影，再排序（避免重复计算距离）
13
var withDistance = entities
14
    .OfType<Enemy>()
15
    .Where(e => e.IsAlive)
16
    .Select(e => new { Enemy = e, Dist = Vector3.Distance(e.Position, player.Position) })
17
    .Where(x => x.Dist < 50f)
18
    .Where(x => (float)x.Enemy.HP / x.Enemy.MaxHP < 0.3f)
19
    .OrderBy(x => x.Dist)
20
    .Take(5)
21
    .Select(x => x.Enemy)
22
    .ToList();

1
class Quest
2
{
3
    public int ID;
4
    public string Title;
5
    public List<QuestObjective> Objectives;
6
}
7

8
class QuestObjective
9
{
10
    public string Description;
11
    public int RequiredCount;
12
    public int CurrentCount;
13
    public bool IsCompleted => CurrentCount >= RequiredCount;
14
}
15

16
// 获取所有未完成的任务目标（扁平化）
17
var incompleteObjectives = questLog
18
    .SelectMany(q => q.Objectives, (quest, obj) => new {
19
        QuestTitle = quest.Title,
20
        obj.Description,
21
        obj.RequiredCount,
22
        obj.CurrentCount
23
    })
24
    .Where(o => o.CurrentCount < o.RequiredCount)
25
    .OrderByDescending(o => (float)o.CurrentCount / o.RequiredCount)
26
    .ToList();