---

掌握 C# HashSet：高效处理不重复集合

在软件开发中，我们经常需要处理集合数据。这些集合可能包含各种类型的数据，例如数字、字符串或自定义对象。在某些场景下，我们对集合有一个特殊的要求：其中的元素必须是唯一的，不允许重复。传统的集合类型，如 List<T>，虽然灵活且功能强大，但在处理唯一性、进行高效的包含性检查或执行集合论操作（如并集、交集）时，可能会遇到性能瓶颈。

幸运的，.NET Framework 提供了一个专门用于处理不重复元素的集合类型：HashSet<T>。HashSet<T> 是 System.Collections.Generic 命名空间下的一个类，它基于哈希表（Hash Table）的原理实现，提供了非常高效的方式来存储、添加、删除和查找唯一的元素。掌握 HashSet<T> 的使用和内部原理，对于编写高性能、健壮的 C# 代码至关重要。

本文将深入探讨 HashSet<T>，从其基本概念、工作原理，到常用方法、性能优势，以及如何处理自定义类型和常见的陷阱，旨在帮助您全面掌握这个强大的集合类型。

1. 为何需要 HashSet？List 的局限性

在我们深入 HashSet<T> 之前，先来看看为什么我们需要一个专门处理不重复元素的集合类型。最常见的通用集合是 List<T>。List<T> 是一个动态数组，它按顺序存储元素，允许重复，并且可以通过索引快速访问元素。然而，当涉及到唯一性时，List<T> 就会暴露出其不足。

考虑以下常见操作：

1. 确保添加的元素不重复： 如果您想向一个 List<T> 中添加一个元素，但前提是这个元素之前不存在。您需要先使用 Contains() 方法检查元素是否存在，然后如果不存在再使用 Add() 添加。List<T> 的 Contains() 方法需要遍历列表中的所有元素，其时间复杂度是 O(n)，其中 n 是列表中的元素数量。如果列表很大，这个操作会非常耗时。
   csharp
List<string> names = new List<string>();
string newName = "Alice";
if (!names.Contains(newName)) // O(n)
{
names.Add(newName);
}
2. 从集合中移除所有重复项： 如果您有一个包含重复项的 List<T>，想要得到一个不包含重复项的新列表。您可能需要创建一个新的列表，然后遍历原列表，逐个将元素添加到新列表，同时检查新列表中是否已存在该元素（同样使用 O(n) 的 Contains()）。
   csharp
List<int> numbersWithDuplicates = new List<int>() { 1, 2, 2, 3, 4, 4, 5 };
List<int> uniqueNumbers = new List<int>();
foreach (int number in numbersWithDuplicates)
{
if (!uniqueNumbers.Contains(number)) // O(n) for each number
{
uniqueNumbers.Add(number);
}
}
// 整体时间复杂度约为 O(n^2)
3. 执行集合论操作（交集、并集等）： 实现两个 List<T> 的交集或并集需要复杂的嵌套循环或借助其他数据结构，效率通常不高。例如，计算两个列表的交集，可能需要对一个列表中的每个元素，遍历另一个列表来检查是否存在，同样是 O(n*m) 或更差的时间复杂度。

这些场景都凸显了 List<T> 在处理“集合”概念（数学上的集合，强调元素的唯一性）时的低效率。这就是 HashSet<T> 发挥作用的地方。

2. 什么是 HashSet？核心概念

HashSet<T> 是 .NET 中实现“集合”概念的通用类。它的核心特点和用途是：

• 存储唯一的元素： HashSet<T> 保证其内部不会存在重复的元素。当您尝试添加一个已经存在于集合中的元素时，添加操作会被忽略，不会引发错误，也不会改变集合的状态。
• 无序集合： HashSet<T> 不保证元素的存储顺序或迭代顺序。元素的顺序取决于其哈希码以及内部哈希表的实现细节，可能会随时间或操作而改变。如果您需要一个存储唯一元素且保持排序的集合，应该考虑使用 SortedSet<T>。
• 高效的操作： HashSet<T> 的设计目标之一就是提供高效的添加、删除和查找（包含性检查）操作。这些操作在平均情况下的时间复杂度接近于 O(1)，与集合中元素的数量无关。这是通过哈希实现的。

