C-Enumerable类-之-集合操作

JAY.LIN 收录于 C

2025-03-12 约 8377 字预计阅读 17 分钟

https://bing.ee123.net/img/rand?artid=146182911

C# Enumerable类之集合操作

前言

在 C# 中，System.Linq.Enumerable 类是 LINQ（Language Integrated Query）的核心组成部分，它提供了一系列静态方法，用于操作实现了 IEnumerable 接口的集合。通过这些方法，我们可以轻松地对集合进行查询、转换、排序和聚合等操作。

本文属于中的一个章节，着重介绍 C# Enumerable 类中集合操作这部分的内容。

一、概览

方法	描述	示例
`Concat`	序列合并（不去重）	`list1.Concat(list2);`
`Union` 和 `UnionBy`	序列并集（去重）	`list1.Union(list2);`
`Except` 和 `ExceptBy`	序列差集	`list1.Except(list2);`
`Intersect` 和 `IntersectBy`	序列交集	`list1.Intersect(list2);`

二、 `Concat` ：合并(不去重)

1. 什么是 Concat

Concat 是 LINQ 提供的一个扩展方法，用于将两个序列连接在一起，并返回一个包含所有元素的新序列。需要注意的是， Concat 方法不会去除重复项，如果需要去重可以使用 Union 方法。

2. Concat 方法基本信息

1） Concat

public static IEnumerable<TSource> Concat<TSource>(this IEnumerable<TSource> first,IEnumerable<TSource> second)

参数：
- first ：第一个要连接的序列。
- second ：第二个要连接的序列。
返回值 ： Concat 方法返回一个 IEnumerable<T> 对象，其中 T 是输入序列中元素的类型。

2）工作原理

Concat 方法通过惰性求值和迭代器模式，将两个序列依次遍历并返回一个新的序列，过程中不会创建新的集合对象，而是逐个返回两个序列中的元素。

3）使用场景

适用于合并多个集合、处理流式数据、数据预处理等场景。

3. 使用示例

示例 1：基本连接

假设我们有两个整数列表，我们希望将它们连接在一起形成一个新的列表。

class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3 };
        List<int> list2 = new List<int> { 4, 5, 6 };

        // 使用 Concat 连接两个列表
        var concatenatedList = list1.Concat(list2);
        
        Console.WriteLine(string.Join(",",concatenatedList));
        // 输出：1,2,3,4,5,6
    }
}

示例 2：不同类型的序列

虽然 Concat 方法要求两个序列的元素类型相同，但可以通过泛型和隐式转换来处理不同类型的数据。

class Program
{
    static void Main()
    {
        List<string> list1 = new List<string> { "Apple", "Banana" };
        List<object> list2 = new List<object> { 1, 2.5, true };

        // 使用 Concat 连接两个不同类型的列表
        var concatenatedList = list1.Cast<object>().Concat(list2);

        Console.WriteLine(string.Join(",",concatenatedList));
        // 输出：Apple,Banana,1,2.5,True
    }
}

示例 3：空序列

Concat 方法也可以用于将一个非空序列与一个空序列连接。

class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3 };
        List<int> list2 = new List<int>();

        // 使用 Concat 连接非空序列和空序列
        var concatenatedList = list1.Concat(list2);

        Console.WriteLine(string.Join(",",concatenatedList));
        // 输出：1,2,3
    }
}

示例 4：合并多个集合

当需要合并多个集合时，可以多次使用 Concat 方法，或者使用 Union 方法来去除重复项。

class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3 };
        List<int> list2 = new List<int> { 3, 4, 5, 6 };
        List<int> list3 = new List<int> { 6, 7, 8, 9 };

        // 使用 Concat 合并多个集合
        var concatenatedList = list1.Concat(list2).Concat(list3);

        Console.WriteLine(string.Join(",", concatenatedList));
        // 输出：1,2,3,3,4,5,6,6,7,8,9

        // 使用 Union 去除重复项
        var unionedList = list1.Union(list2).Union(list3);

        Console.WriteLine(string.Join(",", unionedList));
        // 输出：1,2,3,4,5,6,7,8,9
    }
}

示例 5：处理流式数据

由于 Concat 方法采用惰性求值，因此非常适合处理流式数据或无限序列。

