Một số chức năng Linq.Enable có thể có một IEqualityComparer<T>. Có một lớp bao bọc thuận tiện thích nghi delegate(T,T)=>boolđể thực hiện IEqualityComparer<T>không? Thật dễ dàng để viết một cái (nếu bạn bỏ qua vấn đề với việc xác định mã băm chính xác), nhưng tôi muốn biết liệu có giải pháp vượt trội nào không.

Cụ thể, tôi muốn thực hiện cài đặt các thao tác trên Dictionarys, chỉ sử dụng Khóa để xác định tư cách thành viên (trong khi vẫn giữ các giá trị theo các quy tắc khác nhau).

Thông thường, tôi sẽ giải quyết vấn đề này bằng cách bình luận @Sam về câu trả lời (Tôi đã thực hiện một số chỉnh sửa trên bài đăng gốc để dọn dẹp nó một chút mà không thay đổi hành vi.)

Sau đây là câu trả lời của tôi về câu trả lời của @ Sam , với bản sửa lỗi quan trọng [IMNSHO] cho chính sách băm mặc định: -

class FuncEqualityComparer<T> : IEqualityComparer<T>
{
    readonly Func<T, T, bool> _comparer;
    readonly Func<T, int> _hash;

    public FuncEqualityComparer( Func<T, T, bool> comparer )
        : this( comparer, t => 0 ) // NB Cannot assume anything about how e.g., t.GetHashCode() interacts with the comparer's behavior
    {
    }

    public FuncEqualityComparer( Func<T, T, bool> comparer, Func<T, int> hash )
    {
        _comparer = comparer;
        _hash = hash;
    }

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

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

Về tầm quan trọng của GetHashCode

Những người khác đã nhận xét về thực tế rằng bất kỳ IEqualityComparer<T>triển khai tùy chỉnh nào thực sự nên bao gồm một GetHashCodephương thức ; nhưng không ai bận tâm để giải thích tại sao trong bất kỳ chi tiết.

Đây là lý do tại sao. Câu hỏi của bạn đặc biệt đề cập đến các phương pháp mở rộng LINQ; gần như tất cả các mã này dựa vào mã băm để hoạt động chính xác, bởi vì chúng sử dụng các bảng băm trong nội bộ để đạt hiệu quả.

Lấy Distinctví dụ. Hãy xem xét ý nghĩa của phương pháp mở rộng này nếu tất cả những gì nó sử dụng là một Equalsphương pháp. Làm thế nào để bạn xác định xem một mục đã được quét theo trình tự nếu bạn chỉ có Equals? Bạn liệt kê toàn bộ bộ sưu tập các giá trị bạn đã xem và kiểm tra sự trùng khớp. Điều này sẽ dẫn đến Distinctviệc sử dụng thuật toán O (N ² ) trong trường hợp xấu nhất thay vì thuật toán O (N)!

May mắn thay, đây không phải là trường hợp. Distinctkhông chỉ sử dụng Equals; nó sử dụng GetHashCodelà tốt. Trong thực tế, nó hoàn toàn không hoạt động đúng mà không có một IEqualityComparer<T>nguồn cung cấp phù hợpGetHashCode . Dưới đây là một ví dụ giả định minh họa điều này.

Nói rằng tôi có loại sau:

class Value
{
    public string Name { get; private set; }
    public int Number { get; private set; }

    public Value(string name, int number)
    {
        Name = name;
        Number = number;
    }