从数学集合的角度看，HashSet<T> 支持常见的集合操作，如并集 (Union)、交集 (Intersection)、差集 (Difference) 和对称差集 (Symmetric Difference)。

3. HashSet 的工作原理：哈希的力量

理解 HashSet<T> 高效率的关键在于理解其底层机制——哈希表。

哈希表是一种数据结构，它使用哈希函数将键（Key）映射到存储桶（Bucket）中的位置。在 HashSet<T> 中，集合中的每个元素本身就是“键”。

当您向 HashSet<T> 添加一个元素时，会发生以下几个步骤：

1. 计算哈希码： 系统会调用该元素的 GetHashCode() 方法，计算出一个整数值，这就是该元素的哈希码（Hash Code）。
2. 确定存储桶： 基于这个哈希码，使用一个内部算法（通常是哈希码对存储桶数量取模）来确定该元素应该存储在哪一个“存储桶”中。存储桶实际上是哈希表内部的一个数组索引。
3. 检查唯一性并存储：
   • 首先，系统会跳转到计算出的存储桶。
   • 如果该存储桶是空的，说明该元素是新的，直接将其添加到这个存储桶中。
   • 如果该存储桶中已经有元素（可能是一个元素或一个链表/红黑树，取决于具体的哈希表实现和冲突处理策略），系统会遍历该存储桶中的现有元素。
   • 对于存储桶中的每一个现有元素，系统会调用该元素的 Equals() 方法与要添加的新元素进行比较。
   • 如果找到了一个元素与新元素 Equals() 返回 true，则认为要添加的元素已经存在于集合中，添加操作失败（或者说，不执行任何操作并返回 false）。
   • 如果遍历完整个存储桶，都没有找到与新元素 Equals() 返回 true 的元素，则将新元素添加到这个存储桶中（通常是添加到该存储桶维护的链表或结构中）。

查找（Contains()）和删除（Remove()）操作也遵循类似的高效流程：

1. 计算哈希码： 对要查找或删除的元素计算哈希码。
2. 确定存储桶： 根据哈希码找到对应的存储桶。
3. 遍历存储桶并比较： 遍历该存储桶中的所有元素，使用 Equals() 方法与目标元素进行比较。
4. 执行操作： 如果找到了相等的元素，对于 Contains() 返回 true，对于 Remove() 则将其移除并返回 true。如果遍历完存储桶没有找到，则 Contains() 返回 false，Remove() 返回 false。

为什么高效？

哈希表的高效性在于，在理想情况下，哈希函数能将元素均匀地分布到不同的存储桶中。这样，每个存储桶中包含的元素数量就很少。无论整个 HashSet 中有多少元素，查找或比较时，只需要在少数几个元素组成的存储桶中进行，而不是遍历整个集合。这使得平均时间复杂度接近于 O(1)。

哈希冲突 (Hash Collision):

不同的元素可能会计算出相同的哈希码，这被称为哈希冲突。哈希表必须有机制来处理冲突。常见的处理方式包括：

• 链地址法 (Chaining): 每个存储桶维护一个链表或类似结构，所有哈希到同一个桶的元素都存储在这个链表中。
• 开放寻址法 (Open Addressing): 当发生冲突时，在哈希表中寻找下一个可用的空位置来存储元素。

.NET 的 HashSet<T> 使用的是链地址法。当冲突发生时，性能会略有下降，因为需要在同一个桶的链表中进行遍历比较。如果哈希函数设计得不好，导致大量冲突，或者集合中元素数量远大于存储桶数量（负载因子过高），存储桶中的链表会变长，极端情况下可能退化为 O(n) 的线性查找。但对于大多数常见类型及其默认的 GetHashCode() 实现，这种极端情况很少发生。

4. 开始使用 HashSet：实例化