class Program
{
    static void Main()
    {
        IEnumerable<int> streamData = GenerateStreamData();
        List<int> additionalData = new List<int> { 10, 20, 30 };

        // 使用 Concat 连接流式数据和附加数据
        var concatenatedStream = streamData.Concat(additionalData);

        // 输出结果
        Console.WriteLine("Concatenated Stream Data (First 10 elements):");
        foreach (var item in concatenatedStream.Take(10))
        {
            Console.Write(item + " ");
        }
    }

    static IEnumerable<int> GenerateStreamData()
    {
        int i = 0;
        while (true)
        {
            yield return i++;
        }
    }
}

输出结果：

Concatenated Stream Data (First 10 elements):
0 1 2 3 4 5 6 7 8 9

示例 6：数据预处理

在某些情况下，你可能需要对数据进行预处理，然后再将其与其他数据连接起来。

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

class Program
{
    static void Main()
    {
        List<int> rawData = new List<int> { 1, 2, 3, 4, 5 };
        List<int> processedData = rawData.Select(x => x * 2).ToList();

        List<int> additionalData = new List<int> { 10, 20, 30 };

        // 使用 Concat 连接预处理后的数据和其他数据
        var concatenatedData = processedData.Concat(additionalData);

        // 输出结果
        Console.WriteLine("Concatenated Data:");
        foreach (var item in concatenatedData)
        {
            Console.Write(item + " ");
        }
    }
}

输出结果：

Concatenated Data:
2 4 6 8 10 10 20 30

4. 注意事项

尽管 Concat 方法非常有用，但在实际应用中也有一些需要注意的地方：

空集合处理 ：如果源集合为空， Concat 方法将返回一个空的结果集。因此，在使用 Concat 方法之前，通常不需要检查集合是否为空。
数据类型一致 ：适用于需要合并的集合对象的数据类型是一样的情况。

三、 `Union` 和 `UnionBy` ：并集(去重)

1. 什么是 Union/UnionBy

Union 是 LINQ 提供的一个扩展方法，用于将两个序列合并成一个新的序列，并去除重复的元素。这个方法非常有用，特别是在需要合并多个集合并确保结果中没有重复项时。
UnionBy 是 .NET 6 及以上版本中引入的一个扩展方法，用于合并两个序列并根据指定的键选择器函数去除重复项。与 Union 方法不同的是， UnionBy 允许你通过一个自定义的键来确定元素是否相同，而不是直接比较整个对象。

2. Union/UnionBy 方法基本信息

1） Union/UnionBy

public static IEnumerable<TSource> Union<TSource>(
    this IEnumerable<TSource> first,
    IEnumerable<TSource> second
)

public static IEnumerable<TSource> Union<TSource>(
    this IEnumerable<TSource> first,
    IEnumerable<TSource> second,
    IEqualityComparer<TSource> comparer
)

参数：
- first ：第一个要合并的序列。
- second ：第二个要合并的序列。
- comparer （可选）：一个 IEqualityComparer<TSource> 实现，用于比较元素是否相等。
返回值 ： Union 方法返回一个 IEnumerable<T> 对象，其中 T 是输入序列中元素的类型。

public static IEnumerable<TSource> UnionBy<TSource, TKey>(
    this IEnumerable<TSource> first,
    IEnumerable<TSource> second,
    Func<TSource, TKey> keySelector
)

public static IEnumerable<TSource> UnionBy<TSource, TKey>(
    this IEnumerable<TSource> first,
    IEnumerable<TSource> second,
    Func<TSource, TKey> keySelector,
    IEqualityComparer<TKey> comparer
)

参数：
- first ：第一个要合并的序列。
- second ：第二个要合并的序列。
- keySelector ：一个函数，用于从每个元素中提取键值。
- comparer （可选）：一个 IEqualityComparer 实现，用于比较键值是否相等。
返回值 ： UnionBy 方法返回一个 IEnumerable<TSource> 对象，其中 TSource 是输入序列中元素的类型。

2）工作原理

Union 方法通过惰性求值和迭代器模式，将两个序列合并成一个新的序列，并在遍历过程中自动去除重复元素。
UnionBy 方法通过指定的键选择器函数从两个序列中提取键值，并根据这些键值合并序列，去除重复项，最终返回一个包含唯一键值元素的新序列。

3）使用场景

适用于合并多个集合、处理流式数据、数据预处理、复杂数据结构合并等场景。

3. 使用示例

示例 1：基本合并

假设我们有两个整数列表，我们希望将它们合并在一起形成一个新的列表，并去除重复项。

