Différentes façons d'ajouter au Dictionnaire

Quelle est la différence dans Dictionary.add(key, value) et Dictionary[key] = value?

J'ai remarqué que la dernière version n'a pas de jeter un ArgumentException lors de l'insertion d'un double de la clé, mais il n'existe aucune raison de préférer la première version?

Modifier: quelqu'un aurait-il une source d'informations fiables à ce sujet? J'ai essayé de MSDN, mais c'est comme toujours un wild goose chase 🙁

InformationsquelleAutor Sune Rievers | 2009-12-03

c#dictionary optimization

97

Les performances sont presque identiques à 100%. Vous pouvez le vérifier en ouvrant la classe dans Reflector.net

C'est le Présent de l'indexeur:
```
public TValue this[TKey key]
{
    get
    {
        int index = this.FindEntry(key);
        if (index >= 0)
        {
            return this.entries[index].value;
        }
        ThrowHelper.ThrowKeyNotFoundException();
        return default(TValue);
    }
    set
    {
        this.Insert(key, value, false);
    }
}
```
Et c'est la méthode Add:
```
public void Add(TKey key, TValue value)
{
    this.Insert(key, value, true);
}
```
Je ne vais pas poster l'ensemble de la méthode d'Insertion que c'est un peu long, cependant, la méthode de déclaration est: est-ce
```
private void Insert(TKey key, TValue value, bool add)
```
Et plus bas dans la fonction, ce qui se passe:
```
if ((this.entries[i].hashCode == num) && this.comparer.Equals(this.entries[i].key, key))
{
    if (add)
    {
        ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AddingDuplicate);
    }
```
Qui vérifie si la clé existe déjà, et si il le fait et le paramètre ajouter, c'est vrai, il lève l'exception.

Donc, à toutes fins et intentions de la performance est la même.

Comme quelques autres mentions, il est tout au sujet de savoir si vous avez besoin de la vérifier, pour les tentatives d'ajout de la touche même deux fois.

Désolé pour le long post, j'espère que c'est ok.
- +1 Très intéressant, merci pour ton post! Il semblerait que la performance est presque identique ici, comme les autres affiches ont fait allusion sur, de toute façon belle trouvaille 🙂
InformationsquelleAutor Steffen
66

La première version ajoute une nouvelle KeyValuePair au dictionnaire, à lancer si la clé est déjà dans le dictionnaire. La seconde, à l'aide de l'indexeur, va ajouter une nouvelle paire si la clé n'existe pas, mais remplacer la valeur de la clé si elle existe déjà dans le dictionnaire.
```
IDictionary<string, string> strings = new Dictionary<string, string>();

strings["foo"] = "bar";          //strings["foo"] == "bar"
strings["foo"] = string.Empty;   //strings["foo"] == string.empty
strings.Add("foo", "bar");       //throws     
```
- +1 Avez-vous une source pour les informations ci-dessus? Je suis intéressé à apprendre si il y a des effets secondaires ou des mises en garde à l'aide de la première ou de la dernière forme.
- N'ont pas vraiment de source en tant que tel, juste à côté de ma tête, mais je ne pense pas qu'il ya beaucoup plus à lui, que mentionné dans les autres commentaires. Si je me souviens bien, Ajoutez utilise simplement l'indexeur, mais vérifie d'abord si la Clé est déjà en cours d'utilisation.
- Changé accepté de répondre à Steffen, parce que sa documentation est top notch. C'est encore une réponse très bien.
- Mauvais coup... personnellement je pense que cette réponse est rues avant de Steffen du... droit au but et un bon exemple.
- il semblerait que la communauté est d'accord avec vous. Cependant, je pense personnellement que Steffen réponse était plus complète et instructive. C'est une question de goût je pense, hhravn la réponse est bonne, court et doux, mais je préfère encore Steffen réponse 🙂
- Je pense que, il sera plus helphul pour les gens, si accepté de répondre pour cela, au lieu de l'actuel accepté de répondre. Parce que ce exactement répond à la question ("quelle est la différence"), plutôt que de les a accepté un (qui parle de performance, et près de 99% des utilisateurs de la recherche à ce sujet (comme moi), nécessaire à la "différence" (ce pourquoi je l'ai rencontré à ce sujet), et a accepté de répondre était inutile pour moi et les déchets de notre deuxième. au lieu de cela, cette réponse est exacte.
- La documentation indique que cette différence entre les deux types ici lien, Vous pouvez également utiliser la propriété d'Élément à ajouter de nouveaux éléments par la mise en valeur d'une clé qui n'existe pas dans le Dictionnaire<TKey, TValue>; par exemple, myCollection[maclé] = mavaleur (en Visual Basic, myCollection(myKey) = mavaleur). Toutefois, si la clé existe déjà dans le Dictionnaire<TKey, TValue>, le réglage de l'Élément de propriété écrase l'ancienne valeur. En revanche, la Addmethod lève une exception si une valeur de la clé spécifiée existe déjà"
InformationsquelleAutor hhravn
28

