web-dev-qa-db-fra.com

Comment vérifier si une paire clé/valeur existe dans un dictionnaire

Comment vérifier si une paire clé/valeur existe dans un dictionnaire <>? Je peux vérifier si une clé ou une valeur existe en utilisant ContainsKey et ContainsValue, mais je ne sais pas comment vérifier si une paire clé/valeur existe.

Merci

c#.netdata-structuresdictionary
18
user1261466

Eh bien, la paire ne peut pas exister si la clé n'existe pas ... recherchez donc la valeur associée à la clé et vérifiez si c'est la valeur que vous recherchiez. Donc par exemple:

// Could be generic of course, but let's keep things simple...
public bool ContainsKeyValue(Dictionary<string, int> dictionary,
                             string expectedKey, int expectedValue)
{
    int actualValue;
    if (!dictionary.TryGetValue(expectedKey, out actualValue))
    {
        return false;
    }
    return actualValue == expectedValue;
}

Ou un peu plus "intelligemment" (généralement quelque chose à éviter ...):

public bool ContainsKeyValue(Dictionary<string, int> dictionary,
                             string expectedKey, int expectedValue)
{
    int actualValue;
    return dictionary.TryGetValue(expectedKey, out actualValue) &&
           actualValue == expectedValue;
}
38
Jon Skeet

Un dictionnaire ne supporte qu'une valeur par clé, donc:

// key = the key you are looking for
// value = the value you are looking for
YourValueType found;
if(dictionary.TryGetValue(key, out found) && found == value) {
    // key/value pair exists
}
24
Marc Gravell
if (myDic.ContainsKey(testKey) && myDic[testKey].Equals(testValue))
     return true;
5
Wesley Long

Vous pouvez le faire en utilisant dictionary.TryGetValue .

Dictionary<string, bool> clients = new Dictionary<string, bool>();
                    clients.Add("abc", true);
                    clients.Add("abc2", true);
                    clients.Add("abc3", false);
                    clients.Add("abc4", true);

                    bool isValid = false;

                    if (clients.TryGetValue("abc3", out isValid)==false||isValid == false)
                    {
                        Console.WriteLine(isValid);
                    }
                    else
                    {
                        Console.WriteLine(isValid);
                    }

Au niveau du code ci-dessus, si condition, il y a deux sections, la première pour vérifier si la clé a une valeur et la seconde pour comparer la valeur réelle à votre valeur attendue. 

First Section{clients.TryGetValue("abc3", out isValid)==false}||Second Section{isValid == false}
4
Md. Mufazzal Hussain

Version générique de la réponse de Jon Skeet

        public bool ContainsKeyValue<TKey, TVal>(Dictionary<TKey, TVal> dictionnaire,
                                             TKey expectedKey,
                                             TVal expectedValue) where TVal : IComparable
    {
        TVal actualValue;

        if (!dictionnaire.TryGetValue(expectedKey, out actualValue))
        {
            return false;
        }
        return actualValue.CompareTo(expectedValue) == 0;
    }
0
Philippe Veilleux-Girard

Comment quelque chose comme ça

bool exists = dict.ContainsKey("key") ? dict["key"] == "value" : false;
0
Ash Burlaczenko

Méthode d'extension simple et générique

Voici une méthode d'extension générique rapide qui ajoute une méthode ContainsPair() à toute IDictionary:

public static bool ContainsPair<TKey, TValue>(this IDictionary<TKey, TValue> dictionary,
                                                   TKey key,
                                                   TValue value)
{
    return dictionary.TryGetValue(key, out var found) && found.Equals(value);
}

Cela vous permet de vérifier les dictionnaires comme ceci:

if( myDict.ContainsPair("car", "mustang") ) { ... }     // NOTE: this is not case-insensitive

Contrôle insensible à la casse

Lorsque vous travaillez avec des clés basées sur des chaînes, vous pouvez rendre la Dictionary insensible à la casse par rapport à ses clés en la créant avec un comparateur tel que StringComparer.OrdinalIgnoreCase lors de la construction du dictionnaire.

Cependant, pour rendre la comparaison de valeurs insensible à la casse (en supposant que les valeurs sont également des chaînes), vous pouvez utiliser cette version qui ajoute un paramètre IComparer:

public static bool ContainsPair<TKey, TValue>(this IDictionary<TKey, TValue> dictionary,
                                                   TKey key,
                                                   TValue value,
                                                   IComparer<TValue> comparer)
{
    return dictionary.TryGetValue(key, out var found) && comparer.Compare(found, value) == 0;
}
0
Jonathan B.