class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3 };
        List<int> list2 = new List<int> { 3, 4, 5 };

        // 使用 Union 合并两个列表并去除重复项
        var unionedList = list1.Union(list2);
        Console.WriteLine(string.Join(",", unionedList));// 输出：1,2,3,4,5

        // 使用 UnionBy 合并两个列表并去除重复项
        unionedList = list1.UnionBy(list2, x => x);
        Console.WriteLine(string.Join(",", unionedList));// 输出：1,2,3,4,5
    }
}

在这个例子中，我们使用 Union / UnionBy 方法将两个整数列表合并在一起，并打印了结果。注意，数字 3 只出现了一次。

示例 2：自定义对象

当处理自定义对象时， Union 方法默认使用对象的 Equals 和 GetHashCode 方法来判断元素是否相同。如果你有更复杂的比较需求，可以提供自定义的 IEqualityComparer<T> 实现。

使用默认的 Equals 和 GetHashCode 方法，并不能实现对象内容的比较

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}
class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Charlie", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        // 使用 Union 合并两个列表并去除重复项
        var unionedPeople = list1.Union(list2);

        Console.WriteLine(string.Join(",",unionedPeople));
        // 输出：Alice (30),Bob (25),Charlie (30),Bob (25)
    }
}

重写对象的 Equals 和 GetHashCode 方法，可以实现对象内容的比较。使用 Union 时，默认就会调用重写后的方法判断对象是否相等

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override bool Equals(object obj)
    {
        if (obj is Person other)
        {
            return Name == other.Name && Age == other.Age;
        }
        return false;
    }

    public override int GetHashCode()
    {
        return HashCode.Combine(Name, Age);
    }

    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}
class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Charlie", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        // 使用 Union 合并两个列表并去除重复项
        var unionedPeople = list1.Union(list2);

        Console.WriteLine(string.Join(",",unionedPeople));
        // 输出：Alice (30),Bob (25),Charlie (30)
    }
}

使用自定义的 PersonComparer 来比较 Person 对象，并确保合并后的结果中没有重复项。

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}
class PersonComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        if (x == null || y == null) return false;
        return x.Name == y.Name && x.Age == y.Age;
    }

    public int GetHashCode(Person obj)
    {
        return HashCode.Combine(obj.Name, obj.Age);
    }
}

class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {`在这里插入代码片`
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Charlie", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        // 使用 Union 合并两个列表并去除重复项
        var unionedPeople = list1.Union(list2,new PersonComparer());

        Console.WriteLine(string.Join(",",unionedPeople));
        // 输出：Alice (30),Bob (25),Charlie (30)
    }
}

使用 UnionBy ，通过指定键选择器函数来确定哪些对象应该被视为相同的。并确保合并后的结果中没有重复项。

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}

class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Charlie", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        // 使用 UnionBy 合并两个列表并根据年龄去重
        var unionedPeople = list1.UnionBy(list2, p => p.Age);

        Console.WriteLine(string.Join(",", unionedPeople));
        // 输出：Alice (30),Bob (25)
    }
}

示例 3：处理无限序列

Union / UnionBy 方法采用惰性求值（Lazy Evaluation），这意味着它不会立即执行合并操作，而是等到实际遍历时才会计算结果。这使得 Union / UnionBy 可以处理无限序列或延迟执行复杂的查询。

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

class Program
{
    static void Main()
    {
        IEnumerable<int> infiniteNumbers = Enumerable.Range(0, int.MaxValue).Select(i => i * 2);
        List<int> finiteNumbers = new List<int> { 1, 3, 5 };

        // 使用 Union 合并无限序列和有限序列
        var unionedSequence = infiniteNumbers.Union(finiteNumbers);
		// var unionedSequence = infiniteNumbers.UnionBy(finiteNumbers, x => x);
        
        // 限制输出数量
        Console.WriteLine("Unioned Sequence (First 10 elements):");
        foreach (var item in unionedSequence.Take(10))
        {
            Console.Write(item + " ");
        }
    }
}

输出结果：

Unioned Sequence (First 10 elements):
0 2 4 6 8 10 12 14 16 18

在这个例子中，我们展示了如何使用 Union / UnionBy 方法合并一个无限序列和一个有限序列，并通过 Take 方法限制输出的数量，从而避免无限循环。

示例 4：自定义比较器

