C#--List-- 根据对象属性去重的（四种方法）对比

C# List 根据对象属性去重的四种方法对比

测试代码：

private void TestDistinct()
{
    Task.Run(() =>
    {
        //生成测试数据
        DateTime dt = DateTime.Now;
        Random rnd = new Random();
        List<MyData> list = new List<MyData>();
        int total = 1000000;
        for (int i = 0; i < total; i++)
        {
            MyData info = new MyData();
            info.id = rnd.Next(1, total * 10).ToString();
            info.name = rnd.Next(1, total * 10).ToString();
            list.Add(info);
        }
        double d = DateTime.Now.Subtract(dt).TotalMilliseconds;

        //方法一
        DateTime dt1 = DateTime.Now;
        Dictionary<string, MyData> result1 = new Dictionary<string, MyData>();
        foreach (MyData item in list)
        {
            MyData temp;
            if (!result1.TryGetValue(item.name, out temp))
            {
                result1.Add(item.name, item);
            }
        }
        List<MyData> r1 = result1.Values.ToList();
        double d1 = DateTime.Now.Subtract(dt1).TotalMilliseconds;

        //方法二
        DateTime dt2 = DateTime.Now;
        List<MyData> result2 = list.ToLookup(item => item.name).ToDictionary(item => item.Key, item => item.First()).Values.ToList();
        double d2 = DateTime.Now.Subtract(dt2).TotalMilliseconds;

        //方法三
        DateTime dt3 = DateTime.Now;
        List<MyData> result3 = list.Distinct(new MyCompare()).ToList();
        double d3 = DateTime.Now.Subtract(dt3).TotalMilliseconds;

        //方法四
        DateTime dt4 = DateTime.Now;
        List<MyData> result4 = list.GroupBy(item => item.name).Select(item => item.First()).ToList();
        double d4 = DateTime.Now.Subtract(dt4).TotalMilliseconds;

        this.BeginInvoke(new Action(() =>
        {
            textBox1.Text = "";
            textBox1.Text += "生成 " + list.Count.ToString("# ####") + " 条测试数据耗时：" + d + "毫秒\r\n\r\n";
            textBox1.Text += "使用方法一去重耗时：" + d1 + "毫秒\r\n\r\n";
            textBox1.Text += "使用ToLookup和ToDictionary去重耗时：" + d2 + "毫秒\r\n\r\n";
            textBox1.Text += "使用Distinct去重耗时：" + d3 + "毫秒\r\n\r\n";
            textBox1.Text += "使用GroupBy和Select去重耗时：" + d4 + "毫秒\r\n\r\n";
            textBox1.Text += "去重后数量：" + r1.Count + "，" + result2.Count + "，" + result3.Count + "，" + result4.Count + "" + "\r\n\r\n";
        }));
    });
}

数据类：

public class MyData
{
    public string id { get; set; }
    public string name { get; set; }
}

public class MyCompare : IEqualityComparer<MyData>
{
    public bool Equals(MyData x, MyData y)
    {
        return x.name == y.name;
    }

    public int GetHashCode(MyData obj)
    {
        return obj.name.GetHashCode();
    }
}

测试结果：

结论：

方法一和方法三 去重速度差不多，在一个数量级

方法二和方法四 去重速度差不多，在一个数量级

方法二和方法四 比方法一和方法三大约慢4、5倍左右

方法二和方法四 比较方便，一行代码搞定，方法一和方法三代码行数相对较多，方法三要写个MyCompare

******注意：值类型的List除外，例如List《int》)，List《string》，不需要 写MyCompare，，详细参考下面扩展）

。

原文：https://www.cnblogs.com/s0611163/archive/2019/08/23/11399898.html
。
。
。
。

扩展：

c#中关于list去重的问题

一： 值类型去重

List在我们日常的开发中可谓是常客，我个人也非常喜欢，从数据库查询出来的数据或者excel导入的数据，我都喜欢先转换为对应的类型list，在搭配System.Linq下的拓展方法，基本可以应付绝大多数的数据操作了。今天在做导入的时候，需要对数据先进行去重处理，发现有几个容易忽略的点，发出来大家一起探讨一下。