使用 HashSet<T> 非常简单，首先需要引用 System.Collections.Generic 命名空间。

4.1 创建一个空的 HashSet:

“`csharp
using System.Collections.Generic;

// 创建一个存储整数的 HashSet
HashSet uniqueNumbers = new HashSet();

// 创建一个存储字符串的 HashSet
HashSet uniqueNames = new HashSet();
“`

4.2 从现有集合创建 HashSet:

您可以将任何实现了 IEnumerable<T> 接口的集合（如 List<T>, 数组等）的元素初始化到一个 HashSet<T> 中。这是一种快速去除重复项的方法。

“`csharp
List namesWithDuplicates = new List { “Alice”, “Bob”, “Alice”, “Charlie”, “Bob” };

// 从 List 创建 HashSet，自动去除重复项
HashSet uniqueNamesFromList = new HashSet(namesWithDuplicates);

// uniqueNamesFromList 现在包含: “Alice”, “Bob”, “Charlie”
Console.WriteLine(“Unique names:”);
foreach (string name in uniqueNamesFromList)
{
Console.WriteLine(name);
}
“`

4.3 指定容量或相等比较器 (IEqualityComparer):

HashSet<T> 的构造函数还允许您指定初始容量（可以帮助优化性能，避免多次重新哈希）或一个自定义的相等比较器 (IEqualityComparer<T>)，用于确定两个元素是否相等以及如何计算哈希码。

“`csharp
// 指定初始容量为 100
HashSet namesWithCapacity = new HashSet(100);

// 使用不区分大小写的字符串比较器
HashSet caseInsensitiveNames = new HashSet(StringComparer.OrdinalIgnoreCase);

caseInsensitiveNames.Add(“Alice”);
caseInsensitiveNames.Add(“alice”); // 不会重复添加，因为比较器认为它们相等

Console.WriteLine($”Count: {caseInsensitiveNames.Count}”); // 输出: Count: 1
“`

5. HashSet 的常用操作与方法

HashSet<T> 提供了丰富的方法来管理集合中的元素和执行集合论操作。

5.1 添加元素 (Add)

Add(T item) 方法尝试将指定的元素添加到集合中。
* 如果元素成功添加（即集合中原本不存在该元素），则返回 true。
* 如果元素已经存在于集合中，则不进行任何操作并返回 false。

“`csharp
HashSet numbers = new HashSet();

bool added1 = numbers.Add(10); // added1 is true
bool added2 = numbers.Add(20); // added2 is true
bool added3 = numbers.Add(10); // added3 is false, 10 is already present

Console.WriteLine($”Added 10 first time: {added1}”);
Console.WriteLine($”Added 20: {added2}”);
Console.WriteLine($”Added 10 second time: {added3}”);
Console.WriteLine($”Current count: {numbers.Count}”); // Output: Current count: 2 (10, 20)
“`

5.2 检查元素是否存在 (Contains)

Contains(T item) 方法检查集合中是否包含指定的元素。这是一个非常高效的操作，平均时间复杂度为 O(1)。

“`csharp
HashSet fruits = new HashSet { “Apple”, “Banana”, “Orange” };

Console.WriteLine($”Contains ‘Banana’: {fruits.Contains(“Banana”)}”); // Output: True
Console.WriteLine($”Contains ‘Grape’: {fruits.Contains(“Grape”)}”); // Output: False
“`

5.3 移除元素 (Remove)

Remove(T item) 方法从集合中移除指定的元素。
* 如果元素成功移除（即集合中存在该元素），则返回 true。
* 如果元素不存在于集合中，则不进行任何操作并返回 false。这个操作也非常高效，平均时间复杂度为 O(1)。

“`csharp
HashSet colors = new HashSet { “Red”, “Green”, “Blue” };

bool removedGreen = colors.Remove(“Green”); // removedGreen is true
bool removedYellow = colors.Remove(“Yellow”); // removedYellow is false

Console.WriteLine($”Removed Green: {removedGreen}”);
Console.WriteLine($”Removed Yellow: {removedYellow}”);
Console.WriteLine($”Current count: {colors.Count}”); // Output: Current count: 2 (Red, Blue)
“`

