2012-03-10 14 views

Respuesta

36

Bueno, la par no puede existir si el clave no existe ... así buscar el valor asociado a la clave, y comprobar si ese es el valor que estaba buscando. Así, por ejemplo:

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

o un poco más "inteligente" (por lo general algo para evitar ...):

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

Cómo algo como esto

bool exists = dict.ContainsKey("key") ? dict["key"] == "value" : false; 
+3

Uso TryGetValue lugar. – Marlon

+2

¿Por qué buscar dos veces? –

-1

Primero se comprueba si el la clave existe, de ser así, obtiene el valor de esta clave y la compara con el valor que está probando ... Si son iguales, su diccionario contiene el par

22

Un diccionario sólo es compatible con un valor por llave, así:

// 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 
} 
+0

Me disgusta un poco configurar y usar 'found' en una expresión. – CodesInChaos

+3

@CodeInChaos por qué? El comportamiento está muy claramente definido para ser siempre válido ... –

+0

Sé que está bien definido. Es solo una preferencia estilística. Al igual que trato de tener solo un único efecto secundario por afirmación, que también es lo último que sucede en esa declaración. – CodesInChaos

5
if (myDic.ContainsKey(testKey) && myDic[testKey].Equals(testValue)) 
    return true; 
+2

Use TryGetValue en su lugar. – Marlon

+0

Sí, funciona. No es tan ilustrativo. Elegí este para aclarar la lógica, no para optimizar el rendimiento. –

+0

Este escenario particular del que estamos hablando, no se trata de (micro) optimización. Se trata más bien de comprender cómo funcionan los diccionarios .NET, las complejidades O (k), etc. Es la práctica correcta utilizar el valor tryget aquí. – nawfal

3

Usted puede hacer esto mediante el uso de 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); 
        } 

En el código anterior si la condición no hay dos secciones primera para comprobar tecla tiene valor y la segunda para la comparación del valor real con su valor esperado.

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

favor, consulte con el código siguiente

var dColList = new Dictionary<string, int>(); 
if (!dColList.Contains(new KeyValuePair<string, int>(col.Id,col.RowId))) 
{} 

Gracias, Mahesh G

+1

Esto va a ser * mucho * más lento que las otras opciones, ya que no está aprovechando la capacidad de los diccionarios para realizar búsquedas rápidas en su clave. – Servy

0

versión genérica de la Jon Skeet 's respuesta

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