C#黔驢技巧之去重（Distinct）

C#黔驢技巧之去重（Distinct）

前言

關于C#中預設的Distinct方法在什麼情況下才能去重，這個就不用我再多講，針對集合對象去重預設實作将不再滿足，于是乎我們需要自定義實作來解決這個問題，接下來我們詳細講解幾種常見去重方案，孰好孰歹自行判之。

分組

首先給出我們需要用到的對象，如下：

public class Person

{

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

}

接下來我們添加100萬條資料到集合中，如下：

var list = new List();

for (int i = 0; i < 1000000; i++)

list.Add(new Person() { Age = 18, Name = "jeffcky" });           

接下來我們對年齡和名稱進行分組，然後取第一條即可達到去重，如下：

list = list.GroupBy(d => new { d.Age, d.Name })

.Select(d => d.FirstOrDefault())
.ToList();           

擴充方法（HashSet去重）

我們知道在C#中HashSet對于重複元素會進行過濾篩選，是以我們寫下如下擴充方法，周遊集合元素，最後利用HashSet進行過濾達到去重目的，如下：

public static IEnumerable Distinct(

this IEnumerable<TSource> source,
    Func<TSource, TKey> keySelector)
{
    var hashSet = new HashSet<TKey>();
    
    foreach (TSource element in source)
    {
        if (hashSet.Add(keySelector(element)))
        {
            yield return element;
        }
    }
}
           

最後調用上述擴充方法即可去重，如下：

list = list.Distinct(d => new { d.Age, d.Name }).ToList();

擴充方法（IEqualityComparer去重）

在實際項目中有很多通過具體實作類實作該接口，通過重寫Equals和HashCode比較屬性值來達到去重目的，因為對于每一個類都得實作對應比較器，是以并不通用，反而利用上述方式才是最佳，其實我們大可借助該比較接口實作通用解決方案，對于每一個類都得實作一個比較器的原因在于，我們将屬性比較放在類該接口内部，如果我們将屬性比較放在外圍呢，這個時候就達到了通用解決方案，那麼我們怎麼實作呢，通過委托來實作，實作該接口的本質無非就是比較HashCode，然後通過Equals比較其值，當比較HashCode時，我們強制其值為一個常量（比如0），當重寫Equals方法我們調用委托即可，如下：

public static class Extensions

public static IEnumerable<T> Distinct<T>(
    this IEnumerable<T> source, Func<T, T, bool> comparer)
    where T : class
    => source.Distinct(new DynamicEqualityComparer<T>(comparer));

private sealed class DynamicEqualityComparer<T> : IEqualityComparer<T>
    where T : class
{
    private readonly Func<T, T, bool> _func;

    public DynamicEqualityComparer(Func<T, T, bool> func)
    {
        _func = func;
    }

    public bool Equals(T x, T y) => _func(x, y);

    public int GetHashCode(T obj) => 0;
}           

最終通過指定屬性進行比較即可去重，如下：

list = list.Distinct((a, b) => a.Age == b.Age && a.Name == b.Name).ToList();

性能比較

以上3種常見方式我們已經介紹完畢了，當資料量比較小時，我們大可忽略對集合進行各種操作所帶來的性能，但是一旦資料量很大時，我們可能需要考慮性能，能節省一點時間或許有必要，于是乎，在上述100萬條資料前提下，我們來分析其耗時情況，如下：

list.Add(new Person() { Age = 18, Name = "jeffcky" });           

var time1 = Time(() =>

list.GroupBy(d => new { d.Age, d.Name })
    .Select(d => d.FirstOrDefault())
    .ToList();           

});

Console.WriteLine($"分組耗時：{time1}");

var time2 = Time(() =>

list.Distinct(d => new { d.Age, d.Name }).ToList();           

Console.WriteLine($"HashSet耗時：{time2}");

var time3 = Time(() =>

list.Distinct((a, b) => a.Age == b.Age && a.Name == b.Name).ToList();           

Console.WriteLine($"委托耗時：{time3}");

static long Time(Action action)

var stopwatch = new Stopwatch();
stopwatch.Start();
action();
stopwatch.Stop();
return stopwatch.ElapsedMilliseconds;           

總結

上述結果耗時大小比較理論應該不會出現逆轉的情況，隻是多少的問題，資料量較少時理論上差異也很明顯，本文對于去重方式隻是基于性能角度來分析，還是那句話大部分情況下，我們完全不需要考慮這些問題，不過，作為程式員的我們可能也想寫出高性能、高品質的代碼吧，有時候多考慮考慮也無妨，對自身有個好的代碼品質要求也未嘗不可，也還是那句話，孰好孰歹，自行判之。

原文位址

https://www.cnblogs.com/CreateMyself/p/12863407.html