5.4 获取元素数量 (Count)

Count 属性获取集合中当前包含的元素数量。这是一个 O(1) 的操作。

csharp
HashSet<int> data = new HashSet<int> { 1, 2, 3 };
Console.WriteLine($"Number of elements: {data.Count}"); // Output: 3
data.Add(4);
Console.WriteLine($"Number of elements after add: {data.Count}"); // Output: 4
data.Add(2); // Already exists
Console.WriteLine($"Number of elements after adding duplicate: {data.Count}"); // Output: 4

5.5 清空集合 (Clear)

Clear() 方法移除集合中的所有元素。

csharp
HashSet<string> items = new HashSet<string> { "A", "B", "C" };
Console.WriteLine($"Count before clear: {items.Count}"); // Output: 3
items.Clear();
Console.WriteLine($"Count after clear: {items.Count}"); // Output: 0

5.6 遍历集合

可以使用 foreach 循环遍历 HashSet<T> 中的元素。但是请记住，遍历的顺序是不确定且不保证的。

csharp
HashSet<string> cities = new HashSet<string> { "London", "Paris", "Tokyo" };
Console.WriteLine("Cities in HashSet:");
foreach (string city in cities)
{
Console.WriteLine(city);
}
// 输出顺序可能是 "London", "Paris", "Tokyo" 或其他排列组合

重要提示： 不要在 foreach 循环遍历 HashSet<T> 的过程中修改集合（添加或移除元素），否则会引发 InvalidOperationException。如果您需要在遍历时进行修改，可以将元素先收集到一个临时列表中，然后在遍历结束后再进行修改，或者使用支持边遍历边修改的集合类型（但 HashSet<T> 不支持）。

6. 集合论操作

HashSet<T> 提供了丰富的集合论方法，可以直接对两个集合执行数学上的集合操作。这些方法通常比手动实现高效得多。

假设我们有两个 HashSet<int>：

csharp
HashSet<int> set1 = new HashSet<int> { 1, 2, 3, 4 };
HashSet<int> set2 = new HashSet<int> { 3, 4, 5, 6 };

6.1 并集 (UnionWith)

UnionWith(IEnumerable<T> other)：修改当前的 HashSet，使其包含当前集合和另一个集合中的所有唯一元素。

csharp
HashSet<int> unionSet = new HashSet<int>(set1); // Clone set1
unionSet.UnionWith(set2);
// unionSet now contains { 1, 2, 3, 4, 5, 6 }
Console.WriteLine("Union:");
foreach (int item in unionSet) Console.Write($"{item} "); // Output: 1 2 3 4 5 6 (order may vary)
Console.WriteLine();

6.2 交集 (IntersectWith)

IntersectWith(IEnumerable<T> other)：修改当前的 HashSet，使其只包含同时存在于当前集合和另一个集合中的元素。

csharp
HashSet<int> intersectSet = new HashSet<int>(set1); // Clone set1
intersectSet.IntersectWith(set2);
// intersectSet now contains { 3, 4 }
Console.WriteLine("Intersection:");
foreach (int item in intersectSet) Console.Write($"{item} "); // Output: 3 4 (order may vary)
Console.WriteLine();

6.3 差集 (ExceptWith)

ExceptWith(IEnumerable<T> other)：修改当前的 HashSet，使其移除存在于另一个集合中的元素。

“`csharp
HashSet exceptSet = new HashSet(set1); // Clone set1
exceptSet.ExceptWith(set2);
// exceptSet now contains { 1, 2 }
Console.WriteLine(“Difference (set1 – set2):”);
foreach (int item in exceptSet) Console.Write($”{item} “); // Output: 1 2 (order may vary)
Console.WriteLine();

HashSet exceptSet2 = new HashSet(set2); // Clone set2
exceptSet2.ExceptWith(set1);
// exceptSet2 now contains { 5, 6 }
Console.WriteLine(“Difference (set2 – set1):”);
foreach (int item in exceptSet2) Console.Write($”{item} “); // Output: 5 6 (order may vary)
Console.WriteLine();
“`

