In my last post, I introduced the PredicateEqualityComparer
and a Distinct extension method that receives a predicate to internally create a PredicateEqualityComparer
to filter elements.
Using the predicate greatly improves readability, conciseness and expressiveness of the queries, but it can be even better. Most of the times, we don't want to provide a comparison method but just extract the comparison key for the elements.
So, I developed a SelectorEqualityComparer
that takes a method that extracts the key value for each element. Something like this:
public class SelectorEqualityComparer<TSource, Tkey> : EqualityComparer<TSource>
where Tkey : IEquatable<Tkey>
{
private Func<TSource, Tkey> selector;
public SelectorEqualityComparer(Func<TSource, Tkey> selector)
: base()
{
this.selector = selector;
}
public override bool Equals(TSource x, TSource y)
{
Tkey xKey = this.GetKey(x);
Tkey yKey = this.GetKey(y);
if (xKey != null)
{
return ((yKey != null) && xKey.Equals(yKey));
}
return (yKey == null);
}
public override int GetHashCode(TSource obj)
{
Tkey key = this.GetKey(obj);
return (key == null) ? 0 : key.GetHashCode();
}
public override bool Equals(object obj)
{
SelectorEqualityComparer<TSource, Tkey> comparer =
obj as SelectorEqualityComparer<TSource, Tkey>;
return (comparer != null);
}
public override int GetHashCode()
{
return base.GetType().Name.GetHashCode();
}
private Tkey GetKey(TSource obj)
{
return (obj == null) ? (Tkey)(object)null : this.selector(obj);
}
}
Now I can write code like this:
.Distinct(new SelectorEqualityComparer<Source, Key>(x => x.Field))
And, for improved readability, conciseness and expressiveness and support for anonymous types, the corresponding Distinct
extension method:
public static IEnumerable<TSource> Distinct<TSource, TKey>
(this IEnumerable<TSource> source, Func<TSource, TKey> selector)
where TKey : IEquatable<TKey>
{
return source.Distinct(new SelectorEqualityComparer<TSource, TKey>(selector));
}
And the query is now written like this:
.Distinct(x => x.Field)
For most usages, it’s simpler than using a predicate.