当处理复杂的数据结构时，可以通过自定义比较器来实现更灵活的合并逻辑。

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override bool Equals(object obj)
    {
        if (obj is Person other)
        {
            return Name == other.Name && Age == other.Age;
        }
        return false;
    }

    public override int GetHashCode()
    {
        return HashCode.Combine(Name, Age);
    }

    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}

class PersonComparerByName : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        if (x == null || y == null) return false;
        return x.Name == y.Name;
    }

    public int GetHashCode(Person obj)
    {
        return obj.Name?.GetHashCode() ?? 0;
    }
}

class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Alice", Age = 31 },
            new Person { Name = "Charlie", Age = 30 }
        };

        // 使用 Union 合并两个列表并根据名字去重
        var unionedPeople = list1.Union(list2, new PersonComparerByName());

        Console.WriteLine(string.Join(",", unionedPeople));
        // 输出：Alice (30),Bob (25),Charlie (30)
    }
}

在这个例子中，我们展示了如何使用自定义的 PersonComparerByName 来根据名字去重合并 Person 对象。

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}

class CustomAgeComparer : IEqualityComparer<int>
{
    public bool Equals(int x, int y)
    {
        // 自定义比较逻辑：年龄相差不超过1岁视为相同
        return Math.Abs(x - y) <= 1;
    }

    public int GetHashCode(int obj)
    {
        return 0;
    }
}

class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Charlie", Age = 30 },
            new Person { Name = "David", Age = 26 }
        };

        // 使用 UnionBy 合并两个列表并根据年龄和自定义比较器去重
        var unionedPeople = list1.UnionBy(list2, p => p.Age, new CustomAgeComparer());

        Console.WriteLine(string.Join(",", unionedPeople));
        // 输出：Alice (30),Bob (25)
    }
}

示例 5：多个集合的合并

当需要合并多个集合时，可以多次使用 Union 方法。

class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3 };
        List<int> list2 = new List<int> { 4, 5, 6 };
        List<int> list3 = new List<int> { 7, 8, 9 };

        // 使用 Union 合并多个集合
        var unionedLists = list1.Union(list2).Union(list3);
		// var unionedLists = list1.UnionBy(list2, x => x).UnionBy(list3, x => x);
		
        Console.WriteLine(string.Join(",", unionedLists));
        // 输出：1,2,3,4,5,6,7,8,9
    }
}

4. 注意事项

尽管 Union / UnionBy 方法非常有用，但在实际应用中也有一些需要注意的地方：

空集合处理 ：如果源集合为空， Union / UnionBy 方法将返回一个空的结果集。因此，在使用 Union / UnionBy 方法之前，通常不需要检查集合是否为空。
数据类型一致 ：适用于需要合并的集合对象的数据类型是一样的情况。

四、 `Except` 和 `ExceptBy` ：差集

1. 什么是 Except/ExceptBy

Except 方法用于计算两个序列的差集，即返回第一个序列中存在但第二个序列中不存在的所有元素。默认情况下，它使用对象的默认比较器（如 EqualityComparer.Default）来比较元素是否相等。你也可以提供自定义的比较器来控制比较逻辑。
ExceptBy 是 .NET 6 及以上版本中引入的一个扩展方法，用于计算两个序列的差集，但与 Except 不同的是，它允许你通过指定的键选择器函数来确定元素是否相同。这意味着你可以根据某个特定属性或计算结果来进行差集操作，而不是直接比较整个对象。

2. Except/ExceptBy 方法基本信息

1） Except/ExceptBy

public static IEnumerable<TSource> Except<TSource>(
    this IEnumerable<TSource> first,
    IEnumerable<TSource> second
)

public static IEnumerable<TSource> Except<TSource>(
    this IEnumerable<TSource> first,
    IEnumerable<TSource> second,
    IEqualityComparer<TSource> comparer
)

参数：
- first ：第一个要计算差集的序列。
- second ：第二个要计算差集的序列。
- comparer （可选）：一个 IEqualityComparer<TSource> 实现，用于比较元素是否相等。
返回值 ： Except 方法返回一个 IEnumerable<TSource> 对象，其中 TSource 是输入序列中元素的类型。

public static IEnumerable<TSource> ExceptBy<TSource, TKey>(
    this IEnumerable<TSource> first,
    IEnumerable<TKey> second,
    Func<TSource, TKey> keySelector
)

public static IEnumerable<TSource> ExceptBy<TSource, TKey>(
    this IEnumerable<TSource> first,
    IEnumerable<TKey> second,
    Func<TSource, TKey> keySelector,
    IEqualityComparer<TKey> comparer
)

