Оберните делегата в IEqualityComparer
Вопрос
Некоторые функции Linq.Enumerable принимают IEqualityComparer<T>
.Есть ли удобный класс-оболочка, который адаптирует delegate(T,T)=>bool
реализовать IEqualityComparer<T>
?Написать его достаточно легко (если вы игнорируете проблемы с определением правильного хэш-кода), но мне хотелось бы знать, существует ли готовое решение.
В частности, я хочу выполнять операции над множествами Dictionary
s, используя только ключи для определения членства (с сохранением значений в соответствии с разными правилами).
Решение
Обычно я бы решил эту проблему, прокомментировав ответ @Sam (я немного отредактировал исходное сообщение, чтобы немного его очистить, не меняя поведения).
Ниже приводится мой рифф @ Ответ Сэма, с критическим исправлением [IMNSHO] для политики хеширования по умолчанию: -
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 );
}
}
Другие советы
О важности GetHashCode
Другие уже прокомментировали тот факт, что любой обычай IEqualityComparer<T>
выполнение действительно должен включать GetHashCode
метод;но никто не удосужился объяснить почему в любых подробностях.
Вот почему.В вашем вопросе конкретно упоминаются методы расширения LINQ;около все из них для правильной работы полагаются на хеш-коды, поскольку для повышения эффективности они используют внутренние хэш-таблицы.
Брать Distinct
, например.Рассмотрим последствия этого метода расширения, если бы все, что он использовал, было бы Equals
метод.Как определить, сканировался ли уже элемент в последовательности, если у вас есть только Equals
?Вы перебираете всю коллекцию значений, которые вы уже просмотрели, и проверяете совпадение.Это приведет к Distinct
используя наихудший случай O(N2) вместо алгоритма O(N)!
К счастью, это не так. Distinct
не делает только использовать Equals
;оно использует GetHashCode
также.Фактически, это абсолютно не работать нормально без IEqualityComparer<T>
который обеспечивает надлежащее GetHashCode
.Ниже приведен надуманный пример, иллюстрирующий это.
Скажем, у меня есть следующий тип:
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);
}
}
Теперь скажем, что у меня есть List<Value>
и я хочу найти все элементы с разными именами.Это идеальный вариант использования Distinct
использование специального компаратора равенства.Итак, давайте воспользуемся Comparer<T>
класс из Ответ Аку:
var comparer = new Comparer<Value>((x, y) => x.Name == y.Name);
Теперь, если у нас есть куча Value
элементы с одинаковым Name
свойство, все они должны сжаться в одно значение, возвращаемое Distinct
, верно?Давайте посмотрим...
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);
}
Выход:
x: 1346013431 x: 1388845717 x: 1576754134 x: 1104067189 x: 1144789201 x: 1862076501 x: 1573781440 x: 646797592 x: 655632802 x: 1206819377
Хм, это не сработало, не так ли?
Как насчет GroupBy
?Давайте попробуем это:
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);
}
}
Выход:
[KEY = 'x: 1346013431'] x: 1346013431 [KEY = 'x: 1388845717'] x: 1388845717 [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
Снова:не сработало.
Если подумать, это имело бы смысл Distinct
использовать HashSet<T>
(или эквивалент) для внутреннего использования, а также для GroupBy
использовать что-то вроде Dictionary<TKey, List<T>>
внутренне.Может ли это объяснить, почему эти методы не работают?Давайте попробуем это:
var uniqueValues = new HashSet<Value>(values, comparer);
foreach (Value x in uniqueValues)
{
Console.WriteLine(x);
}
Выход:
x: 1346013431 x: 1388845717 x: 1576754134 x: 1104067189 x: 1144789201 x: 1862076501 x: 1573781440 x: 646797592 x: 655632802 x: 1206819377
Ага...начинает обретать смысл?
Надеемся, из этих примеров станет понятно, почему включение подходящего GetHashCode
в любой IEqualityComparer<T>
реализация очень важна.
Оригинальный ответ
Расширение ответ Орипа:
Здесь можно сделать несколько улучшений.
- Во-первых, я бы взял
Func<T, TKey>
вместоFunc<T, object>
;это предотвратит упаковку ключей типа значения в фактическомkeyExtractor
сам. - Во-вторых, я бы добавил
where TKey : IEquatable<TKey>
ограничение;это предотвратит бокс вEquals
вызов (object.Equals
принимаетobject
параметр;тебе нуженIEquatable<TKey>
реализация, чтобы принятьTKey
параметр без его упаковки).Очевидно, что это может наложить слишком серьезное ограничение, поэтому вы можете создать базовый класс без ограничения и производный класс с ним.
Вот как может выглядеть результирующий код:
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));
}
}
Если вы хотите настроить проверку на равенство, в 99% случаев вас интересует определение ключей для сравнения, а не само сравнение.
Это могло бы быть элегантным решением (концепция из Python метод сортировки списка).
Использование:
var foo = new List<string> { "abc", "de", "DE" };
// case-insensitive distinct
var distinct = foo.Distinct(new KeyEqualityComparer<string>( x => x.ToLower() ) );
А KeyEqualityComparer
сорт:
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();
}
}
Боюсь, такой обертки из коробки нет.Однако создать его не сложно:
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));
То же, что и ответ Дэна Тао, но с некоторыми улучшениями:
Опирается на
EqualityComparer<>.Default
выполнить фактическое сравнение, чтобы избежать упаковки для типов значений (struct
s), который реализовалIEquatable<>
.С
EqualityComparer<>.Default
использовался, он не взрываетсяnull.Equals(something)
.Предоставлена статическая оболочка вокруг
IEqualityComparer<>
который будет иметь статический метод для создания экземпляра компаратора - упрощает вызов.СравниватьEquality<Person>.CreateComparer(p => p.ID);
с
new EqualityComparer<Person, int>(p => p.ID);
Добавлена перегрузка для указания
IEqualityComparer<>
для ключа.
Класс:
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));
}
}
}
вы можете использовать его следующим образом:
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);
Человек — это простой класс:
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 );
}
}
С расширениями: -
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 ) );
}
}
ответ Орипа великолепен.
Вот небольшой метод расширения, чтобы сделать его еще проще:
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())
Я собираюсь ответить на свой вопрос.Чтобы рассматривать словари как наборы, самым простым методом является применение операций над наборами к dict.Keys, а затем преобразование обратно в словари с помощью Enumerable.ToDictionary(...).
Реализация на (текст на немецком языке) Реализация IEqualityCompare с лямбда-выражениемзаботится о нулевых значениях и использует методы расширения для создания IEqualityComparer.
Чтобы создать IEqualityComparer в объединении Linq, вам просто нужно написать
persons1.Union(persons2, person => person.LastName)
Компаратор:
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();
}
}
Вам также необходимо добавить метод расширения для поддержки вывода типа.
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));
}
}
Всего одна оптимизация:Мы можем использовать готовый EqualityComparer для сравнения значений, а не делегировать его.
Это также сделает реализацию более чистой, поскольку фактическая логика сравнения теперь остается в GetHashCode() и Equals(), которые вы, возможно, уже перегрузили.
Вот код:
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();
}
}
Не забудьте перегрузить методы GetHashCode() и Equals() вашего объекта.
Мне помог этот пост: C# сравнить два общих значения
Сушил
ответ Орипа отлично.Расширение ответа Орипа:
я думаю, что ключом к решению является использование «метода расширения» для передачи «анонимного типа».
public static class Comparer
{
public static IEqualityComparer<T> CreateComparerForElements<T>(this IEnumerable<T> enumerable, Func<T, object> keyExtractor)
{
return new KeyEqualityComparer<T>(keyExtractor);
}
}
Использование:
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;
}
Это позволяет выбрать свойство с лямбда-выражением следующим образом: .Select(y => y.Article).Distinct(x => x.ArticleID);
Я не знаю существующего класса, но что-то вроде:
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();
}
}
Примечание:На самом деле я еще не скомпилировал и не запустил это, поэтому может быть опечатка или другая ошибка.