Plusieurs fonctions Linq.Enumerable prennent un IEqualityComparer<T>. Existe-t-il une classe wrapper pratique qui adapte un delegate(T,T)=>boolà implémenter IEqualityComparer<T>? Il est assez facile d'en écrire un (si vous ignorez les problèmes de définition d'un hashcode correct), mais j'aimerais savoir s'il existe une solution prête à l'emploi.

Plus précisément, je souhaite effectuer des opérations de définition sur Dictionarys, en utilisant uniquement les clés pour définir l'appartenance (tout en conservant les valeurs selon différentes règles).

Habituellement, je résoudre ce problème en commentant @Sam sur la réponse (j'ai fait quelques modifications sur le message d'origine pour le nettoyer un peu sans modifier le comportement.)

Ce qui suit est mon riff de la réponse de @ Sam , avec un correctif critique [IMNSHO] à la politique de hachage par défaut: -

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 );
    }
}

Sur l'importance de GetHashCode

D'autres ont déjà commenté le fait que toute IEqualityComparer<T>implémentation personnalisée devrait vraiment inclure une GetHashCodeméthode ; mais personne n'a pris la peine d'expliquer pourquoi en détail.

Voici pourquoi. Votre question mentionne spécifiquement les méthodes d'extension LINQ; presque tous reposent sur des codes de hachage pour fonctionner correctement, car ils utilisent des tables de hachage en interne pour plus d'efficacité.

Prenez Distinct, par exemple. Considérez les implications de cette méthode d'extension si tout ce qu'elle utilisait était une Equalsméthode. Comment déterminer si un élément a déjà été numérisé dans une séquence si vous ne l'avez déjà fait Equals? Vous énumérez l'ensemble de la collection de valeurs que vous avez déjà consultées et recherchez une correspondance. Cela entraînerait l' Distinctutilisation d'un algorithme O (N ² ) du pire des cas au lieu d'un algorithme O (N)!

Heureusement, ce n'est pas le cas. Distinctne pas simplement utiliser Equals; il utilise GetHashCodeaussi. En fait, il ne fonctionne absolument pas correctement sans un IEqualityComparer<T>qui fournit un bonGetHashCode . Voici un exemple artificiel illustrant cela.

Disons que j'ai le type suivant:

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);
    }
}

Maintenant, disons que j'ai un List<Value>et je veux trouver tous les éléments avec un nom distinct. C'est un cas d'utilisation parfait pour Distinctutiliser un comparateur d'égalité personnalisé. Alors utilisons la Comparer<T>classe de la réponse d' Aku :

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

Maintenant, si nous avons un tas d' Valueéléments avec la même Namepropriété, ils devraient tous se réduire en une seule valeur renvoyée par Distinct, non? Voyons voir...

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);
}

Production:

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

Hmm, ça n'a pas marché, n'est-ce pas?

Et quoi GroupBy? Essayons ça:

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);
    }
}

Production:

[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

Encore une fois: n'a pas fonctionné.

Si vous y réfléchissez, il serait logique Distinctd'utiliser a HashSet<T>(ou équivalent) en interne, et GroupByd'utiliser quelque chose comme un en Dictionary<TKey, List<T>>interne. Cela pourrait-il expliquer pourquoi ces méthodes ne fonctionnent pas? Essayons ça:

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

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

Production:

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

Ouais ... commence à avoir un sens?

Espérons qu'à partir de ces exemples, il est clair pourquoi l'inclusion d'un approprié GetHashCodedans toute IEqualityComparer<T>implémentation est si importante.

Réponse originale

Élargissement de la réponse d'orip :

Il y a quelques améliorations qui peuvent être apportées ici.

1. Tout d'abord, je prendrais un Func<T, TKey>au lieu de Func<T, object>; cela empêchera l'encadrement des clés de type valeur dans le réel keyExtractorlui-même.
2. Deuxièmement, j'ajouterais en fait une where TKey : IEquatable<TKey>contrainte; cela évitera le boxing dans l' Equalsappel ( object.Equalsprend un objectparamètre; vous avez besoin d'une IEquatable<TKey>implémentation pour prendre un TKeyparamètre sans le boxing). Clairement, cela peut poser une restriction trop sévère, vous pouvez donc créer une classe de base sans la contrainte et une classe dérivée avec elle.

Voici à quoi pourrait ressembler le code résultant:

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));
    }
}

Lorsque vous souhaitez personnaliser la vérification d'égalité, 99% du temps, vous êtes intéressé par la définition des clés à comparer, pas par la comparaison elle-même.

Cela pourrait être une solution élégante (concept de la méthode de tri de liste de Python ).

Usage:

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

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

La KeyEqualityComparerclasse:

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();
    }
}

J'ai bien peur qu'il n'y ait pas de telle enveloppe prête à l'emploi. Cependant, il n'est pas difficile d'en créer un:

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));

Identique à la réponse de Dan Tao, mais avec quelques améliorations:

1. S'appuie sur EqualityComparer<>.Defaultpour faire la comparaison réelle afin d'éviter la boxe pour les types de valeur structqui ont été implémentés IEquatable<>.

2. Depuis EqualityComparer<>.Defaultutilisé, il n'explose pas null.Equals(something).

3. Fournit un wrapper statique autour IEqualityComparer<>duquel aura une méthode statique pour créer l'instance de comparateur - facilite l'appel. Comparer

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

   avec

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

4. Ajout d'une surcharge à spécifier IEqualityComparer<>pour la clé.

La classe:

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));
        }
    }
}

vous pouvez l'utiliser comme ceci:

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);

La personne est une classe simple:

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 );
    }
}

Avec extensions: -

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 ) );
    }
}

La réponse d'orip est excellente.

Voici une petite méthode d'extension pour le rendre encore plus facile:

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())

Je vais répondre à ma propre question. Pour traiter les dictionnaires comme des ensembles, la méthode la plus simple semble être d'appliquer des opérations d'ensembles à dict.Keys, puis de les reconvertir en dictionnaires avec Enumerable.ToDictionary (...).

L'implémentation à (texte allemand) Implémentation de IEqualityCompare avec l'expression lambda se soucie des valeurs nulles et utilise des méthodes d'extension pour générer IEqualityComparer.

Pour créer un IEqualityComparer dans une union Linq, il vous suffit d'écrire

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

Le comparateur:

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();
  }
}

Vous devez également ajouter une méthode d'extension pour prendre en charge l'inférence de type

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));
       }
   }

Juste une optimisation: nous pouvons utiliser EqualityComparer prêt à l'emploi pour les comparaisons de valeurs, plutôt que de les déléguer.

Cela rendrait également l'implémentation plus propre car la logique de comparaison réelle reste maintenant dans GetHashCode () et Equals () que vous avez peut-être déjà surchargés.

Voici le code:

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(); 
  } 
} 

N'oubliez pas de surcharger les méthodes GetHashCode () et Equals () sur votre objet.

Cet article m'a aidé: c # comparer deux valeurs génériques

Sushil

La réponse d'orip est excellente. Élargissement de la réponse d'orip:

Je pense que la clé de la solution est d'utiliser la "méthode d'extension" pour transférer le "type anonyme".

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

Usage:

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;
  }

Cela permet de sélectionner une propriété avec lambda comme ceci: .Select(y => y.Article).Distinct(x => x.ArticleID);

Je ne connais pas de classe existante mais quelque chose comme:

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();
  }
}

Remarque: je n'ai pas encore compilé et exécuté ceci, il peut donc y avoir une faute de frappe ou un autre bogue.