参数：
- first ：第一个要计算差集的序列。
- second ：第二个要计算差集的序列（注意这里的元素类型是键类型 TKey ）。
- keySelector ：一个函数，用于从每个元素中提取键值。
- comparer （可选）：一个 IEqualityComparer 实现，用于比较键值是否相等。
返回值 ： UnionBy 方法返回一个 IEnumerable<TSource> 对象，其中 TSource 是输入序列中元素的类型。

2）工作原理

Except ：计算两个序列的差集，返回第一个序列中存在但第二个序列中不存在的所有元素，并使用默认或自定义的比较器来判断元素是否相等。
ExceptBy ：根据指定的键选择器函数提取键值，并计算两个序列的差集，返回第一个序列中存在但第二个序列中不存在的所有元素，去除具有相同键值的重复项。

3）使用场景

适用于数据过滤、数据预处理、多个集合的差集计算等场景。

3. 使用示例

示例 1：基本差集计算

假设我们有两个整数列表，我们希望计算第一个列表中存在但第二个列表中不存在的所有元素。

class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3, 4, 5 };
        List<int> list2 = new List<int> { 3, 4, 6 };

        // 使用 Except 计算差集
        var exceptList = list1.Except(list2);
        Console.WriteLine(string.Join(",", exceptList));// 输出：1,2,5

        exceptList = list1.ExceptBy(list2, x => x);
        Console.WriteLine(string.Join(",", exceptList));// 输出：1,2,5
    }
}

示例 2：自定义对象

使用默认的 Equals 和 GetHashCode 方法，并不能实现对象内容的比较

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}

class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };

        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "David", Age = 40 }
        };

        // 使用 Except 计算差集
        var exceptPeople = list1.Except(list2);

        Console.WriteLine(string.Join(",", exceptPeople));
        // 输出：Alice (30),Bob (25),Charlie (35)
    }
}

重写对象的 Equals 和 GetHashCode 方法，可以实现对象内容的比较。使用 Except 时，默认就会调用重写后的方法判断对象是否相等

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override bool Equals(object obj)
    {
        if (obj is Person other)
        {
            return Name == other.Name && Age == other.Age;
        }
        return false;
    }

    public override int GetHashCode()
    {
        return HashCode.Combine(Name, Age);
    }

    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}
class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Charlie", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        // 使用 Except 计算差集
        var exceptPeople = list1.Except(list2);

        Console.WriteLine(string.Join(",", exceptPeople));
        // 输出：Alice (30)
    }
}

使用自定义的 PersonComparer 来比较 Person 对象。

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}
class PersonComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        if (x == null || y == null) return false;
        return x.Name == y.Name && x.Age == y.Age;
    }

    public int GetHashCode(Person obj)
    {
        return HashCode.Combine(obj.Name, obj.Age);
    }
}

class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Charlie", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        // 使用 Except 计算差集并使用自定义比较器
        var exceptPeople = list1.Except(list2, new PersonComparer());

        Console.WriteLine(string.Join(",", exceptPeople));
        // 输出：Alice (30)
    }
}

使用 ExceptBy ，通过指定键选择器函数来确定哪些对象应该被视为相同的。并确保合并后的结果中没有重复项。

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}

class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };
        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "David", Age = 40 }
        };

        // 使用 ExceptBy 计算差集并排除特定年龄
        var exceptPeople = list1.ExceptBy(list2.Select(x => x.Age), p => p.Age);

        Console.WriteLine(string.Join(",", exceptPeople));
        // 输出：Alice (30),Charlie (35)
    }
}

示例 3：处理无限序列

Except / ExceptBy 方法采用惰性求值（Lazy Evaluation），这意味着它不会立即执行合并操作，而是等到实际遍历时才会计算结果。这使得 Except / ExceptBy 可以处理无限序列或延迟执行复杂的查询。

class Program
{
    static void Main()
    {
        IEnumerable<int> infiniteNumbers = Enumerable.Range(0, int.MaxValue).Select(i => i * 2);
        List<int> finiteNumbers = new List<int> { 1, 3, 5 };

        // 使用 Union 合并无限序列和有限序列
        //var unionedSequence = infiniteNumbers.Except(finiteNumbers);
        var unionedSequence = infiniteNumbers.ExceptBy(finiteNumbers, x => x);

        // 限制输出数量
        Console.WriteLine("Unioned Sequence (First 10 elements):");
        foreach (var item in unionedSequence.Take(10))
        {
            Console.Write(item + " ");
        }
    }
}

