平时做技术实践时，很多问题不是概念不会，而是细节没串起来。拿“.NET高效实现List集合去重的多种做法”来说，它看着像小点，放到项目里常会牵出环境、配置、兼容性和维护成本。下面按实际采用顺序，把思路、关键写法和容易踩坑的地方讲清楚，便于大家直接对照操作。

目录

• 一、采用 LINQ 的 Distinct() 方法（最常用）
• 1. 基本类型去重
• 2. 自定义对象去重（需实现 IEqualityComparer 或重写 Equals/GetHashCode）
• 方式 A：重写 Equals 和 GetHashCode
• 方式 B：采用自定义 IEqualityComparer
• 二、采用 HashSet（高性能建议）
• 三、采用 ToLookup / GroupBy（按条件去重）
• 四、.NET 6+ 新特性：DistinctBy()
• 五、性能与选型建议
• 总结

结合项目来看，在 .NET 开发里，处理集合数据时经常会遇到需对 List<T> 进行去重的场景。无论是基本类型（如 int、string）还是自定义对象，.NET 提供了多种简洁高效的去重方式。本文将系统介绍几种常用且性能良好的去重方法，同时对比其适用场景。

一、采用 LINQ 的 Distinct() 方法（最常用）

结合项目来看，LINQ 提供了最简洁的去重方式：Distinct() 扩展方法。

1. 基本类型去重

var numbers = new List<int> { 1, 2, 2, 3, 4, 4, 5 };
var uniqueNumbers = numbers.Distinct().ToList();
// 结果: [1, 2, 3, 4, 5]

2. 自定义对象去重（需实现 IEqualityComparer 或重写 Equals/GetHashCode）

若直接对自定义类调用 Distinct()，默认比较的是引用（除非重写了 Equals 和 GetHashCode）。

方式 A：重写 Equals 和 GetHashCode

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

    public override bool Equals(object obj) => obj is Person p && Name == p.Name && Age == p.Age;
    public override int GetHashCode() => HashCode.Combine(Name, Age);
}

var people = new List<Person>
{
    new Person { Name = "Alice", Age = 30 },
    new Person { Name = "Alice", Age = 30 },
    new Person { Name = "Bob", Age = 25 }
};

var uniquePeople = people.Distinct().ToList(); // 自动去重

方式 B：采用自定义 IEqualityComparer

public class PersonNameComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y) => x?.Name == y?.Name;
    public int GetHashCode(Person obj) => obj?.Name?.GetHashCode() ?? 0;
}

var uniqueByName = people.Distinct(new PersonNameComparer()).ToList();

二、采用 HashSet（高性能建议）

HashSet<T> 天然具有去重特性，插入时自动忽略重复项，性能优于 Distinct()（尤其在大数据量时）。

var numbers = new List<int> { 1, 2, 2, 3, 4, 4, 5 };
var uniqueNumbers = new HashSet<int>(numbers).ToList();

落到代码里，对于自定义对象，同样需提供合适的 IEqualityComparer<T>：

var uniquePeople = new HashSet<Person>(people, new PersonNameComparer()).ToList();

优点：时间复杂度接近 O(n)，适合频繁去重或大数据集。

注意：HashSet 不保证元素顺序（但 .NET Core 6+ 的 HashSet 在某些情况下保持插入顺序，不建议依赖此行为）。

三、采用 ToLookup / GroupBy（按条件去重）

结合项目来看，若需“保留第一个出现的元素”同时按特定字段去重，可结合 GroupBy：

var uniquePeople = people
    .GroupBy(p => p.Name)
    .Select(g => g.First())
    .ToList();

这种方式灵活，适用来复杂去重逻辑（如保留最新记录、按多个字段分组等）。

四、.NET 6+ 新特性：DistinctBy()

从实现思路看，从 .NET 6 开始，LINQ 新增了 DistinctBy() 方法，无需实现比较器即可按属性去重：

var uniquePeople = people.DistinctBy(p => p.Name).ToList();
// 或按多个属性
var uniqueByBoth = people.DistinctBy(p => new { p.Name, p.Age }).ToList();

强烈建议：代码简洁、语义清晰、性能良好，是现代 .NET 项目的首选方案。

五、性能与选型建议

总结

对于 基本类型，直接采用 Distinct() 即可。

对于 自定义对象：

• 若采用 .NET 6 及以上，优先采用 DistinctBy()；
• 若需兼容旧版本，可选择 GroupBy 或实现 IEqualityComparer<T>；
• 在这个场景下，若追求极致性能且不关心顺序，采用 HashSet<T>。

从实现思路看，合理选择去重方式，不仅能提升代码可读性，还能显著优化程序性能。希望本文能帮助你在 .NET 项目中高效处理集合去重问题！

到此这篇关于.NET高效实现List集合去重的多种方法详解的文章就介绍到这了,更多相关.NET List集合去重内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多兼容脚本之家！

您可能感兴趣的文章:

• .NET 中实现 List 集合去重的方法
• C# List.Distinct() 去重问题解决
• C#实现List＜T＞去重的多种高效方法
• C#之List集合去重复对象的实现方法
• C# list＜T＞去重的实现