Dictionary.Add(key, value) et Dictionary[key] = value ont différents objectifs:
- Utiliser le Add méthode pour ajouter nouvelle paire clé/valeur, les clés ne seront pas remplacés (un ArgumentException est jeté).
- Utiliser l'indexeur si vous ne vous souciez pas de savoir si la clé existe déjà dans le dictionnaire, en d'autres termes: ajouter la paire clé/valeur, si la clé n'est pas dans le dictionnaire ou de remplacer la valeur de la clé spécifiée si la clé est déjà dans le dictionnaire.
- Le Code que l'auto-décrit intention est important et précieux (et nécessite peu ou pas de commentaires). Cette réponse montre la différence dans l'intention avec les deux méthodes, et devrait être suivie lors du choix d'un. En d'autres termes, n'utilisez pas le "indexeur ajouter" lorsque vous savoir à l'avance, que vous aurez toujours ajouter, ou même doit toujours ajouter. Avoir un IndexOutOfBounds exception obtenir jeté est mieux qu'un comportement inattendu.
InformationsquelleAutor Michael Damatov
22

Pour répondre à la question, nous avons d'abord besoin de prendre un coup d'oeil à l'usage d'un dictionnaire et de la technologie sous-jacente.

Dictionary est la liste de KeyValuePair<Tkey, Tvalue> où chaque valeur est représentée par sa clé unique. Disons que nous avons une liste de vos aliments préférés. Chaque valeur de (nom de l'aliment) est représenté par son unique clé (position = combien vous aimez cette nourriture).

Exemple de code:
```
Dictionary<int, string> myDietFavorites = new Dictionary<int, string>()
{
    { 1, "Burger"},
    { 2, "Fries"},
    { 3, "Donuts"}
};
```
Disons que vous voulez rester en bonne santé, vous avez changé votre esprit et que vous voulez remplacer votre favori "Burger" avec de la salade. Votre liste est encore une liste de vos favoris, vous n'aurez pas à changer la nature de la liste. Votre préféré restera le numéro un sur la liste, que c'est la valeur va changer. C'est quand vous appelez cette:
```
/*your key stays 1, you only replace the value assigned to this key
  you alter existing record in your dictionary*/
myDietFavorites[1] = "Salad";
```
Mais n'oubliez pas que vous êtes le programmeur, et à partir de maintenant tu finis tes phrases avec ; vous refusez d'utiliser des émoticônes, car ils jeter erreur de compilation et toute la liste des favoris est de 0 basée sur un index.

Votre régime alimentaire changé!!! Si vous modifiez votre liste de nouveau:
```
/*you don't want to replace Salad, you want to add this new fancy 0
  position to your list. It wasn't there before so you can either define it*/
myDietFavorites[0] = "Pizza";

/*or Add it*/
myDietFavorites.Add(0, "Pizza");
```
Il y a deux possibilités de définition, vous souhaitez donner une nouvelle définition de quelque chose d'inexistant avant ou vous voulez changer la définition de ce qui existe déjà.

Méthode Add permet d'ajouter un enregistrement, mais à une seule condition: clé de cette définition peut ne pas exister dans votre dictionnaire.

Maintenant, nous allons regarder sous le capot. Lorsque vous faites un dictionnaire de votre compilateur de faire une réservation pour le seau (espaces de mémoire pour stocker vos dossiers). Seau de ne pas stocker les clés dans la façon de les définir. Chaque clé est haché avant d'aller au seau (défini par Microsoft), la peine de mentionner que la valeur reste inchangée.

Je vais utiliser l'algorithme de hachage CRC32 pour simplifier mon exemple. Lorsque vous définir:
```
myDietFavorites[0] = "Pizza";
```
Ce qui se passe dans le seau est db2dc565 "Pizza" (simplifié).

Lorsque vous modifiez la valeur avec:
```
myDietFavorites[0] = "Spaghetti";
```
Vous hachage votre 0, qui est de nouveau db2dc565 puis vous regardez en haut de cette valeur dans votre seau pour trouver si il y est. Si il est là, il vous suffit de réécrire la valeur attribuée à la touche. Si ce n'est pas là, vous allez placer votre valeur dans le seau.

Lorsque vous appelez la fonction Ajouter à votre dictionnaire comme:
```
myDietFavorite.Add(0, "Chocolate");
```
Vous hachage votre 0 à comparer sa valeur à ceux dans le seau. Vous pouvez le placer dans le seau seulement s'il n'y.

Il est crucial de savoir comment il fonctionne, surtout si vous travaillez avec des dictionnaires de chaîne ou de char type de clé. Il est sensible à la casse parce que de subir le hachage. Ainsi, par exemple, "nom" != "Nom". Nous allons utiliser notre CRC32 pour décrire ce.

Valeur de "nom" est: e04112b1
La valeur de "Nom": 1107fb5b
- Ce deux lignes est suffisant pour comprendre ....... Il y a deux possibilités de définition, vous souhaitez donner une nouvelle définition de quelque chose d'inexistant avant ou vous voulez changer la définition de ce qui existe déjà. Ajouter une méthode vous permet d'ajouter un enregistrement, mais à une seule condition: clé de cette définition peut ne pas exister dans votre dictionnaire.
InformationsquelleAutor Kamil Kurzynowski
4

Oui, c'est la différence, le complément de la méthode lève une exception si la clé existe déjà.

La raison d'utiliser la méthode Add est exactement cela. Si le dictionnaire n'est pas censé contenir de la clé déjà, vous voulez généralement à l'exception de sorte que vous êtes conscient du problème.
- Semble raisonnable 🙂
InformationsquelleAutor Guffa
0

Compte tenu de l', plus que probable des similitudes dans la performance, quel que soit le sentir plus correcte et lisible pour le morceau de code que vous utilisez.

Je ressens une opération qui décrit une outre, la présence de la clé déjà une très rare exception est la mieux représentée avec le complément. Du point de vue sémantique, il est plus logique.

La dict[key] = value représente mieux une substitution. Si je vois que le code que j'ai la moitié prévoit la clé pour être déjà dans le dictionnaire de toute façon.
- Je suppose que il y a un petit gain de performance de pas de vérifier si la clé existe en premier. Je ne m'attends pas à partir de dic[key] = value que la clé était déjà présent, mais je suppose que c'est discutable 😉
- + je pense que jeter ne devrait jamais être utilisée comme un moyen de vérifier si la clé est déjà représenté. if(!les chaînes de caractères.ContainsKey("toto")) les chaînes de caractères.Add("foo", "bar");
InformationsquelleAutor Jorge Córdoba
0

L'une consiste à attribuer une valeur, tandis que l'autre est d'ajouter dans le Dictionnaire une nouvelle Clé et la Valeur.

InformationsquelleAutor Joshua Smith

Vous devez vous connecter pour publier un commentaire.