.NET中List集合去重的7种高效方法对比

1. 项目概述

在.NET开发中，List集合去重是一个高频操作场景。无论是处理数据库查询结果、API返回数据还是内存中的临时集合，我们经常需要确保集合元素的唯一性。不同的去重方法在性能、可读性和适用场景上各有优劣，本文将深入解析7种主流实现方案及其背后的技术原理。

提示：本文所有代码示例基于.NET 6+环境，部分方法在早期版本中可能需要调整语法

2. 核心需求解析

2.1 为什么需要专门研究List去重？

List作为.NET中最常用的集合类型之一，其去重操作看似简单实则暗藏玄机。在实际项目中，我们常遇到以下典型场景：

• 合并多个数据源时消除重复记录
• 统计UV（Unique Visitor）时需要去重计算
• 缓存数据刷新时避免重复添加
• 业务逻辑要求保证数据唯一性

2.2 性能考量关键指标

评估去重方法优劣时需关注：

1. 时间复杂度：大数据量下的执行效率
2. 空间复杂度：内存占用情况
3. 代码可维护性：团队协作时的可读性
4. 特殊场景适配：如自定义对象的去重

3. 七种去重方法详解

3.1 LINQ Distinct() 方法

最直观的解决方案，适合大多数简单场景：

csharp复制var distinctList = originalList.Distinct().ToList();

实现原理：

• 内部使用默认的EqualityComparer进行比较
• 延迟执行（Deferred Execution）特性
• 最终需要.ToList()实现立即求值

性能实测（100万条记录）：

• 平均耗时：约320ms
• 内存峰值：1.2倍原集合大小

注意：对于自定义类需要重写Equals()和GetHashCode()，否则按引用比较

3.2 HashSet 构造函数法

利用HashSet天生去重的特性：

csharp复制var hashSet = new HashSet<T>(originalList);
var distinctList = hashSet.ToList();

优势分析：

• O(1)的查找时间复杂度
• 自动处理哈希冲突
• 明确表达去重意图

优化技巧：

csharp复制// 指定自定义比较器
var customComparer = new HashSet<T>(originalList, new MyEqualityComparer());

3.3 循环遍历法

传统但可控性强的方案：

csharp复制var result = new List<T>();
foreach(var item in originalList)
{
    if(!result.Contains(item))
        result.Add(item);
}

适用场景：

• 需要逐步处理去重过程
• 特殊业务逻辑介入
• 早期.NET版本兼容

3.4 Dictionary键去重法

利用Dictionary键唯一的特性：

csharp复制var dict = new Dictionary<T, bool>();
foreach(var item in originalList)
{
    dict[item] = true;
}
var distinctList = dict.Keys.ToList();

性能对比：

3.5 并行处理去重

大数据量下的优化方案：

csharp复制var distinctList = originalList
    .AsParallel()
    .Distinct()
    .ToList();

注意事项：

• 仅当数据量>50万条时建议使用
• 需要线程安全的比较器
• 可能打乱原始顺序

3.6 IEqualityComparer自定义比较

处理复杂对象的专业方案：

csharp复制public class ProductComparer : IEqualityComparer<Product>
{
    public bool Equals(Product x, Product y) 
        => x.ProductId == y.ProductId;
    
    public int GetHashCode(Product obj)
        => obj.ProductId.GetHashCode();
}

// 使用示例
var distinctProducts = products.Distinct(new ProductComparer());

3.7 MoreLINQ库的DistinctBy

扩展方法提供更多灵活性：

csharp复制// 安装MoreLINQ包
var distinctByPrice = products.DistinctBy(p => p.Price).ToList();

4. 性能深度对比测试

4.1 测试环境配置

• 设备：i7-11800H/32GB RAM
• 数据量：1-100万条随机数据
• 运行次数：每种方法测试10次取平均值

4.2 结果数据表

4.3 内存占用分析

![内存占用趋势图]

• HashSet内存效率最佳
• LINQ会产生临时迭代器对象
• 并行方法线程开销明显

5. 特殊场景处理方案

5.1 大对象去重优化

当集合元素是内存占用大的对象时：

csharp复制// 使用引用保留模式
var distinctRefs = originalList
    .Select(obj => new { obj, hash = obj.GetHashCode() })
    .GroupBy(x => x.hash)
    .Select(g => g.First().obj)
    .ToList();

5.2 稳定排序去重

需要保留首次出现的元素：

csharp复制var seen = new HashSet<T>();
var distinctOrdered = originalList
    .Where(item => seen.Add(item))
    .ToList();

5.3 多条件复合去重

csharp复制var distinctMulti = originalList
    .GroupBy(x => new { x.Prop1, x.Prop2 })
    .Select(g => g.First())
    .ToList();

6. 实战问题排查指南

6.1 常见异常处理

问题1：自定义对象去重无效

• 检查是否实现了Equals/GetHashCode
• 确认比较逻辑的一致性

问题2：并行处理结果不稳定

• 检查比较器是否线程安全
• 考虑使用ConcurrentDictionary

6.2 性能优化技巧

1. 预估容量减少扩容：

csharp复制var hashSet = new HashSet<T>(capacity: originalList.Count);

2. 避免多层嵌套去重：

csharp复制// 反模式
var filtered = bigList.Where(...).Distinct().Where(...).Distinct();

3. 考虑使用Span减少内存分配

7. 方法选型决策树

根据你的具体需求选择方案：

1. 需要保持原始顺序 → LINQ Distinct()
2. 极致性能需求 → HashSet构造函数
3. 自定义复杂比较 → IEqualityComparer
4. 超大数据集(>1M) → 并行Distinct
5. 需要中间处理 → MoreLINQ DistinctBy

我在实际项目中最常用的是HashSet方案，它在大多数场景下提供了最佳的性能与可读性平衡。特别是在处理10万级以上数据时，相比LINQ能有30-50%的性能提升。不过要注意HashSet不保证顺序的特性，在需要严格保持元素原始顺序的场景下，可能需要额外进行索引记录。