6.4 对称差集 (SymmetricExceptWith)

SymmetricExceptWith(IEnumerable<T> other)：修改当前的 HashSet，使其只包含只存在于当前集合或只存在于另一个集合中的元素（即并集减去交集）。

csharp
HashSet<int> symmetricExceptSet = new HashSet<int>(set1); // Clone set1
symmetricExceptSet.SymmetricExceptWith(set2);
// symmetricExceptSet now contains { 1, 2, 5, 6 }
Console.WriteLine("Symmetric Difference:");
foreach (int item in symmetricExceptSet) Console.Write($"{item} "); // Output: 1 2 5 6 (order may vary)
Console.WriteLine();

6.5 子集/超集/相等/重叠检查 (IsSubsetOf, IsSupersetOf, SetEquals, Overlaps)

这些方法用于检查两个集合之间的关系。它们不会修改当前集合。

• IsSubsetOf(IEnumerable<T> other)：检查当前集合是否是另一个集合的子集。
• IsSupersetOf(IEnumerable<T> other)：检查当前集合是否是另一个集合的超集。
• SetEquals(IEnumerable<T> other)：检查当前集合与另一个集合是否包含完全相同的元素（忽略顺序）。
• Overlaps(IEnumerable<T> other)：检查当前集合与另一个集合是否至少有一个共同元素。

“`csharp
HashSet subSet = new HashSet { 3, 4 };
HashSet superSet = new HashSet { 1, 2, 3, 4, 5 };
HashSet equalSet = new HashSet { 4, 3, 2, 1 };
HashSet disjointSet = new HashSet { 7, 8, 9 };

Console.WriteLine($”set1 is subset of superSet: {set1.IsSubsetOf(superSet)}”); // True
Console.WriteLine($”superSet is superset of set1: {superSet.IsSupersetOf(set1)}”); // True
Console.WriteLine($”set1 is subset of subSet: {set1.IsSubsetOf(subSet)}”); // False
Console.WriteLine($”set1 equals equalSet: {set1.SetEquals(equalSet)}”); // True
Console.WriteLine($”set1 overlaps with set2: {set1.Overlaps(set2)}”); // True (share 3, 4)
Console.WriteLine($”set1 overlaps with disjointSet: {set1.Overlaps(disjointSet)}”); // False
“`

7. 性能分析与比较

HashSet<T> 的主要优势在于其卓越的性能，尤其是在以下操作中：

• 添加 (Add)
• 查找 (Contains)
• 移除 (Remove)

在平均情况下，这些操作的时间复杂度是 O(1)。这意味着无论集合中有 10 个元素还是 100 万个元素，执行这些操作所需的时间基本保持不变。

相比之下，List<T> 执行 Contains() 或 Remove() 操作时，需要遍历列表，时间复杂度为 O(n)。随着列表规模的增长，这些操作的性能会急剧下降。

性能对比总结：

操作	HashSet<T> (平均)	HashSet<T> (最差)	List<T>	备注
Add	O(1)	O(n)	O(1) (末尾) / O(n) (中间)	HashSet 添加已存在的元素是 O(1)，返回 false
Contains	O(1)	O(n)	O(n)	HashSet 显著优势
Remove	O(1)	O(n)	O(n)	HashSet 显著优势
Count	O(1)	O(1)	O(1)	基本持平
索引访问	不支持	不支持	O(1)	List<T> 优势
插入到指定位置	不支持	不支持	O(n)	List<T> 支持但 O(n)
集合操作	通常高效 (O(n) 或 O(n+m))	取决于具体操作和冲突	通常需要手动实现，效率较低 ( often O(n*m))	HashSet<T> 提供内置高效方法

最差情况 (O(n)) 发生场景：

