說到對集合去重處理，第一時間想到的肯定是Linq的Distinct擴充套件方式，對於一般的值型別集合去重，很好處理，直接list.Distinct()即可。但是如果想要對一個引用型別的集合去重（屬性值都相同就認為重複），就會發現，直接Distinct()是不行的

先來看看泛型連結串列 List<T> 的定義：

public class List<T> : IList<T>, ICollection<T>, IList, ICollection, IReadOnlyList<T>, IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable

var list=new List<SampleVersionDto>()///表明具有重複值得集合

有時候Distinct（）不能對引用型別去重時 我們就要自定義了 自定義程式碼如下：

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
}

var list = new List<User>() 
{ 
    new User() { Id = 1, Name = "張三" } ,
    new User() { Id = 1, Name = "張三" } ,
    new User() { Id = 3, Name = "李四" } ,
};

var newList1 = list.Distinct().ToList();

執行上述程式碼會發現，並不是預期想要的結果，newList1還是有3個元素。之所以會產生這樣的結果，是因為Distinct()是通過使用預設的相等比較器對值進行比較返回序列中的非重複元素。對於值型別，預設的相等比較器是比較值是否相等，對於引用型別，預設的相等比較器是比較物件的引用地址，所以上述例子中即使屬性值都相同，也不能去重。

IEqualityComparer<TSource>

聰明的我們，很容易就能發現，Linq已經為我們過載了一個去重方法，可以滿足我們的需求：

public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer);

過載的這個方法，多提供了一個引數IEqualityComparer<TSource> comparer，是一個泛型介面，我們只需要對這個介面進行實現，即可滿足我們的去重需求：

public class UserComparer : IEqualityComparer<User>
{
    public bool Equals(User x, User y)
    {
        return x.Id == y.Id && x.Name == y.Name;
    }

    public int GetHashCode(User obj)
    {
        return obj.ToString().GetHashCode();
    }
}

IEqualityComparer<TSource> 定義了兩個方法，一個是Equals，一個是GetHashCode。這裡我查詢參考資料發現，進行比較時，預設先通過GetHashCode對兩個元素進行比較，如果HashCode不同，則認為兩個元素不同，如果相同則再通過Equals方法比較。所以這裡我不能直接將User物件GetHashCode處理，而是先轉換成了字串再GetHashCode。通過這個過載方法，我們就可以到達目的了：

ar newList2 = list.Distinct(new UserComparer()).ToList();

甚至我們還可以實現只要某個屬性相同就認為重複的效果，只需要在Equals方法按想要比較方式進行處理即可

延伸思考

Distinct的過載方法，基本已經能夠滿足我們的各式各樣的去重需求了，但是想來想去，還是覺得有點彆扭，那就是如果有類似的去重需求，我們都要新增一個類去實現IEqualityComparer<TSource>介面，不夠靈活，本著封裝重用的原則，想了想能否在這方面進行優化。恰巧最近在搞一個Android專案，學習了一下java，瞭解到java有一個匿名實現介面的語法特性，如果C#也能匿名實現介面，那就不需要增加那麼多類去實現介面，會方便很多。很遺憾C#中沒有這個特性，看了下資料我感覺java其實也不算是真正意義上的匿名實現，它是編譯器做了手腳，編譯的時候生成了一個真實的類去實現介面。在一番查詢資料後，終於找到了一個很好的解決方案：

public class LambdaComparer<T> : IEqualityComparer<T>
{
    private readonly Func<T, T, bool> _lambdaComparer;
    private readonly Func<T, int> _lambdaHash;
    public LambdaComparer(Func<T, T, bool> lambdaComparer)
        : this(lambdaComparer, EqualityComparer<T>.Default.GetHashCode)
    {
    }
    public LambdaComparer(Func<T, T, bool> lambdaComparer, Func<T, int> lambdaHash)
    {
        if (lambdaComparer == null)
            throw new ArgumentNullException("lambdaComparer");
        if (lambdaHash == null)
            throw new ArgumentNullException("lambdaHash");
            _lambdaComparer = lambdaComparer;
            _lambdaHash = lambdaHash;
    }

    public bool Equals(T x, T y)
    {
        return _lambdaComparer(x, y);
    }

    public int GetHashCode(T obj)
    {
        return _lambdaHash(obj);
    }
}

很巧妙的採用了泛型委託的方式，實現只需要定義一個類實現IEqualityComparer<TSource>介面，Equals、GetHashCode的實現，由傳入的委託方法決定，接下來就簡單了

var newList3 = list.Distinct(new LambdaComparer<User>((a, b) => a.Id == b.Id && a.Name == b.Name, obj => obj.ToString().GetHashCode())).ToList();

是不是很熟悉的寫法，想怎麼比較就怎麼比較，方便快捷，不需要定義那麼多類去實現介面，目的達到。Linq中有很多擴充套件方法，都會用到IEqualityComparer<TSource>介面。通過這種方式，可以大大提高重用率

參考資料

1、https://www.cnblogs.com/mirageJ/p/8950842.html

2、https://ask.helplib.com/c-Sharp/post_127