LINQ - 喵~

参考视频：https://www.youtube.com/watch?v=7-P6Mxl5elg

1
dotnet add console
2

3
dotnet add package Dumpify # Dump函数，能很方便的打印集合

LINQ有两种执行方式：延迟执行 | Differred Execution 与立即执行 | Immediate Execution。本文使用 [DE] 与 [IE] 标注

筛选 | Filtering#

Where [DE]：通用筛选#

1
IEnumerable<int> collection = [1, 2, 3, 4, 5];
2

3
collection.Where(x => x >= 2).Dump();

OfType [DE]：类型筛选#

1
IEnumerable<object> collection = [1, "Hi", 3.14, 4, 5];
2

3
collection.OfType<string>().Dump(); // 会自动转换类型为 IEnumerable<string>

分区 | Partitioning#

Skip [DE]，Take [DE]，SkipLast [DE] 与 TakeLast [DE]#

1
IEnumerable<int> collection = [1, 2, 3, 4, 5];
2

3
collection.Take(3).Dump();
4
collection.Skip(3).Dump();
5

6
collection.SkipLast(3).Dump("SkipLast");
7
collection.TakeLast(3).Dump("TakeLast");

SkipWhile [DE] 与 TakeWhile [DE]#

1
IEnumerable<int> collection = [1, 2, 3, 1, 1];
2

3
collection.SkipWhile(x => x < 3).Dump("SkipWhile");     // skip 1 2 3
4
collection.TakeWhile(x => x <= 3).Dump("TakeWhile");    // take 1 2 3

SkipWhile 与 TakeWhile 均为前缀过滤（只要开头一段符合条件的）

投影 | Projection#

将数据映射为另一种形式

Select [DE]#

1
IEnumerable<int> collection = [1, 2, 3, 4, 5];
2

3
collection.Select(x => x < 3).Dump("Select"); // 这里返回的是true/false集合
4
collection.Select((x, i) => $"{i}: {x}").Dump("Select with index"); // 带索引

SelectMany [DE]：展平#

1
IEnumerable<List<int>> collection = [
2
    [1, 2, 3, 4, 5],
3
    [1, 2, 3, 4],
4
    [1, 2, 3, 4, 5, 6]
5
];
6

7
collection.SelectMany(x => x).Dump("SelectMany");
8
collection
9
    .SelectMany(
10
        (list, listIndex)
11
            => list.Select(element
12
                => $"{listIndex}: {element}".ToString()
13
            )
14
        )
15
    .Dump("SelectMany with index");

Cast [DE]：类型转换#

1
IEnumerable<object> collection = [1, 2, 3, 4, 5];
2

3
collection.Cast<int>().Dump();

Chunk [DE]：切分#

1
IEnumerable<int> collection = [1, 2, 3, 4, 5, 6, 7];
2

3
collection.Chunk(3).Dump();

检查 | Check#

Any [IE]，与 All [IE]#

1
IEnumerable<int> collection = [1, 2, 3, 4, 5];
2

3
collection.Any(x => x > 3).Dump(); // True
4
collection.All(x => x > 3).Dump(); // False

Contains [IE]#

1
IEnumerable<int> collection = [1, 2, 3, 4, 5];
2

3
collection.Contains(3).Dump();

这个功能也可以用 Any(x => x == 3) 实现，但是 Contains 会优先走集合优化（哈希查找），Any 一直是 foreach

序列操作 | Sequence Manipulation#

Append [DE] 与 Prepend [DE]：插入#

1
IEnumerable<int> collection = [1, 2, 3, 4, 5];
2

3
collection.Append(6).Prepend(0).Dump();

聚合 | Aggregation#

Count [IE]， TryGetNonEnumeratedCount [IE] 与 LongCount [IE]：计数#

1
IEnumerable<int> collection = [1, 2, 3, 4, 5];
2

3
collection.Count().Dump(); // 5
4
collection.Where(x => x >= 2).TryGetNonEnumeratedCount(out var count).Dump(); // False
5
count.Dump(); // 0

一般的 Count 会优先调取集合的 Length 属性，但是有些集合没有这个属性，Count 就只能遍历了（）
如果不想遍历可以用 TryGetNonEnumeratedCount ~~神秘的名字~~
如果需要返回值为 long，使用 LongCount

Max [IE]，MaxBy [IE]，Min [IE] 与 MinBy [IE]：最值#

1
IEnumerable<int> collection = [-2, -1, 0, 1, 2];
2