HashSet<T> 的最差性能通常是由于极端的哈希冲突导致的。如果所有的元素都计算出相同的哈希码，那么查找、添加、删除操作就会退化为遍历一个很长的链表（存储桶中的元素），其性能就类似于在链表中查找，时间复杂度变为 O(n)。这种情况通常是由于哈希函数设计得非常差，或者处理的是一些特殊的、哈希码分布极不均匀的数据。对于 .NET 内置类型的默认哈希函数，这种极端情况非常罕见。

另一个影响性能的因素是 哈希表的重新哈希 (Rehashing)。当 HashSet 中的元素数量达到一定阈值（基于负载因子 Load Factor），为了保持哈希表的效率（即减少每个桶中的元素数量），HashSet 需要创建一个更大的内部数组，并重新计算所有现有元素的哈希码，将它们分配到新的存储桶中。这个过程是 O(n) 的，但它分摊到多次添加操作中，使得平均添加操作仍接近 O(1)。如果能预估集合的大小，通过构造函数指定初始容量，可以减少重新哈希的次数，从而略微提升性能。

8. 使用自定义类型作为 HashSet 元素

当您在 HashSet<T> 中存储自定义类的对象时，正确实现 Equals() 和 GetHashCode() 方法变得至关重要。

默认情况下，对于引用类型，HashSet<T> (以及其他依赖哈希的代码，如 Dictionary<TKey, TValue>) 使用的是对象的引用相等性（即两个变量是否指向内存中的同一个对象）和基于对象内存地址（或其他内部标识符）计算的哈希码。这意味着即使两个不同的对象实例具有完全相同的属性值，HashSet<T> 也可能将它们视为不同的元素，因为它们的引用不同，默认的 Equals() 返回 false，默认的 GetHashCode() 也可能不同。

示例：不实现 Equals() 和 GetHashCode()

“`csharp
public class Point
{
public int X { get; set; }
public int Y { get; set; }

// 没有重写 Equals 和 GetHashCode
public Point(int x, int y)
{
    X = x;
    Y = y;
}

}

HashSet points = new HashSet();

Point p1 = new Point(1, 2);
Point p2 = new Point(1, 2); // 属性值相同，但这是另一个对象实例
Point p3 = p1; // 这是同一个对象实例的引用

points.Add(p1);
points.Add(p2); // 可能会被视为不同的对象，因为是新的实例
points.Add(p3); // 会被视为与 p1 相同，因为是同一引用

Console.WriteLine($”Count: {points.Count}”);
// 输出可能是 2 (包含 p1 和 p2)，取决于 GetHashCode 的默认实现细节，
// 但可以肯定的是，p1 和 p3 只会算一个，p2 可能会算另一个。
// 想要根据值来判断唯一性则会失败。
“`

正确实现 Equals() 和 GetHashCode()

为了让 HashSet<T> 根据对象的值来判断唯一性，您需要重写 Equals(object obj)（通常也实现 IEquatable<T> 接口并重写 Equals(T other) 以获得更好的性能和类型安全）和 GetHashCode() 方法。

重要约定：

• 如果两个对象根据 Equals() 方法被认为是相等的 (Equals() 返回 true)，那么它们的 GetHashCode() 方法必须返回相同的值。
• 反之不一定成立：两个对象可以有相同的哈希码，但根据 Equals() 方法可能不相等（这就是哈希冲突）。但是一个好的哈希函数应该尽量减少这种情况。

实现 Equals() 和 GetHashCode() 的一个常见模式是：