输出结果：

Unioned Sequence (First 10 elements):
0 2 4 6 8 10 12 14 16 18

在这个例子中，我们展示了如何使用 Except / ExceptBy 方法合并一个无限序列和一个有限序列，并通过 Take 方法限制输出的数量，从而避免无限循环。

示例 4：自定义比较器

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}

class CustomAgeComparer : IEqualityComparer<int>
{
    public bool Equals(int x, int y)
    {
        // 自定义比较逻辑：年龄相差不超过1岁视为相同
        return Math.Abs(x - y) <= 1;
    }

    public int GetHashCode(int obj)
    {
        return 0;
    }
}

class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };

        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Charlie", Age = 30 },
            new Person { Name = "David", Age = 26 }
        };

        // 使用 UnionBy 合并两个列表并根据年龄和自定义比较器去重
        var unionedPeople = list1.ExceptBy(list2.Select(x=>x.Age), p => p.Age, new CustomAgeComparer());

        Console.WriteLine(string.Join(",", unionedPeople));
        // 输出：Charlie (35)
    }
}

示例 5：多个集合的合并

当需要合并多个集合时，可以多次使用 Except/ExceptBy 方法。

class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3, 4, 5 };
        List<int> list2 = new List<int> { 3, 4, 6 };
        List<int> list3 = new List<int> { 4, 7, 8 };

        // 使用 Union 合并多个集合
        //var unionedLists = list1.Except(list2).Except(list3);
         var unionedLists = list1.ExceptBy(list2, x => x).ExceptBy(list3, x => x);

        Console.WriteLine(string.Join(",", unionedLists));
        // 输出：1,2,5
    }
}

4. 注意事项

尽管 Except / ExceptBy 方法非常有用，但在实际应用中也有一些需要注意的地方：

空集合处理 ：如果源集合为空， Except / ExceptBy 方法将返回一个空的结果集。因此，在使用 Except / ExceptBy 方法之前，通常不需要检查集合是否为空。
数据类型一致 ：适用于需要取差集的集合对象的数据类型是一样的情况。

五、 `Intersect` 和 `IntersectBy` ：交集

1. 什么是 Intersect/IntersectBy

Intersect 方法用于计算两个序列的交集，即返回两个序列中共有的所有元素。默认情况下，它使用对象的默认比较器（如 EqualityComparer<T>.Default ）来比较元素是否相等。你也可以提供自定义的比较器来控制比较逻辑。
IntersectBy 是 .NET 6 及以上版本中引入的一个扩展方法，用于计算两个序列的交集，但与 Intersect 不同的是，它允许你通过指定的键选择器函数来确定元素是否相同。这意味着你可以根据某个特定属性或计算结果来进行交集操作，而不是直接比较整个对象。

2. Intersect/IntersectBy 方法基本信息

1） Intersect/IntersectBy

public static IEnumerable<TSource> Intersect<TSource>(
    this IEnumerable<TSource> first,
    IEnumerable<TSource> second
)

public static IEnumerable<TSource> Intersect<TSource>(
    this IEnumerable<TSource> first,
    IEnumerable<TSource> second,
    IEqualityComparer<TSource> comparer
)

参数：
- first ：第一个要计算交集的序列。
- second ：第二个要计算交集的序列。
- comparer （可选）：一个 IEqualityComparer<TSource> 实现，用于比较元素是否相等。
返回值 ： Except 方法返回一个 IEnumerable<TSource> 对象，其中 TSource 是输入序列中元素的类型。

public static IEnumerable<TSource> IntersectBy<TSource, TKey>(
    this IEnumerable<TSource> first,
    IEnumerable<TKey> second,
    Func<TSource, TKey> keySelector
)

public static IEnumerable<TSource> IntersectBy<TSource, TKey>(
    this IEnumerable<TSource> first,
    IEnumerable<TKey> second,
    Func<TSource, TKey> keySelector,
    IEqualityComparer<TKey> comparer
)

参数：
- first ：第一个要计算交集的序列。
- second ：第二个要计算交集的序列（注意这里的元素类型是键类型 TKey ）。
- keySelector ：一个函数，用于从每个元素中提取键值。
- comparer （可选）：一个 IEqualityComparer 实现，用于比较键值是否相等。
返回值 ： UnionBy 方法返回一个 IEnumerable<TSource> 对象，其中 TSource 是输入序列中元素的类型。