    public override string ToString()
    {
        return string.Format("{0}: {1}", Name, Number);
    }
}

Bây giờ nói rằng tôi có một List<Value>và tôi muốn tìm tất cả các yếu tố với một tên riêng biệt. Đây là một trường hợp sử dụng hoàn hảo để Distinctsử dụng một bộ so sánh bình đẳng tùy chỉnh. Vì vậy, hãy sử dụng Comparer<T>lớp từ câu trả lời của Aku :

var comparer = new Comparer<Value>((x, y) => x.Name == y.Name);

Bây giờ, nếu chúng ta có một loạt các Valuephần tử có cùng thuộc Nametính, tất cả chúng sẽ thu gọn thành một giá trị được trả về Distinct, phải không? Hãy xem nào...

var values = new List<Value>();

var random = new Random();
for (int i = 0; i < 10; ++i)
{
    values.Add("x", random.Next());
}

var distinct = values.Distinct(comparer);

foreach (Value x in distinct)
{
    Console.WriteLine(x);
}

Đầu ra:

x: 1346013431
x: 1388845617
x: 1576754134
x: 1104067189
x: 1144789201
x: 1862076501
x: 1573781440
x: 646797592
x: 655632802
x: 1206819377

Hmm, điều đó đã không làm việc, phải không?

Thế còn GroupBy? Hãy thử xem:

var grouped = values.GroupBy(x => x, comparer);

foreach (IGrouping<Value> g in grouped)
{
    Console.WriteLine("[KEY: '{0}']", g);
    foreach (Value x in g)
    {
        Console.WriteLine(x);
    }
}

Đầu ra:

[KEY = 'x: 1346013431']
x: 1346013431
[KEY = 'x: 1388845617']
x: 1388845617
[KEY = 'x: 1576754134']
x: 1576754134
[KEY = 'x: 1104067189']
x: 1104067189
[KEY = 'x: 1144789201']
x: 1144789201
[KEY = 'x: 1862076501']
x: 1862076501
[KEY = 'x: 1573781440']
x: 1573781440
[KEY = 'x: 646797592']
x: 646797592
[KEY = 'x: 655632802']
x: 655632802
[KEY = 'x: 1206819377']
x: 1206819377

Một lần nữa: không hoạt động.

Nếu bạn nghĩ về nó, nó sẽ làm cho ý nghĩa đối với Distinctsử dụng một HashSet<T>(hoặc tương đương) trong nội bộ, và cho GroupByđến việc sử dụng một cái gì đó giống như một Dictionary<TKey, List<T>>nội bộ. Điều này có thể giải thích tại sao các phương pháp này không hoạt động? Chúng ta hãy cố gắng này:

var uniqueValues = new HashSet<Value>(values, comparer);

foreach (Value x in uniqueValues)
{
    Console.WriteLine(x);
}

Đầu ra:

x: 1346013431
x: 1388845617
x: 1576754134
x: 1104067189
x: 1144789201
x: 1862076501
x: 1573781440
x: 646797592
x: 655632802
x: 1206819377

Vâng ... bắt đầu có ý nghĩa?

Hy vọng từ những ví dụ này, rõ ràng tại sao bao gồm một sự phù hợp GetHashCodetrong bất kỳ IEqualityComparer<T>triển khai nào lại quan trọng đến vậy.

Câu trả lời gốc

Mở rộng câu trả lời của orip :

Có một vài cải tiến có thể được thực hiện ở đây.

1. Đầu tiên, tôi sẽ Func<T, TKey>thay thế Func<T, object>; điều này sẽ ngăn quyền anh của các loại khóa giá trị trong thực tế keyExtractor.
2. Thứ hai, tôi thực sự thêm một where TKey : IEquatable<TKey>ràng buộc; điều này sẽ ngăn quyền anh trong Equalscuộc gọi ( object.Equalslấy objecttham số; bạn cần IEquatable<TKey>triển khai để lấy TKeytham số mà không cần quyền anh). Rõ ràng điều này có thể đặt ra một hạn chế quá nghiêm trọng, vì vậy bạn có thể tạo một lớp cơ sở mà không có sự ràng buộc và một lớp dẫn xuất với nó.

Đây là mã kết quả có thể trông như thế nào:

public class KeyEqualityComparer<T, TKey> : IEqualityComparer<T>
{
    protected readonly Func<T, TKey> keyExtractor;

    public KeyEqualityComparer(Func<T, TKey> keyExtractor)
    {
        this.keyExtractor = keyExtractor;
    }

    public virtual bool Equals(T x, T y)
    {
        return this.keyExtractor(x).Equals(this.keyExtractor(y));
    }

    public int GetHashCode(T obj)
    {
        return this.keyExtractor(obj).GetHashCode();
    }
}

public class StrictKeyEqualityComparer<T, TKey> : KeyEqualityComparer<T, TKey>
    where TKey : IEquatable<TKey>
{
    public StrictKeyEqualityComparer(Func<T, TKey> keyExtractor)
        : base(keyExtractor)
    { }

    public override bool Equals(T x, T y)
    {
        // This will use the overload that accepts a TKey parameter
        // instead of an object parameter.
        return this.keyExtractor(x).Equals(this.keyExtractor(y));
    }
}

Khi bạn muốn tùy chỉnh kiểm tra đẳng thức, 99% thời gian bạn quan tâm đến việc xác định các khóa để so sánh, chứ không phải so sánh chính nó.

Đây có thể là một giải pháp tao nhã (khái niệm từ phương pháp sắp xếp danh sách của Python ).

Sử dụng:

var foo = new List<string> { "abc", "de", "DE" };

// case-insensitive distinct
var distinct = foo.Distinct(new KeyEqualityComparer<string>( x => x.ToLower() ) );

Cả KeyEqualityComparerlớp

public class KeyEqualityComparer<T> : IEqualityComparer<T>
{
    private readonly Func<T, object> keyExtractor;

    public KeyEqualityComparer(Func<T,object> keyExtractor)
    {
        this.keyExtractor = keyExtractor;
    }