“`csharp
public class ValuePoint : IEquatable
{
public int X { get; set; }
public int Y { get; set; }

public ValuePoint(int x, int y)
{
    X = x;
    Y = y;
}

// 实现 IEquatable<T> 接口的 Equals 方法 (类型安全，性能更好)
public bool Equals(ValuePoint other)
{
    if (other == null) return false;
    if (ReferenceEquals(this, other)) return true;
    // 比较值
    return X == other.X && Y == other.Y;
}

// 重写基类的 Equals 方法
public override bool Equals(object obj)
{
    // 兼容非 ValuePoint 类型的比较
    if (obj is ValuePoint other)
    {
        return Equals(other); // 调用 IEquatable<T> 的实现
    }
    return false;
}

// 重写 GetHashCode 方法
public override int GetHashCode()
{
    // 结合所有参与相等比较的字段/属性的哈希码
    // 可以使用 Tuple 或 HashCode.Combine (C# 7.0+) 来简化
    // return (X, Y).GetHashCode(); // 使用 Tuple (需要 .NET 4.7+)
    return HashCode.Combine(X, Y); // 使用 HashCode.Combine (需要 .NET Core 2.1 / .NET Standard 2.1 / .NET 5+)

    // 或者手动组合（老版本 .NET）
    // int hashCode = 17; // 任意非零质数
    // hashCode = hashCode * 23 + X.GetHashCode(); // 乘以质数并加上字段的哈希码
    // hashCode = hashCode * 23 + Y.GetHashCode();
    // return hashCode;
}

// 重写 ToString (可选，但有助于调试)
public override string ToString()
{
    return $"({X}, {Y})";
}

}

// 使用正确实现的自定义类型
HashSet valuePoints = new HashSet();

ValuePoint vp1 = new ValuePoint(1, 2);
ValuePoint vp2 = new ValuePoint(1, 2); // 属性值相同
ValuePoint vp3 = new ValuePoint(3, 4);

valuePoints.Add(vp1); // 添加 vp1
valuePoints.Add(vp2); // 尝试添加 vp2。Equals(vp1, vp2) 返回 true，GetHashCode() 相同，视为重复，添加失败
valuePoints.Add(vp3); // 添加 vp3

Console.WriteLine($”Count: {valuePoints.Count}”); // Output: Count: 2 (vp1/vp2 count as one, vp3 is another)
Console.WriteLine($”Contains (1, 2): {valuePoints.Contains(new ValuePoint(1, 2))}”); // Output: True
Console.WriteLine($”Contains (5, 6): {valuePoints.Contains(new ValuePoint(5, 6))}”); // Output: False
“`

在上面的示例中，由于正确重写了 Equals 和 GetHashCode，new ValuePoint(1, 2) 的两个不同实例被 HashSet<T> 视为同一个元素，因为它根据值来判断相等性。

总结： 当在 HashSet<T> 中使用自定义类时，如果希望根据对象的内容（而不是引用）来判断唯一性，务必正确重写 Equals() 和 GetHashCode() 方法。通常建议实现 IEquatable<T> 接口，并使用 HashCode.Combine 或 Tuple 的 GetHashCode() 来生成哈希码。

9. 何时使用 HashSet？何时避免？

何时使用 HashSet<T>:

• 需要一个存储唯一元素的集合： 这是 HashSet<T> 的核心用途。
• 频繁进行元素存在性检查 (Contains)： HashSet<T> 在此操作上表现出色 (平均 O(1))，远优于 List<T> (O(n))。
• 频繁进行元素的添加和移除： 同样是平均 O(1) 的高效操作。
• 需要执行集合论操作（并集、交集、差集等）： HashSet<T> 提供了内置的、通常比手动实现更高效的方法。
• 元素的顺序不重要： HashSet<T> 不保证顺序，如果需要保持元素的插入顺序或排序顺序，请考虑其他集合类型。
• 从一个可能包含重复项的集合中快速获取唯一元素： 可以通过 new HashSet<T>(collection) 构造函数一步完成。

何时避免使用 HashSet<T>:

• 需要存储重复的元素： HashSet<T> 设计上就不允许重复。
• 需要通过索引访问元素： HashSet<T> 没有索引器 ([])，不能像 List<T> 或数组那样通过索引快速获取元素。
• 需要保持元素的特定顺序（插入顺序或排序顺序）： HashSet<T> 是无序的。如果需要有序且唯一的集合，考虑使用 SortedSet<T>。
• 元素的类型没有正确实现或根本无法实现 Equals() 和 GetHashCode()： 某些类型可能无法根据其内容进行有意义的相等性比较。
• 在多线程环境下需要线程安全的集合： HashSet<T> 不是线程安全的。在并发场景下，需要使用锁或其他同步机制，或者考虑使用 System.Collections.Concurrent 命名空间下的并发集合类型（但目前 .NET 没有内置的并发 HashSet，可能需要手动实现或使用外部库）。