2）工作原理

Intersect ：计算两个序列的交集，返回两个序列中共有的所有元素，并使用默认或自定义的比较器来判断元素是否相等。
IntersectBy ：根据指定的键选择器函数提取键值，并计算两个序列的交集，返回第一个序列中具有与第二个序列中相同键值的所有元素。

3）使用场景

适用于数据过滤、数据预处理、多个集合的交集计算等场景。

3. 使用示例

示例 1：基本交集计算

假设我们有两个整数列表，我们希望找出它们共有的元素。

class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3, 4, 5 };
        List<int> list2 = new List<int> { 3, 4, 6 };

        // 使用 Intersect 计算交集
        var intersectList = list1.Intersect(list2);
        Console.WriteLine(string.Join(",", intersectList));// 输出：3,4

        intersectList = list1.IntersectBy(list2, x => x);
        Console.WriteLine(string.Join(",", intersectList));// 输出：3,4
    }
}

示例 2：自定义对象

当处理自定义对象时， Intersect 方法默认使用对象的 Equals 和 GetHashCode 方法来判断元素是否相同。如果你有更复杂的比较需求，可以提供自定义的 IEqualityComparer<T> 实现。

使用默认的 Equals 和 GetHashCode 方法，并不能实现对象内容的比较

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}

class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };

        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "David", Age = 40 }
        };

        // 使用 Intersect 计算交集
        var intersectPeople = list1.Intersect(list2);

        Console.WriteLine(string.Join(",", intersectPeople));
        // 输出：          - 表示 没有交集
    }
}

重写对象的 Equals 和 GetHashCode 方法，可以实现对象内容的比较。使用 Except 时，默认就会调用重写后的方法判断对象是否相等

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override bool Equals(object obj)
    {
        if (obj is Person other)
        {
            return Name == other.Name && Age == other.Age;
        }
        return false;
    }

    public override int GetHashCode()
    {
        return HashCode.Combine(Name, Age);
    }

    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}
class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Charlie", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        // 使用 Intersect 计算交集
        var intersectPeople = list1.Intersect(list2);

        Console.WriteLine(string.Join(",", intersectPeople));
        // 输出：Bob (25)
    }
}

使用自定义的 PersonComparer 来比较 Person 对象。

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}
class PersonComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        if (x == null || y == null) return false;
        return x.Name == y.Name && x.Age == y.Age;
    }

    public int GetHashCode(Person obj)
    {
        return HashCode.Combine(obj.Name, obj.Age);
    }
}

class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Charlie", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };

        // 使用 Intersect 计算交集并使用自定义比较器
        var intersectPeople = list1.Intersect(list2, new PersonComparer());

        Console.WriteLine(string.Join(",", intersectPeople));
        // 输出：Bob (25)
    }
}

使用 ExceptBy ，通过指定键选择器函数来确定哪些对象应该被视为相同的。并确保合并后的结果中没有重复项。

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}

class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };
        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "David", Age = 40 }
        };

        // 使用 IntersectBy 计算交集
        var intersectPeople = list1.IntersectBy(list2.Select(x => x.Age), p => p.Age);

        Console.WriteLine(string.Join(",", intersectPeople));
        // 输出：Bob (25)
    }
}

示例 3：处理无限序列

Intersect / IntersectBy 方法采用惰性求值（Lazy Evaluation），这意味着它不会立即执行合并操作，而是等到实际遍历时才会计算结果。这使得 Intersect / IntersectBy 可以处理无限序列或延迟执行复杂的查询。

class Program
{
    static void Main()
    {
        IEnumerable<int> infiniteNumbers = Enumerable.Range(0, int.MaxValue).Select(i => i * 2);
        List<int> finiteNumbers = new List<int> { 4, 6, 8 };

        // 使用 Intersect 计算交集
        var intersectSequence = infiniteNumbers.Intersect(finiteNumbers);

        // 限制输出数量
        Console.WriteLine("Elements common between infiniteNumbers and finiteNumbers (First 3 elements):");
        foreach (var item in intersectSequence.Take(3))
        {
            Console.Write(item + " ");
        }
    }
}

输出结果：

Elements common between infiniteNumbers and finiteNumbers (First 3 elements):
4 6 8

在这个例子中，我们展示了如何使用 Intersect 方法计算一个无限序列和一个有限序列之间的交集，并通过 Take 方法限制输出的数量，从而避免无限循环。

