Test d'égalité entre les dictionnaires en c #

Question

En supposant que les clés et les valeurs de dictionnaire ont leurs égales et leurs méthodes de hachage implémentées correctement, quelle est la manière la plus succincte et la plus efficace de tester l'égalité de deux dictionnaires?

Dans ce contexte, deux dictionnaires sont dits égaux s'ils contiennent le même ensemble de clés (ordre non important), et pour chaque clé, ils s'accordent sur la valeur.

voici quelques façons dont j'ai trouvé (il y en a probablement beaucoup plus):

 public bool Compare1<TKey, TValue>(
    Dictionary<TKey, TValue> dic1, 
    Dictionary<TKey,TValue> dic2)
{
    return dic1.OrderBy(x => x.Key).
        SequenceEqual(dic2.OrderBy(x => x.Key));
}

public bool Compare2<TKey, TValue>(
    Dictionary<TKey, TValue> dic1, 
    Dictionary<TKey, TValue> dic2)
{
    return (dic1.Count == dic2.Count && 
        dic1.Intersect(dic2).Count().
        Equals(dic1.Count));
}

public bool Compare3<TKey, TValue>(
    Dictionary<TKey, TValue> dic1, 
    Dictionary<TKey, TValue> dic2)
{
    return (dic1.Intersect(dic2).Count().
        Equals(dic1.Union(dic2).Count()));
}
 

Answer 1

dic1.Count == dic2.Count && !dic1.Except(dic2).Any();

Answer 2

Cela dépend vraiment de ce que vous entendez par égalité.

Cette méthode testera que deux dictionnaires contiennent les mêmes clés avec les mêmes valeurs (en supposant que les deux dictionnaires utilisent la même implémentation IEqualityComparer<TKey> ).

 public bool CompareX<TKey, TValue>(
    Dictionary<TKey, TValue> dict1, Dictionary<TKey, TValue> dict2)
{
    if (dict1 == dict2) return true;
    if ((dict1 == null) || (dict2 == null)) return false;
    if (dict1.Count != dict2.Count) return false;

    var comparer = EqualityComparer<TValue>.Default;

    foreach (KeyValuePair<TKey, TValue> kvp in dict1)
    {
        TValue value2;
        if (!dict2.TryGetValue(kvp.Key, out value2)) return false;
        if (!comparer.Equals(kvp.Value, value2)) return false;
    }
    return true;
}
 

Answer 3

Vous pouvez utiliser linq pour les comparaisons clé / valeur:

 public bool Compare<TKey, TValue>(Dictionary<TKey, TValue> dict1, Dictionary<TKey, TValue dict2)
{
    IEqualityComparer<TValue> valueComparer = EqualityComparer<TValue>.Default;

    return  dict1.Count == dict2.Count &&
            dict1.Keys.All(key => dict2.ContainsKey(key) && valueComparer.Equals(dict1[key], dict2[key]));
}
 

Answer 4

@ Réponse d'Allen :

 bool equals = a.Intersect(b).Count() == a.Union(b).Count()
 

concerne les tableaux, mais en ce qui concerne les méthodes IEnumerable<T> , elles peuvent également être utilisées pour Dictionary<K,V> .

Answer 5

Dans l'OP questions, il a dit que le test d'égalité doit couvrir non seulement la mise en correspondance des touches, mais aussi de leur valeur "Dans ce contexte, deux dictionnaires sont dit être égales si elles contiennent le même jeu de clés (l'ordre n'est pas important), et pour chacune de ces clés, ils sont d'accord sur la valeur."

Ai-je raté quelque chose ou ne l'marqué répondre http://stackoverflow.com/a/3804852/916121 seulement pour vérifier l'égalité de taille et les touches, mais pas leur valeur?

Je l'aurais posté à côté de la réponse, mais ne pourrais pas travailler sur la façon d'ajouter un commentaire, désolé.