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

前言

關於C#中默認的Distinct方法在什麼狀況下才能去重，這個就不用我再多講，針對集合對象去重默認實現將再也不知足，因而乎咱們須要自定義實現來解決這個問題，接下來咱們詳細講解幾種常見去重方案，孰好孰歹自行判之。

分組

首先給出咱們須要用到的對象，以下：

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

接下來咱們添加100萬條數據到集合中，以下：

var list = new List<Person>();
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<TSource> Distinct<TSource, TKey>(
        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萬條數據前提下，咱們來分析其耗時狀況，以下：

var list = new List<Person>();
for (int i = 0; i < 1000000; i++)
{
    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;
}

總結

上述結果耗時大小比較理論應該不會出現逆轉的狀況，只是多少的問題，數據量較少時理論上差別也很明顯，本文對於去重方式只是基於性能角度來分析，仍是那句話大部分狀況下，咱們徹底不須要考慮這些問題，不過，做爲程序員的咱們可能也想寫出高性能、高質量的代碼吧，有時候多考慮考慮也無妨，對自身有個好的代碼質量要求也何嘗不可，也仍是那句話，孰好孰歹，自行判之。