示例 4：自定义比较器

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override string ToString()
    {
        return $"{Name} ({Age})";
    }
}

class CustomAgeComparer : IEqualityComparer<int>
{
    public bool Equals(int x, int y)
    {
        // 自定义比较逻辑：年龄相差不超过1岁视为相同
        return Math.Abs(x - y) <= 1;
    }

    public int GetHashCode(int obj)
    {
        return 0;
    }
}

class Program
{
    static void Main()
    {
        List<Person> list1 = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };

        List<Person> list2 = new List<Person>
        {
            new Person { Name = "Charlie", Age = 30 },
            new Person { Name = "David", Age = 26 }
        };

        // 使用 IntersectBy 取两个列表交集并根据年龄和自定义比较器 比较Person对象
        var intersectPeople = list1.IntersectBy(list2.Select(x => x.Age), p => p.Age, new CustomAgeComparer());

        Console.WriteLine(string.Join(",", intersectPeople));
        // 输出：Alice (30),Bob (25)
    }
}

示例 5：多个集合的合并

当需要合并多个集合时，可以多次使用 Intersect/IntersectBy 方法。

class Program
{
    static void Main()
    {
        List<int> list1 = new List<int> { 1, 2, 3, 4, 5 };
        List<int> list2 = new List<int> { 3, 4, 6 };
        List<int> list3 = new List<int> { 4, 7, 8 };

        // 使用 Union 合并多个集合
        //var unionedLists = list1.Intersect(list2).Intersect(list3);
         var unionedLists = list1.IntersectBy(list2, x => x).IntersectBy(list3, x => x);

        Console.WriteLine(string.Join(",", unionedLists));
        // 输出：4
    }
}

4. 注意事项

尽管 Intersect/IntersectBy 方法非常有用，但在实际应用中也有一些需要注意的地方：

空集合处理 ：如果源集合为空， Intersect/IntersectBy 方法将返回一个空的结果集。因此，在使用 Intersect/IntersectBy 方法之前，通常不需要检查集合是否为空。
数据类型一致 ：适用于需要取差集的集合对象的数据类型是一样的情况。

结语

回到目录页：

希望以上内容可以帮助到大家，如文中有不对之处，还请批评指正。

参考资料：

目录

C-Enumerable类-之-集合操作

C# Enumerable类 之 集合操作

前言

一、概览

二、 Concat ：合并(不去重)

1. 什么是 Concat

2. Concat 方法 基本信息

1） Concat

2）工作原理

3）使用场景

3. 使用示例

示例 1：基本连接

示例 2：不同类型的序列

示例 3：空序列

示例 4：合并多个集合

示例 5：处理流式数据

示例 6：数据预处理

4. 注意事项

三、 Union 和 UnionBy ：并集(去重)

1. 什么是 Union/UnionBy

2. Union/UnionBy 方法 基本信息

1） Union/UnionBy

2）工作原理

3）使用场景

3. 使用示例

示例 1：基本合并

示例 2：自定义对象

示例 3：处理无限序列

示例 4：自定义比较器

示例 5：多个集合的合并

4. 注意事项

四、 Except 和 ExceptBy ：差集

1. 什么是 Except/ExceptBy

2. Except/ExceptBy 方法 基本信息

1） Except/ExceptBy

2）工作原理

3）使用场景

3. 使用示例

示例 1：基本差集计算

示例 2：自定义对象

示例 3：处理无限序列

示例 4：自定义比较器

示例 5：多个集合的合并

4. 注意事项

五、 Intersect 和 IntersectBy ：交集

1. 什么是 Intersect/IntersectBy

2. Intersect/IntersectBy 方法 基本信息

1） Intersect/IntersectBy

2）工作原理

3）使用场景

3. 使用示例

示例 1：基本交集计算

示例 2：自定义对象

示例 3：处理无限序列

示例 4：自定义比较器

示例 5：多个集合的合并

4. 注意事项

结语

C# Enumerable类之集合操作

二、 `Concat` ：合并(不去重)

2. Concat 方法基本信息

三、 `Union` 和 `UnionBy` ：并集(去重)

2. Union/UnionBy 方法基本信息

四、 `Except` 和 `ExceptBy` ：差集

2. Except/ExceptBy 方法基本信息

五、 `Intersect` 和 `IntersectBy` ：交集

2. Intersect/IntersectBy 方法基本信息