Pourquoi je ne peux pas comparer un KeyValuePair<TKey, TValue> à défaut

Dans .Net de 2,5 je peux habituellement obtenir une comparaison d'égalité (==) entre une valeur et son type par défaut

if (myString == default(string))

Mais j'ai l'exception suivante lorsque j'essaie d'exécuter une comparaison d'égalité sur un défaut KeyValuePair et un KeyValuePair

Exemple de Code (à partir d'une pré-extension de la méthode, de la proto-lambda statique ListUtilities classe 🙂 )

public static TKey 
        FirstKeyOrDefault<TKey, TValue>(Dictionary<TKey, TValue> lookups, 
                   Predicate<KeyValuePair<TKey, TValue>> predicate)
{
    KeyValuePair<TKey, TValue> pair = FirstOrDefault(lookups, predicate);

    return pair == default(KeyValuePair<TKey, TValue>) ? 
                   default(TKey) : pair.Key;
}

Exception:

Opérateur '==' ne peut pas être appliquée à
des opérandes de type
'Système.Les Collections.Génériques.KeyValuePair<string,object>'
et
'Système.Les Collections.Génériques.KeyValuePair<string,object>'

Est-ce parce que, comme un struct, le KeyValuePair n'est pas nullable? Si c'est le cas, pourquoi, comme, sans doute, par défaut a été mis en œuvre pour gérer pas les types nullables?

MODIFIER

Pour l'enregistrement, j'ai choisi @Chris Hannon comme réponse sélectionnée, car il m'a donné ce que je cherchais, le plus élégant de l'option, et une brève explication, cependant, je fais de la promotion de la lecture @Dasuraga pour un ensemble très complet qui explique pourquoi c'est le cas

  • FirstOrDefault<KeyValuePair<TKey,TValue>>(recherches, prédicat) ?
  • Pellerin, qui doit être déduit du type transmis, ou le compilateur qui se serait plaint. L'exception se produit également lorsque vous simplifier à myKvp == défaut(KeyValuePair<...>)
  • Sûrement les valeurs par défaut sont dressées à des types scalaires? Que signifie, pour un KVP, pour avoir une valeur par défaut? J'imagine que vous avez une réponse à cette question dans le contexte de ce que vous essayez de construire. Je suppose que pour les non-scalaires la valeur par défaut est ce que vous obtenez à partir de l'appel du néant constructeur. Dans ce cas, je m'attends à l'identité de l'objet de la comparaison de fausse déclaration puisque vous obtenez un nouvel objet à chaque fois que le constructeur est appelé.
InformationsquelleAutor johnc | 2011-06-16
  1. 57

    Cela se produit parce que KeyValuePair<TKey, TValue> ne définit pas une coutume opérateur == et n'est pas inclus dans la liste prédéfinie des types de valeur qui peut l'utiliser.

    Voici un lien vers le La documentation MSDN pour l'opérateur.

    Prédéfinis pour différents types de valeurs, l'opérateur d'égalité (==) retourne true si les valeurs de ses opérandes sont égaux, sinon false.

    Votre meilleur pari pour un contrôle d'égalité dans ce cas, parce que ce n'est pas une struct vous avez plus de contrôle, c'est d'appeler default(KeyValuePair<TKey,TValue>).Equals(pair) à la place.

    • Ah, qui ne font sens. Merci pour cette!
    • Mais n'est pas égal à vérifier si les Objets sont égaux, c'est à dire si les références se rapportent au même objet? Je ne sais pas si par défaut(int).Est égal à(0)...
    • Console.WriteLine(valeur par défaut(int).Est égal à(0)); sorties "vrai". Je suis à la réflexion sur les types de valeur, cette valeur est comparée à d'égal à Égal, sinon, il semble inutile d'avoir une méthode Equals sur eux
    • tous les autres opérateur) est non virtuelle. (object)kvp1 == (object)kvp2 effectuer une référence à l'égalité. Le casting est important de modifier le type de compilation pour vous assurer que object.==(object) est appelée est un opérateur défini.
    • quand est égal à est appelé sur une struct c'est en fait la méthode d'instance de ValueType qui est appelé, non pas la méthode d'instance de l'Objet. ValueType de la méthode d'instance est Égal utilise la réflexion pour vérifier si tous les champs sont égaux. ref: msdn.microsoft.com/en-us/library/ms173110.aspx
    InformationsquelleAutor Chris Hannon
  2. 5

    (Si vous n'avez pas de soins sur les génériques de discussion lié à cette erreur, vous pouvez simplement sauter à la fin de votre "vraie" réponse)

    Que l'erreur dit, il n'y a pas d'égalité des tests pour KeyValuePairs (à savoir qu'il n'est pas intégré dans la méthode de comparaison). La raison pour cela est pour éviter d'avoir à placer des contraintes sur les types de KeyValuePairs (il existe de nombreux cas où les clés,les comparaisons de la valeur ne sera jamais rendu).

    Évidemment, si vous voulez comparer th KeyValuePairs, j'imagine ce que vous voulez est de vérifier si les clés et les valeurs sont égales. Mais cela implique un gâchis de choses , notamment que TKey et TValue sont les deux types comparables (c'est à dire qu'ils implémentent l'interface IComparable)

    Vous pouvez écrire votre propre fonction de comparaison entre keyvaluepairs, par exemple:

    static bool KeyValueEqual<TKey , TValue>(KeyValuePair<TKey, TValue> fst, 
                                          KeyValuePair<TKey, TValue> snd) 
                                         where  TValue:IComparable
                                         where  TKey:IComparable
        {
            return (fst.Value.CompareTo(snd.Value)==0)
                     && (snd.Key.CompareTo(fst.Key)==0);
        }

    (Excusez le terrible indentation)

    Ici, nous l'imposer TKey et TValue sont à la fois comparables (via le CompareTo fonction de membre).

    La CompareTo fonction (telle que définie pour le pré-types définis par l') renvoie 0 lorsque deux objets sont égaux , à la strcmp . un.ComparesTo(b)==0 signifie que a et b sont de la "même"(en valeur, pas le même objet).

    de sorte que cette fonction devrait prendre deux KVPs (k,v) et (k',v') et qui renvoie true si et seulement si k==k' et v==v' (au sens intuitif).

    Mais est-ce nécessaire? Il semble que votre test où vous rencontrez des problèmes est basée sur une sorte de vérification sur le retour de FirstOrDefault.

    Mais il y a une raison pour laquelle votre fonction est appelée FirstOrDefault:

    Renvoie le premier élément de la
    la séquence qui satisfait à une condition ou à une
    un par défaut valeur si aucun élément est
    trouvé.

    (l'emphase est mienne)

    Cette fonction retourne les valeurs par défaut si quelque chose n'est pas trouvé, de sens que si votre prédicat n'est pas vérifié, vous aurez un KeyValuePair égal à (la valeur par défaut(TKey),par défaut(TValue).

    Votre code donc (entend) vérifier si la paire.Key==défaut(TKey), seulement pour de retour par défaut(TKey) de toute façon. Ne serait-il pas juste faire plus de sens de retour de la paire.Clé dès le début?

    • Très belle réponse, et votre solution est exactement le chemin que j'allais vers le bas jusqu'à ce que @Chris Hannon, a souligné à l'aide de Equals(). Reportez-vous à mon commentaire à votre commentaire sur cette réponse est la réponse à votre préoccupation, qui est Égal à ne fonctionnerait pas sur un type de valeur. Je suppose, cependant, devrait être sur la défensive et à supposer qu'il existe quelque bout que je ne suis pas en considérant ...
    InformationsquelleAutor rtpg
  3. 4

    Pour vous d'utiliser le "==" opérateur d'égalité sur une catégorie ou d'une structure, il doit remplacer l'opérateur: http://msdn.microsoft.com/en-us/library/ms173147(v=vs. 80).aspx

    KeyValuePair ne l'est pas, et, par conséquent, vous obtenez l'erreur de compilation. Remarque, vous obtiendrez le même message d'erreur si vous essayez ceci:

    var k1 = new KeyValuePair<int,string>();
var k2 = new KeyValuePair<int,string>();

bool b = k1 == k2; //compile error

    EDIT: Comme Eric Lippert corrigé moi dans les commentaires, les classes de toute évidence n'a pas besoin de surcharger l'opérateur d'égalité pour "==" pour être valide. Il va compiler amende et de faire une référence à l'égalité de vérifier. Mon erreur.

    • Tous classe ou structure -- vraiment? Que faire si vous faites votre propre classe C; - il possible de comparer deux instances de C pour l'égalité sans la définition d'un custom == opérateur?
    • Vous sir sont corrects. Édité ma réponse.
    InformationsquelleAutor BFree
  4. 3

    Il échoue pour la même raison que les suivantes:

    var kvp = new KeyValuePair<string,string>("a","b");
var res = kvp == kvp;

    L'indice est dans le message d'erreur, naturellement. (Il n'a rien à voir avec default).

    Operator '==' cannot be applied to operands of type 'System.Collections.Generic.KeyValuePair<string,string>' and 'System.Collections.Generic.KeyValuePair<string,string>'

    L'opérateur == n'est pas définie pour KeyValuePair<T,U>.

    Messages d'erreur FTW.

    Heureux de codage.

    InformationsquelleAutor
  5. 1

    Les valeurs par défaut sont dressées à des types scalaires.

    Posez-vous cette question: est-Ce dire pour KVP, pour avoir une valeur par défaut?

    Pour les non-scalaires la valeur par défaut est ce que vous obtenez à partir de l'appel du néant constructeur. En supposant que KVP est Égal effectue exemple l'identité de comparaison, je m'attends à ce qu'il renvoie faux, puisque vous obtenez un nouvel objet à chaque fois que le constructeur est appelé.

    • Dans un monde idéal, j'aurais attendu new KVP("Hello", "World") == new KVP("Hello", "World") à compiler. Cependant, pour assurer la == contrat (a.Key == b.Key && a.Value == b.Value) il faudrait donc que les arguments génériques a également répondu à ==, qui ne peut pas être appliquée au moment de la compilation. Rappelez-vous, chaque type, des structures personnalisées comprennent, ont une valeur par défaut.
    InformationsquelleAutor Peter Wone
  6. 1

    Ceci va dans une direction légèrement différente, mais je suis en supposant que vous avez interrogé un Dictionnaire pour obtenir ce résultat, et que vous voulez vérifier si elle a retourné un résultat valide ou pas.

    J'ai trouvé la meilleure façon de le faire était d'interroger la valeur réelle au lieu de l'ensemble de la KeyValuePair, comme ceci:

    var valitem = MyDict.Des valeurs.FirstOrDefault(x=> x.Quelque chose == aVar);

    Vous pouvez maintenant vérifier si valitem est null ou pas. Encore une fois, il ne veut pas répondre directement à votre question, mais il offre ce qui pourrait être une approche alternative à votre objectif.

    InformationsquelleAutor Brady Moritz