webentwicklung-frage-antwort-db.com.de

So prüfen Sie, ob in einem Wörterbuch ein Schlüssel/Wert-Paar vorhanden ist

Wie kann man überprüfen, ob ein Schlüssel/Wert-Paar in einem Wörterbuch <> vorhanden ist? Ich kann mit Hilfe von ContainsKey und ContainsValue prüfen, ob ein Schlüssel oder ein Wert vorhanden ist.

Vielen Dank

18
user1261466

Nun, das pair kann nicht existieren, wenn der key nicht existiert ... also holen Sie den mit dem Key verknüpften Wert ab und prüfen Sie, ob dies der gewünschte Wert ist. Also zum Beispiel:

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

Oder etwas "schlauer" (normalerweise etwas zu vermeiden ...):

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

Ein Wörterbuch unterstützt nur einen Wert pro Schlüssel.

// 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

Sie können dies tun, indem Sie dictionary.TryGetValue verwenden.

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

Im obigen Code, wenn Bedingung, gibt es zwei Abschnitte, in denen der Schlüssel zuerst überprüft wird und der zweite den tatsächlichen Wert mit dem erwarteten Wert vergleicht. 

First Section{clients.TryGetValue("abc3", out isValid)==false}||Second Section{isValid == false}
var result= YourDictionaryName.TryGetValue(key, out string value) ? YourDictionaryName[key] : "";

Wenn der Schlüssel im Wörterbuch vorhanden ist, wird der Wert des Schlüssels zurückgegeben, andernfalls wird ein leeres Objekt zurückgegeben.

Hoffe, dieser Code hilft dir.

0
Nitika Chopra

Generische Version von Jon Skeet s Antwort

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

Wie so etwas

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

Einfache, generische Erweiterungsmethode

Hier ist eine schnelle generische Erweiterungsmethode, die jeder IDictionary eine ContainsPair()-Methode hinzufügt:

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

So können Sie die Wörterbücher wie folgt prüfen:

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

Prüfung ohne Berücksichtigung der GroßKleinschreibung - /

Wenn Sie mit zeichenfolgenbasierten Schlüsseln arbeiten, können Sie die Dictionary-Groß-/Kleinschreibung bezüglich der Schlüssel unterscheiden, indem Sie sie mit einem Vergleicher wie StringComparer.OrdinalIgnoreCase erstellen, wenn das Wörterbuch erstellt wird.

Um den Wertvergleich jedoch unempfindlich zu machen (vorausgesetzt, die Werte sind auch Zeichenfolgen), können Sie diese Version verwenden, die den Parameter IComparer hinzufügt:

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.