C# List去重性能优化与最佳实践

1. 为什么需要关注List去重问题

在日常开发中，我们经常遇到需要对List集合进行去重操作的场景。比如从数据库查询返回的结果集可能存在重复记录，或者多个数据源合并时需要剔除重复项。以电商系统为例，当用户浏览商品时，系统可能需要合并"猜你喜欢"和"浏览历史"两个推荐列表，但又不希望同一个商品重复出现。

List去重看似简单，但不同实现方式的性能差异可能达到数百倍。我曾在一个日活百万的系统中，就因为使用了不当的去重方法，导致接口响应时间从50ms飙升到800ms。经过排查发现，正是因为在循环中使用了低效的Contains方法做去重判断。

重要提示：在数据量超过1000条时，不同去重方法的性能差异会变得非常明显。生产环境一定要根据数据规模选择合适的方法。

2. 基础去重方法对比

2.1 使用Distinct方法

LINQ的Distinct()是最简单的去重方式：

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

原理分析：

• Distinct()使用默认的相等比较器(DefaultEqualityComparer)
• 对于值类型直接比较值
• 对于引用类型比较引用地址(除非重写了Equals和GetHashCode)
• 底层使用HashSet实现，时间复杂度接近O(n)

适用场景：

• 简单值类型集合(int, string等)
• 不需要自定义比较逻辑的情况
• 数据量中等(万级以下)

2.2 使用HashSet转换

HashSet天生具有去重特性：

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

性能特点：

• 构造HashSet时自动去重
• 需要一次ToList的内存分配
• 比Distinct()稍快，特别是大数据量时

实测对比(100万条数据)：

2.3 传统循环判断法

很多开发者会这样写：

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

致命缺陷：

• Contains()方法是线性搜索，时间复杂度O(n²)
• 万级数据就会明显卡顿
• 绝对不要在生产环境使用

3. 高级去重技巧

3.1 自定义相等比较器

当需要根据对象属性去重时：

csharp复制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()).ToList();

3.2 并行去重处理

大数据量时可使用Parallel：

csharp复制var distinctBag = new ConcurrentBag<T>();
var seen = new ConcurrentDictionary<T, bool>();

Parallel.ForEach(originalList, item => {
    if(seen.TryAdd(item, true)) {
        distinctBag.Add(item);
    }
});

注意事项：

• 适合CPU密集型场景
• 小数据量反而更慢
• 需要线程安全集合

3.3 内存优化方案

对于极大数据集(GB级别)：

csharp复制var distinctItems = originalList
    .GroupBy(x => x.GetHashCode())
    .Select(g => g.First())
    .ToList();

原理：

• 先按HashCode分组
• 每组取第一个元素
• 减少中间集合的内存占用

4. 性能优化实战

4.1 基准测试对比

使用BenchmarkDotNet测试(1万条数据)：

4.2 最佳实践建议

1. 小数据集(＜1K)：任何方法都可以
2. 中等数据(1K-100K)：优先用HashSet
3. 大数据(＞100K)：考虑并行处理
4. 自定义对象：实现IEqualityComparer
5. 内存敏感：使用GroupBy方案

4.3 常见陷阱

1. 忘记重写Equals/GetHashCode

csharp复制// 错误示例
class Product {
    public int Id {get;set;}
    // 缺少Equals和GetHashCode实现
}

2. 在循环内创建HashSet

csharp复制// 低效写法
foreach(var item in list) {
    var tempSet = new HashSet<T>(); // 每次循环都新建
    // ...
}

3. 忽略null值处理

csharp复制// 安全写法
public override bool Equals(object obj)
{
    if(obj == null) return false;
    // ...
}

5. 特殊场景解决方案

5.1 大数据分块处理

当数据无法一次性加载时：

csharp复制IEnumerable<T> BatchDistinct(IEnumerable<T> source, int batchSize)
{
    var batch = new List<T>(batchSize);
    var seen = new HashSet<T>();
    
    foreach(var item in source) {
        if(seen.Add(item)) {
            batch.Add(item);
            if(batch.Count >= batchSize) {
                foreach(var i in batch) yield return i;
                batch.Clear();
            }
        }
    }
    
    foreach(var i in batch) yield return i;
}

5.2 多条件复合去重

根据多个属性组合去重：

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

5.3 保持原始顺序

有些方法会打乱顺序：

csharp复制// 保持顺序的Distinct
public static IEnumerable<T> DistinctInOrder<T>(this IEnumerable<T> source)
{
    var seen = new HashSet<T>();
    foreach(var item in source) {
        if(seen.Add(item)) {
            yield return item;
        }
    }
}

6. 实际案例：电商商品去重

假设我们需要合并多个推荐列表：

csharp复制var mergedList = new List<Product>();
mergedList.AddRange(recommendList1);
mergedList.AddRange(recommendList2);
mergedList.AddRange(browseHistory);

// 方案1：简单去重
var finalList1 = mergedList.Distinct(new ProductComparer()).ToList();

// 方案2：优先保留特定列表的商品
var finalList2 = mergedList
    .GroupBy(p => p.ProductId)
    .Select(g => g.OrderBy(p => p.Source == "recommend" ? 0 : 1).First())
    .ToList();

性能优化技巧：

1. 预先估算数据量
2. 考虑使用缓存去重结果
3. 异步预处理去重操作

7. 扩展思路：分布式去重

对于超大规模数据(如日志分析)：

1. 使用Bloom Filter进行预过滤
2. 按Key分片处理
3. Map-Reduce模式合并结果

示例伪代码：

csharp复制// 各节点处理自己的数据分片
var localDistinct = localData.Distinct().ToList();

// 汇总到协调节点
var globalDistinct = coordinator
    .Aggregate(localDistinct)
    .Distinct()
    .ToList();

我在实际项目中测试过，对于10亿级数据，这种分布式去重方法比单机处理快200倍以上。关键是要设计好的数据分片策略，避免数据倾斜。