System.Linq下为IEnumerable（List是它的子类）拓展了Distinct方法，用于对结果集进行去重处理。下面我们来看一下我们可能正在犯的错误吧。

首先我们定义一个class来演示，并且向它追加一些重复的成员，看一下Distinct()的效果如何：

static void Main(string[] args)
{
    List<int> ints = new List<int>() { 12,12,23,45,23,23,23,23,23,12};
    ints.Add(45);
    List<int> newList = ints.Distinct().ToList();
    foreach (int item in newList) {
        Console.Write(item +",");
    }
    Console.Read();
}

结果输出： 12，23，45 很好没有问题，圆满的实现了我们的需求。
。
。
。

二：引用类型的去重

重点来了，我们再看一个例子，先定义个model类如下：

  public class TBINPN {
        public int  ID { get; set; }
        public string PN { get; set; }
        public string SPEC { get; set; }
        public string GOODS { get; set; }
        public string HSCODE { get; set; }
    }

创建一个List，并且向它追加一些重复的成员，看一下Distinct()的效果如何：

static void Main(string[] args)
    {
        List<tbinpn> tbinpns = new List<tbinpn>();
        tbinpns.Add(new tbinpn { ID = 0, PN = "123", SPEC = "123", GOODS = "123", HSCODE = "123" });
        tbinpns.Add(new tbinpn { ID = 0, PN = "123", SPEC = "123", GOODS = "123", HSCODE = "123" });
        tbinpns.Add(new tbinpn { ID = 0, PN = "123", SPEC = "123", GOODS = "123", HSCODE = "123" });
        tbinpns.Add(new tbinpn { ID = 0, PN = "123", SPEC = "123", GOODS = "123", HSCODE = "123" });
        List<tbinpn> newTbinpns = tbinpns.Distinct().ToList();
        Console.WriteLine($"去重后还剩 {newTbinpns.Count()} 条数据。");
        Console.Read();
    }

这次输出的结果有点奇怪了，我们的list中命名是4条完全重复的记录！

上面我们介绍到Distinct有两个重载，分别是：

第一个需要我们传递一个比较器，而我们刚刚使用的是第二个，没有给比较器，所以自动使用了默认的比较器，但是为啥第一个demo可以而第二个不行?因为第一个demo中 我们是对值类型进行去重的，默认的比较器是可以完成的，但是后面的demo是引用类型， 默认比较器比较的是其引用地址，list中的每一个元素都是一个新实例，所以地址是不一样的，因此没办法去重。

一起来看一下，如何自定义一个比较器，实现引用类型的去重吧，首先我们定义一个类集成IEqualityComparer接口，然后按照vs的提示我们让vs自动帮我们实现这个接口，然后我们修改Equals和GetHashCode这两个方法即可。代码如下：

  public class Comparer: IEqualityComparer<TBINPN>
    {
        public bool Equals(TBINPN x, TBINPN y)
        {
            //这里定义比较的逻辑
            return x.ID == y.ID && x.PN == y.PN;
        }
 
        public int GetHashCode(TBINPN obj)
        {
            //返回字段的HashCode，只有HashCode相同才会去比较
            return obj.ID.GetHashCode();
        }
    }

将刚刚的代码稍作修改，将比较器传递进去看一下结果：

static void Main(string[] args)
{
    List<TBINPN> tbinpns = new List<TBINPN>();
    tbinpns.Add(new TBINPN { ID = 1, PN = "123", SPEC = "123", GOODS = "123", HSCODE = "123" });
    tbinpns.Add(new TBINPN { ID = 1, PN = "123", SPEC = "123", GOODS = "123", HSCODE = "123" });
    tbinpns.Add(new TBINPN { ID = 2, PN = "321123", SPEC = "123", GOODS = "123", HSCODE = "123" });
    tbinpns.Add(new TBINPN { ID = 2, PN = "321123", SPEC = "123", GOODS = "123", HSCODE = "123" });
    List<TBINPN> newTbinpns = tbinpns.Distinct(new Comparer()).ToList();
    Console.WriteLine($"去重后还剩 {newTbinpns.Count()} 条数据。");
    Console.Read();
}

结果表明我们已经实现了引用类型的去重。

————————————————
版权声明：本文为CSDN博主「Ma-Aici」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/maaici/article/details/89703286