    public bool Equals(T x, T y)
    {
        return this.keyExtractor(x).Equals(this.keyExtractor(y));
    }

    public int GetHashCode(T obj)
    {
        return this.keyExtractor(obj).GetHashCode();
    }
}

Tôi sợ rằng không có bao bì ngoài hộp như vậy. Tuy nhiên, không khó để tạo một:

class Comparer<T>: IEqualityComparer<T>
{
    private readonly Func<T, T, bool> _comparer;

    public Comparer(Func<T, T, bool> comparer)
    {
        if (comparer == null)
            throw new ArgumentNullException("comparer");

        _comparer = comparer;
    }

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

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

...

Func<int, int, bool> f = (x, y) => x == y;
var comparer = new Comparer<int>(f);
Console.WriteLine(comparer.Equals(1, 1));
Console.WriteLine(comparer.Equals(1, 2));

Giống như câu trả lời của Dan Tao, nhưng với một vài cải tiến:

1. Dựa vào EqualityComparer<>.Defaultđể thực hiện so sánh thực tế để nó tránh quyền anh đối với các loại giá trị structđã thực hiện IEquatable<>.

2. Kể từ khi EqualityComparer<>.Defaultsử dụng, nó không phát nổnull.Equals(something) .

3. Cung cấp bao bọc tĩnh xung quanh IEqualityComparer<> sẽ có một phương thức tĩnh để tạo phiên bản so sánh - giảm bớt cuộc gọi. Đối chiếu

   Equality<Person>.CreateComparer(p => p.ID);

   với

   new EqualityComparer<Person, int>(p => p.ID);

4. Đã thêm quá tải để chỉ định IEqualityComparer<> cho khóa.

Lớp:

public static class Equality<T>
{
    public static IEqualityComparer<T> CreateComparer<V>(Func<T, V> keySelector)
    {
        return CreateComparer(keySelector, null);
    }

    public static IEqualityComparer<T> CreateComparer<V>(Func<T, V> keySelector, 
                                                         IEqualityComparer<V> comparer)
    {
        return new KeyEqualityComparer<V>(keySelector, comparer);
    }

    class KeyEqualityComparer<V> : IEqualityComparer<T>
    {
        readonly Func<T, V> keySelector;
        readonly IEqualityComparer<V> comparer;

        public KeyEqualityComparer(Func<T, V> keySelector, 
                                   IEqualityComparer<V> comparer)
        {
            if (keySelector == null)
                throw new ArgumentNullException("keySelector");

            this.keySelector = keySelector;
            this.comparer = comparer ?? EqualityComparer<V>.Default;
        }

        public bool Equals(T x, T y)
        {
            return comparer.Equals(keySelector(x), keySelector(y));
        }

        public int GetHashCode(T obj)
        {
            return comparer.GetHashCode(keySelector(obj));
        }
    }
}

bạn có thể sử dụng nó như thế này:

var comparer1 = Equality<Person>.CreateComparer(p => p.ID);
var comparer2 = Equality<Person>.CreateComparer(p => p.Name);
var comparer3 = Equality<Person>.CreateComparer(p => p.Birthday.Year);
var comparer4 = Equality<Person>.CreateComparer(p => p.Name, StringComparer.CurrentCultureIgnoreCase);

Người là một lớp đơn giản:

class Person
{
    public int ID { get; set; }
    public string Name { get; set; }
    public DateTime Birthday { get; set; }
}

public class FuncEqualityComparer<T> : IEqualityComparer<T>
{
    readonly Func<T, T, bool> _comparer;
    readonly Func<T, int> _hash;

    public FuncEqualityComparer( Func<T, T, bool> comparer )
        : this( comparer, t => t.GetHashCode())
    {
    }

    public FuncEqualityComparer( Func<T, T, bool> comparer, Func<T, int> hash )
    {
        _comparer = comparer;
        _hash = hash;
    }

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

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

Với phần mở rộng: -

public static class SequenceExtensions
{
    public static bool SequenceEqual<T>( this IEnumerable<T> first, IEnumerable<T> second, Func<T, T, bool> comparer )
    {
        return first.SequenceEqual( second, new FuncEqualityComparer<T>( comparer ) );
    }

