Dictionary TryGetValue ou !Contains

Bonjour

Une petite question academique pour ceux qui ont déja été reniflé le code

Pour acceder a une valeur d'un dictionnaire, je me demande s'il est plus performant de faire un TryGetValue ou bien une Sequence de ContainsKey et d'assignation le cas échéant ?

Si c'est pour accéder à la valeur, TryGetValue me semble plus adapté, vu qu'il effectue la recherche et la récupération en 1 passe. Si tu fais via un Contains suivi de la récupération via index, tu feras 2 passes, ce qui est moins intéressant. A benchmarker pour valider !

Declaration

Code:

---

1 2 3 4 5

System.Collections.Generic.Dictionary<int, String> monDictionnaire = new Dictionary<int, string>(); monDictionnaire.Add(0, "zero"); monDictionnaire.Add(1, "un"); monDictionnaire.Add(2, "deux");

---

Methode 1

Code:

---

1 2 3 4 5 6 7

string valeurRecherchee1String; if (monDictionnaire.ContainsKey(1)) { valeurRecherchee1String = monDictionnaire[1]; // Code ici... }

---

Methode 2

Code:

---

1 2 3 4 5 6

string valeurRecherchee2String; if (monDictionnaire.TryGetValue(1, out valeurRecherchee2String)) { // Code ici... }

---

Je pense comme "Arnard" mais j'utilise toujours l'autre methode (la premiere ici)

Tout dépend le type de la clé et le volume également... mais la logique commande le trygetvalue (moche avec le out mais bon on se refait pas :aie:)

Bonjour Le Cygne

Merci pour cette illustration mais ca ne réponds pas a la question !
Le probleme n'est pas de savoir comment coder l'une ou l'autre des methode mais bien de savoir si TryGetValue fait beaucoup gagner en performance

Pour etre honnete, moi aussi j'avais l'habitude d'utiliser un test sur Contains et c'est par hazard que je suis tombé sur ce TryGetValue

Citation:

---

Envoyé par Arnard

(moche avec le out mais bon on se refait pas )

---

De fait !
Mais quand je suis passé du C au C# mon habitude des pointeurs me faisaient un peu abuser des ref et des out ;)
Je suis guéri mais ca ne me fait pas peur :roll:

Logiquement tryGetValue te fait gagner du temps.

Si on expose en code :

TryGetValue

Code:

---

1 2 3 4 5 6 7 8 9 10 11

//A key = keyToSearch; B value = null; foreach(KeyValuePair<A,B> paire in monDico) { if(paire.key == keyToSearch) { value = paire.Value; break; } }

---

Contains

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

//A key = keyToSearch; B value = null; bool found = false;   foreach(KeyValuePair<A,B> paire in monDico) { if(paire.key == keyToSearch) { found = true; break; } } //Plus loin if(found) value = monDico[keyToSearch];//Qui introduit un nouveau parcours du graphe de données

---

J'ai fait le choix du foreach pour que ça reste clair, mais Dictionnary est une classe plus complexe qui gère les clés à sa manière. cela montre que le premier parcours ne traite qu'une fois la collection, et la 2e méthode introduit 2 parcours

Citation:

---

Envoyé par olibara

Bonjour Le Cygne

Merci pour cette illustration mais ca ne réponds pas a la question !
Le probleme n'est pas de savoir comment coder l'une ou l'autre des methode mais bien de savoir si TryGetValue fait beaucoup gagner en performance

Pour etre honnete, moi aussi j'avais l'habitude d'utiliser un test sur Contains et c'est par hazard que je suis tombé sur ce TryGetValue

---

Je suis d'accord avec toi, et je ne connais pas la réponse, Désolé de t'avoir décu. Mais au cas ou quelqu'un qui ne connais pas les dictionnaires passerait par là, il pourra suivre le fil de la discussion et si elle est apportée, comprendre la réponse.

Le plus simple est encore d'aller voir le code de Dictionnary<,> !

ContainsKey fait:

Code:

---

1 2 3 4

public bool ContainsKey(TKey key) { return (this.FindEntry(key) >= 0); }

---

TryGetValue fait:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

public bool TryGetValue(TKey key, out TValue value) { int index = this.FindEntry(key); if (index >= 0) { value = this.entries[index].value; return true; } value = default(TValue); return false; }

---

A partir de là, on en déduis simplement que les deux méthodes reviennent très exactement au même :)

Ps: pour ceux qui ne connaissent pas, j'ai tout simplement utiliser Reflector (qui est maintenant devenu payant dans la version 7), dès que j'ai un doute sur ce que fait .NET, je vais voir par moi même. On apprend parfois beaucoup de chose avec ça !

Merci Darkherumor

Citation:

---

Envoyé par Darkherumor

A partir de là, on en déduis simplement que les deux méthodes reviennent très exactement au même

---

Ah non justement mais tu as quand meme répondu a la question
Car si le ContainsKey donne true if faudra reacceder la valeur et il est vraissemblable que FindEntry soit relancé

Donc ContainsKey n'est intéressant que pour un test d'existence mais sinon c'est TryGetValue qu'il faut utiliser !

Pas d'accord, dans les 2 cas:

Code:

---

1 2 3 4

i = FindEntry i >= 0 ? oui : lecture non : return

---

Le TryGetValue, commence par le même code que le Contains, puis faire une simple lecture.

Si tu fais un Contains, puis une lecture, c'est identique !

Ce serai de faire un ContainsKey, puis un TryGetValue qui serai redondant. Mais là ce serai tordu :)

EDIT : En fait si, tu as raison ^^

J'ai était voir le code de la lecture direct, et il repasse par un FindEntry en toute logique. Donc, un ContainsKey, puis une lecture appel deux fois cette méthode... Après de là à juger les perfs, j'ai un doute... mais je me coucherai moins bête!