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