    public static bool SequenceEqual<T>( this IEnumerable<T> first, IEnumerable<T> second, Func<T, T, bool> comparer, Func<T, int> hash )
    {
        return first.SequenceEqual( second, new FuncEqualityComparer<T>( comparer, hash ) );
    }
}

Câu trả lời của orip là tuyệt vời.

Đây là một phương pháp mở rộng để làm cho nó dễ dàng hơn nữa:

public static IEnumerable<T> Distinct<T>(this IEnumerable<T> list, Func<T, object>    keyExtractor)
{
    return list.Distinct(new KeyEqualityComparer<T>(keyExtractor));
}
var distinct = foo.Distinct(x => x.ToLower())

Tôi sẽ trả lời câu hỏi của riêng tôi. Để coi Từ điển là tập hợp, phương pháp đơn giản nhất dường như là áp dụng các thao tác tập hợp cho dict.Keys, sau đó chuyển đổi trở lại Từ điển với Enumerable.ToDixi (...).

Việc triển khai tại (văn bản tiếng Đức) Triển khai IEqualityCompare với biểu thức lambda quan tâm đến các giá trị null và sử dụng các phương thức mở rộng để tạo IEqualityComparer.

Để tạo một IEqualityComparer trong liên minh Linq, bạn chỉ cần viết

persons1.Union(persons2, person => person.LastName)

Bộ so sánh:

public class LambdaEqualityComparer<TSource, TComparable> : IEqualityComparer<TSource>
{
  Func<TSource, TComparable> _keyGetter;

  public LambdaEqualityComparer(Func<TSource, TComparable> keyGetter)
  {
    _keyGetter = keyGetter;
  }

  public bool Equals(TSource x, TSource y)
  {
    if (x == null || y == null) return (x == null && y == null);
    return object.Equals(_keyGetter(x), _keyGetter(y));
  }

  public int GetHashCode(TSource obj)
  {
    if (obj == null) return int.MinValue;
    var k = _keyGetter(obj);
    if (k == null) return int.MaxValue;
    return k.GetHashCode();
  }
}

Bạn cũng cần thêm một phương thức mở rộng để hỗ trợ suy luận kiểu

public static class LambdaEqualityComparer
{
       // source1.Union(source2, lambda)
        public static IEnumerable<TSource> Union<TSource, TComparable>(
           this IEnumerable<TSource> source1, 
           IEnumerable<TSource> source2, 
            Func<TSource, TComparable> keySelector)
        {
            return source1.Union(source2, 
               new LambdaEqualityComparer<TSource, TComparable>(keySelector));
       }
   }

Chỉ cần một tối ưu hóa: Chúng ta có thể sử dụng EqualityComparer bên ngoài để so sánh giá trị, thay vì ủy thác nó.

Điều này cũng sẽ làm cho việc triển khai sạch hơn khi logic so sánh thực tế hiện nằm trong GetHashCode () và Equals () mà bạn có thể đã bị quá tải.

Đây là mã:

public class MyComparer<T> : IEqualityComparer<T> 
{ 
  public bool Equals(T x, T y) 
  { 
    return EqualityComparer<T>.Default.Equals(x, y); 
  } 

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

Đừng quên quá tải các phương thức GetHashCode () và Equals () trên đối tượng của bạn.

Bài đăng này đã giúp tôi: c # so sánh hai giá trị chung

Sushil

câu trả lời của orip là tuyệt vời. Mở rộng câu trả lời của orip:

tôi nghĩ rằng khóa của giải pháp là sử dụng "Phương thức mở rộng" để chuyển "loại ẩn danh".

    public static class Comparer 
    {
      public static IEqualityComparer<T> CreateComparerForElements<T>(this IEnumerable<T> enumerable, Func<T, object> keyExtractor)
      {
        return new KeyEqualityComparer<T>(keyExtractor);
      }
    }

Sử dụng:

var n = ItemList.Select(s => new { s.Vchr, s.Id, s.Ctr, s.Vendor, s.Description, s.Invoice }).ToList();
n.AddRange(OtherList.Select(s => new { s.Vchr, s.Id, s.Ctr, s.Vendor, s.Description, s.Invoice }).ToList(););
n = n.Distinct(x=>new{Vchr=x.Vchr,Id=x.Id}).ToList();

public static Dictionary<TKey, TValue> Distinct<TKey, TValue>(this IEnumerable<TValue> items, Func<TValue, TKey> selector)
  {
     Dictionary<TKey, TValue> result = null;
     ICollection collection = items as ICollection;
     if (collection != null)
        result = new Dictionary<TKey, TValue>(collection.Count);
     else
        result = new Dictionary<TKey, TValue>();
     foreach (TValue item in items)
        result[selector(item)] = item;
     return result;
  }

Điều này cho phép chọn một thuộc tính với lambda như thế này: .Select(y => y.Article).Distinct(x => x.ArticleID);

Tôi không biết về một lớp hiện có nhưng đại loại như:

public class MyComparer<T> : IEqualityComparer<T>
{
  private Func<T, T, bool> _compare;
  MyComparer(Func<T, T, bool> compare)
  {
    _compare = compare;
  }

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

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

Lưu ý: Tôi chưa thực sự biên dịch và chạy nó, vì vậy có thể có lỗi đánh máy hoặc lỗi khác.