3
collection.Max().Dump(); // 2
4
collection.Max(x => -Math.Pow(x, 2) + 1).Dump(); // 1
5
collection.MaxBy(x => -Math.Pow(x, 2) + 1).Dump(); // 0

Max 返回投影结果，MaxBy 根据投影结果返回对应原始元素¹
Min 与 MinBy 同理，不展示

Sum [IE] 与 Average [IE]#

1
IEnumerable<int> collection = [-2, -1, 0, 1, 2];
2

3
collection.Sum().Dump();
4
collection.Average().Dump();

Aggregate [IE]#

1
IEnumerable<int> collection = [1, 2, 3, 4, 5, 6];
2

3
collection
4
    .Aggregate(
5
        (accumulator, element) => accumulator + element
6
    )
7
    .Dump(); // 等价Sum()

1
collection
2
    .Select(x => x.ToString())
3
    .Aggregate(
4
        new StringBuilder("["),
5
        (sb, x) =>
6
        {
7
            if (sb.Length > 1) sb.Append(", ");
8
            sb.Append(x);
9
            return sb;
10
        },
11
        sb => sb.Append(']')
12
    )
13
    .Dump();

Aggregate 能接收三个参数：seed func resultSelector。（累加器初值累加器最终结果）
emm目前还没在实战中找到太多用处，但感觉这个用好了会很方便..?

元素操作 | Element Operators#

First [IE]，FirstOrDefault [IE]，Last [IE] 与 LastOrDefault [IE]#

1
IEnumerable<int> collection = [1, 2, 3, 4, 5, 6];
2
IEnumerable<int> empty = [];
3

4
collection.First().Dump(); // 1
5
empty.FirstOrDefault().Dump(); // default(int)
6
empty.FirstOrDefault(666).Dump(); // default(int)
7

8
collection.Last().Dump(); // 6

集合为空时，First 会抛异常，FirstOrDefault 返回该类型默认值或者是指定的。Last 同理

Single [IE] SingleOrDefault [IE]#

1
IEnumerable<int> collection = [1, 2, 3, 4, 5, 6];
2
IEnumerable<int> single = [1];
3
IEnumerable<int> empty = [];
4

5

6
collection.Single().Dump(); // System.InvalidOperationException
7
single.Single().Dump(); // 1
8
empty.SingleOrDefault(123).Dump(); // 123

Single 只能用于只有一个元素的集合

ElementAt [IE] 与 ElementAtOrDefault [IE]#

1
IEnumerable<int> collection = [1, 2, 3, 4, 5, 6];
2

3
collection.ElementAt(1).Dump(); // 2
4
collection.ElementAt(4).Dump(); // 5
5
collection.ElementAtOrDefault(8).Dump(); // default(int)

DefaultIfEmpty [DE]#

1
IEnumerable<int> empty = [];
2

3
empty.DefaultIfEmpty().Dump(); // default(int)

不会 Append，只是在集合为空时返回默认值

Conversion | 转换#

ToList [IE]，ToArray [IE]，ToDictionary [IE]，ToHashSet [IE] 与 ToLookup [IE]#

1
IEnumerable<int> collection = [1, 2, 3, 4, 5, 6];
2

3
collection.ToList().Dump();
4
collection.ToArray().Dump();
5
collection.ToDictionary(key => key, value => value).Dump();

1
IEnumerable<Person> people = [
2
    new("A", 15),
3
    new("B", 20),
4
    new("C", 20),
5
];
6

7
people
8
    .ToLookup(p => p.Age)   // Lookup<int, Person>
9
    [20]                    // Grouping<int, Person>
10
    .Dump();
11

12
record Person(string Name, int Age);

Generation | 生成#

AsEnumerable [DE] 与 AsQueryable [DE]#

1
List<int> collection = [1, 2, 3, 4, 5];
2

3
var foo = collection.AsEnumerable();
4
var bar = collection.AsQueryable();

Range [IE]，Repeat [IE] 与 Empty [IE]#

1
IEnumerable<int> collection = Enumerable.Range(1, 100); // (start, count)
2
collection.Dump(); // 1 到 100 的整数
3

4
collection = Enumerable.Repeat(1, 100);
5
collection.Dump(); // 100个1
6

7
collection = Enumerable.Empty<int>(); // Empty 为静态方法，不会 new 实例
8
// collection = []; // C# 12以上有了集合表达式，都用这个了（）
9
collection.Dump(); // []

集合操作 | Set Operations#

Distinct [DE] 与 DistinctBy [DE]：去重#

