Vérifier si mon dictionnaire <int, liste <int>> a un élément dans la liste

Question

que je fais ce moment:

foreach(..) 
{ 
if(myDic.ContainsKey(car.ID) && myDic[car.ID].Contains(car.MfgID)) 
{ 

    // do something 
} 
} 

Je me demandais si je peux effectuer la vérification, mais il faut vérifier si elle n'a pas existe, et ensuite continuez.

Comment est-ce que je ferais cela? en utilisant un || ou & &?

Je ne peux pas supposer que la clé/valeur est là donc je ne veux pas qu'il plante.

Answer 1

foreach(..) 
{ 
    if(!myDic.ContainsKey(car.ID) || !myDic[car.ID].Contains(car.MfgID)) 
    { 
     continue; 
    } 

    // do something 
} 

• Si car.ID est pas une clé de myDic alors la première condition est vraie et il n'y a pas d'évaluation de la condition 2 .
• Si car.ID est une clé de myDic puis la 2ème condition sera évaluée et il ne plantera pas depuis le myDic [car.ID] a une valeur valide.

Si vous avez une certaine logique dans « faire quelque chose » cette façon est utile, car il utilise la complexité un bon accès du dictionnaire. Si "faire quelque chose" ne fait que sélectionner des valeurs pour que toute la boucle soit juste un filtre, il est plus élégant d'utiliser une requête LINQ.

Answer 2

Si vous avez LINQ vous pourriez faire quelque chose comme disponible ceci:

myDic.Any(kvp => kvp.Key == car.ID && kvp.Value.Contains(car.MfgID)); 

Figured Je voudrais ajouter un peu d'expansion, si vous souhaitez filtrer la liste que vous pouvez effectuer les opérations suivantes:

var filteredDictionary = myDic.Where(kvp => kvp.Key == car.ID 
             && kvp.Value.Contains(car.MfgID)); 

foreach(...) 
{ 
    ... //Only enumerating over items that match both conditions. 
} 

Answer 3

Une autre manière courante de le faire est d'utiliser plusieurs simples guard clauses:

foreach (...) 
{ 
    if (!myDic.ContainsKey(car.ID)) 
     continue; 

    if (!myDic[car.ID].Contains(car.MfgID)) 
     continue; 

    // do something actually 
} 

(ce qui peut améliorer la lisibilité parfois)

Answer 4

Ce que vous avez est bien, le côté droit d'un & & n'est pas évalué si le côté gauche évalue à faux.