10. 相关集合类型

• List<T>: 有序、允许重复、通过索引访问高效、添加/移除（非末尾）O(n)、包含性检查 O(n)。适用于需要顺序和索引访问的场景。
• SortedSet<T>: 有序、存储唯一的元素、元素始终保持排序状态、添加/移除/查找的时间复杂度通常是 O(log n)。适用于需要唯一性 和 排序的场景。
• Dictionary<TKey, TValue>: 存储键值对，键是唯一的，通过键进行查找、添加、移除操作是平均 O(1)。适用于需要通过键快速查找关联值的场景。HashSet<T> 可以看作是一个只有键没有值的 Dictionary<TKey, bool>。

选择哪种集合类型取决于您的具体需求：是否需要唯一性？是否需要顺序或索引访问？操作的频率和类型是什么？

11. 进阶话题与常见陷阱

• 初始容量和负载因子： HashSet<T> 的性能受初始容量和负载因子的影响。如果预知集合大小，指定一个合适的初始容量可以减少重新哈希的开销。负载因子决定了当集合元素数量达到容量的多少倍时进行重新哈希。调整这些参数可以微调性能，但在大多数情况下，默认设置已经足够好。
• 相等比较器 (IEqualityComparer<T>)： 除了让自定义类型实现 Equals/GetHashCode 外，还可以通过提供一个实现了 IEqualityComparer<T> 接口的对象来完全控制 HashSet 如何判断相等性和计算哈希码。这在您无法修改元素的类型或需要不同的相等性规则时非常有用（如前面使用 StringComparer.OrdinalIgnoreCase 的例子）。
• 线程安全： 再次强调，HashSet<T> 不是线程安全的。如果您需要在多个线程中同时访问和修改同一个 HashSet 实例，必须采取适当的同步措施（例如使用 lock 关键字），或者考虑其他并发集合类型。
• 哈希码的质量： 一个好的哈希函数应该能够将不同的对象均匀地分散到各个存储桶中，最大程度地减少哈希冲突。对于内置类型，.NET 框架提供了高质量的哈希函数。对于自定义类型，如果手动实现 GetHashCode，需要小心设计，确保其遵循约定并产生良好的分布。使用 HashCode.Combine 是一个安全且推荐的方式。
• 值类型和引用类型： 对于值类型（如 int, struct），默认的 Equals() 和 GetHashCode() 通常是基于值的，可以正确地在 HashSet<T> 中工作，无需特殊处理（除非结构体包含引用类型字段且需要特殊比较）。但对于自定义引用类型，则需要像前面示例那样重写方法。

12. 总结

HashSet<T> 是 .NET 中用于高效处理不重复集合的强大工具。它基于哈希表实现，在添加、删除和包含性检查等操作上提供了接近 O(1) 的平均时间复杂度，远优于 List<T> 在这些场景下的 O(n) 性能。此外，它还内置了方便的集合论操作方法。

理解 HashSet<T> 的工作原理（特别是哈希和相等性判断）以及何时需要为自定义类型实现 Equals 和 GetHashCode 是正确和高效使用它的关键。

在需要存储唯一元素、频繁检查元素是否存在、或执行集合论操作，并且不关心元素顺序的场景下，HashSet<T> 是您的首选集合类型。将其与 List<T>、SortedSet<T> 等其他集合类型结合使用，可以帮助您构建更高效、更优雅的 C# 应用程序。

掌握 HashSet<T>，意味着您为自己的工具箱添加了一个处理集合问题的利器，让您的代码在处理大量数据时更加得心应手。现在，就开始在您的项目中使用 HashSet<T>，体验它带来的效率提升吧！

---