Diversi modi di aggiungere al dizionario

Qual è la differenza in Dictionary.add(key, value)e Dictionary[key] = value?

Ho notato che l'ultima versione non genera un ArgumentExceptionquando si inserisce una chiave duplicata, ma c'è qualche motivo per preferire la prima versione?

Modifica : qualcuno ha una fonte autorevole di informazioni su questo? Ho provato MSDN, ma è come sempre una caccia all'oca selvaggia :(

Le prestazioni sono quasi identiche al 100%. Puoi verificarlo aprendo la classe in Reflector.net

Questo è l'indicizzatore This:

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

E questo è il metodo Add:

public void Add(TKey key, TValue value)
{
    this.Insert(key, value, true);
}

Non pubblicherò l'intero metodo Insert poiché è piuttosto lungo, tuttavia la dichiarazione del metodo è questa:

private void Insert(TKey key, TValue value, bool add)

E più in basso nella funzione, succede questo:

if ((this.entries[i].hashCode == num) && this.comparer.Equals(this.entries[i].key, key))
{
    if (add)
    {
        ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AddingDuplicate);
    }

Che controlla se la chiave esiste già, e se lo fa e il parametro add è vero, genera l'eccezione.

Quindi, a tutti gli effetti, la performance è la stessa.

Come poche altre menzioni, si tratta solo di verificare se è necessario il controllo, per i tentativi di aggiungere la stessa chiave due volte.

Scusa per il lungo post, spero che vada bene.

La prima versione aggiungerà una nuova KeyValuePair al dizionario, lanciando se la chiave è già nel dizionario. Il secondo, utilizzando l'indicizzatore, aggiungerà una nuova coppia se la chiave non esiste, ma sovrascriverà il valore della chiave se esiste già nel dizionario.

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     

Dictionary.Add(key, value)e Dictionary[key] = valuehanno scopi diversi:

• Utilizza il Addmetodo per aggiungere una nuova coppia chiave / valore, le chiavi esistenti non verranno sostituite ( ArgumentExceptionviene generato un messaggio).
• Usa l'indicizzatore se non ti interessa se la chiave esiste già nel dizionario, in altre parole: aggiungi la coppia chiave / valore se la chiave non è nel dizionario o sostituisci il valore per la chiave specificata se la chiave è già nel dizionario.

Per rispondere alla domanda prima dobbiamo dare un'occhiata allo scopo di un dizionario e alla tecnologia sottostante.

Dictionaryè l'elenco di KeyValuePair<Tkey, Tvalue>dove ogni valore è rappresentato dalla sua chiave univoca. Diciamo che abbiamo un elenco dei tuoi cibi preferiti. Ogni valore (nome del cibo) è rappresentato dalla sua chiave univoca (una posizione = quanto ti piace questo cibo).

Codice di esempio:

Dictionary<int, string> myDietFavorites = new Dictionary<int, string>()
{
    { 1, "Burger"},
    { 2, "Fries"},
    { 3, "Donuts"}
};

Diciamo che vuoi restare in salute, hai cambiato idea e vuoi sostituire il tuo "Burger" preferito con l'insalata. Il tuo elenco è ancora un elenco dei tuoi preferiti, non cambierai la natura dell'elenco. Il tuo preferito rimarrà il numero uno della lista, solo il suo valore cambierà. Questo è quando lo chiami:

/*your key stays 1, you only replace the value assigned to this key
  you alter existing record in your dictionary*/
myDietFavorites[1] = "Salad";

Ma non dimenticare che sei il programmatore e da ora in poi finisci le tue frasi con; ti rifiuti di usare gli emoji perché genererebbero un errore di compilazione e tutto l'elenco dei preferiti è basato su 0 indice.

Anche la tua dieta è cambiata! Quindi modifichi di nuovo la tua lista:

/*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");

Ci sono due possibilità con la definizione, o vuoi dare una nuova definizione per qualcosa che non esisteva prima o vuoi cambiare la definizione che già esiste.

Il metodo Aggiungi ti consente di aggiungere un record ma solo a una condizione: la chiave per questa definizione potrebbe non esistere nel dizionario.

Ora guarderemo sotto il cofano. Quando si crea un dizionario, il compilatore effettua una prenotazione per il bucket (spazi in memoria per archiviare i record). Bucket non memorizza le chiavi nel modo in cui le definisci. Ogni chiave viene sottoposta ad hashing prima di passare al bucket (definito da Microsoft), vale la pena ricordare che la parte del valore rimane invariata.

Userò l'algoritmo di hashing CRC32 per semplificare il mio esempio. Quando definisci:

myDietFavorites[0] = "Pizza";

Quello che sta per finire nel secchio è db2dc565 "Pizza" (semplificato).

Quando modifichi il valore con:

myDietFavorites[0] = "Spaghetti";

Hai cancellato il tuo 0 che è di nuovo db2dc565, quindi cerchi questo valore nel tuo bucket per trovare se è lì. Se è lì, riscrivi semplicemente il valore assegnato alla chiave. Se non è lì, metterai il tuo valore nel secchio.

Quando chiami la funzione Aggiungi sul tuo dizionario come:

myDietFavorite.Add(0, "Chocolate");

Hai cancellato il tuo 0 per confrontare il suo valore con quelli nel secchio. Puoi metterlo nel secchio solo se non è lì .

È fondamentale sapere come funziona, soprattutto se lavori con dizionari di stringhe o caratteri di chiave. Fa distinzione tra maiuscole e minuscole a causa dell'hashing. Quindi per esempio "nome"! = "Nome". Usiamo il nostro CRC32 per descrivere questo.

Il valore per "nome" è: e04112b1 Il valore per "Nome" è: 1107fb5b

Sì, questa è la differenza, il metodo Add genera un'eccezione se la chiave esiste già.

Il motivo per utilizzare il metodo Add è esattamente questo. Se il dizionario non dovrebbe contenere già la chiave, di solito si desidera l'eccezione in modo da essere consapevoli del problema.

Date le somiglianze più che probabili nelle prestazioni, usa ciò che ritieni più corretto e leggibile per il pezzo di codice che stai utilizzando.

Sento un'operazione che descrive un'aggiunta, essendo la presenza della chiave già un'eccezione davvero rara è meglio rappresentata con l'add. Semanticamente ha più senso.

La dict[key] = valuerappresenta meglio una sostituzione. Se vedo quel codice mi aspetto che la chiave sia già comunque nel dizionario.

Uno sta assegnando un valore mentre l'altro sta aggiungendo al dizionario una nuova chiave e valore.

Per inserire il valore nel dizionario

 Dictionary<string, string> dDS1 = new Dictionary<string, string>();//Declaration
 dDS1.Add("VEqpt", "aaaa");//adding key and value into the dictionary
 string Count = dDS1["VEqpt"];//assigning the value of dictionary key to Count variable
 dDS1["VEqpt"] = Count + "bbbb";//assigning the value to key