1
IEnumerable<int> collection = [1, 2, 3, 4, 5, 1, 1, 2];
2

3
collection.Distinct().Dump();
4

5
IEnumerable<Person> people = [
6
    new("A", 16),
7
    new("B", 15),
8
    new("C", 15),
9
    new("D", 18),
10
];
11

12
people.DistinctBy(p => p.Age).Dump();
13

14
record Person(string Name, int Age);

Union [DE]，Intersect [DE]，Except [DE]，UnionBy [DE]，IntersectBy [DE] 与 ExceptBy [DE]：集合运算#

1
IEnumerable<int> collection1 = [1, 2, 3];
2
IEnumerable<int> collection2 = [2, 3, 4];
3

4
collection1.Union(collection2).Dump(); // 1, 2, 3, 4
5
collection1.Intersect(collection2).Dump(); // 2, 3
6
collection1.Except(collection2).Dump(); // 1

By 方法同上

SequenceEqual [IE]：序列相等#

1
IEnumerable<int> collection1 = [1, 2, 3];
2
IEnumerable<int> collection2 = [1, 2, 3];
3
IEnumerable<int> collection3 = [1, 2, 3, 4];
4

5
collection1.SequenceEqual(collection2).Dump(); // true
6
collection1.SequenceEqual(collection3).Dump(); // false

合并与分组 | Joinng and Grouping#

Zip [DE]：配对组装#

1
IEnumerable<int> collection1 = [1, 2, 3];
2
IEnumerable<string> collection2 = ["a", "b", "c", "d"];
3

4
collection1.Zip(collection2).Dump(); // (1, "a"), (2, "b"), (3, "c")

Join [DE] 与 GroupJoin [DE]#

1
IEnumerable<Person> people = [
2
    new(1, "Alice", 30),
3
    new(2, "Bob", 25),
4
    new(3, "Charlie", 35)
5
];
6
IEnumerable<Product> products = [
7
    new(1, 1, "Product A"),
8
    new(2, 1, "Product B"),
9
    new(3, 2, "Product C"),
10
    new(4, 3, "Product D")
11
];
12

13
people.Join(
14
    products,
15
    person => person.Id,
16
    product => product.PersonId,
17
    (person, product) => $"{person.Name} bought {product.Name}"
18
    )
19
    .Dump();
20

21
people.GroupJoin(
22
    products,
23
    person => person.Id,
24
    product => product.PersonId,
25
    (person, products) => $"{person.Name} bought {string.Join(',', products.Select(p => p.Name))}"
26
    )
27
    .Dump();
28

29
record Person(int Id, string Name, int Age);
30
record Product(int Id, int PersonId, string Name);

Concact [DE]#

1
IEnumerable<int> collection1 = [1, 2, 3];
2
IEnumerable<int> collection2 = [4, 5];
3

4
collection1.Concat(collection2).Dump();

GroupBy [DE]#

1
IEnumerable<Person> people = [
2
    new(1, "Alice", 30),
3
    new(2, "Bob", 25),
4
    new(3, "Charlie", 25)
5
];
6

7
people.GroupBy(p => p.Age).Dump();
8

9
record Person(int Id, string Name, int Age);

排序 | Sorting#

Order [DE]，OrderBy [DE]，OrderDescending [DE] 与 OrderByDescending [DE]#

1
IEnumerable<int> collection = [3, 1, 2, 4];
2

3
collection.Order().Dump();

Descending 与 By 方法使用略

ThenBy [DE] 与 ThenByDescending#

1
IEnumerable<FinancialSheetItem> sheet = [
2
    new(2, 28, 2500m),
3
    new(1, 15, 1000m),
4
    new(2, 15, 2000m),
5
    new(1, 30, 1500m),
6
    new(1, 30, 500m),
7
    new(3, 15, 1000m),
8
];
9

10
sheet
11
    .OrderBy(i => i.Month)
12
    .ThenBy(i => i.Date)
13
    .ThenByDescending(i => i.Amount)
14
    .Dump();
15

16
record FinancialSheetItem(int Month, int Date, decimal Amount);

Reverse [DE]：翻转#

1
IEnumerable<int> collection = [1, 2, 3, 4];
2

3
collection.Reverse().Dump();

PLINQ#

AsParallel
WithDegreeOfParallelism
WithExecutionMode
WithMergeOptions
AsOrdered

除了返回值不同，By方法还有另一种语义，就是根据某个对象的某个属性，参考这里 ↩