Diferentes maneiras de adicionar ao Dicionário

Qual é a diferença em Dictionary.add(key, value)e Dictionary[key] = value?

Percebi que a última versão não lança um ArgumentExceptionao inserir uma chave duplicada, mas há algum motivo para preferir a primeira versão?

Edit : Alguém tem uma fonte confiável de informações sobre isso? Eu tentei o MSDN, mas é como sempre uma caça ao ganso selvagem :(

O desempenho é quase 100% idêntico. Você pode verificar isso abrindo a classe no Reflector.net

Este é o Este indexador:

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 este é o método Add:

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

Não vou postar todo o método Insert porque é bastante longo, no entanto, a declaração do método é esta:

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

E mais abaixo na função, isso acontece:

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

Que verifica se a chave já existe, e se existe e o parâmetro add é verdadeiro, ele lança a exceção.

Portanto, para todos os fins e intenções, o desempenho é o mesmo.

Como algumas outras menções, trata-se de saber se você precisa da verificação, para tentar adicionar a mesma chave duas vezes.

Desculpe pela postagem longa, espero que esteja tudo bem.

A primeira versão adicionará um novo KeyValuePair ao dicionário, lançando se a chave já estiver no dicionário. O segundo, usando o indexador, adicionará um novo par se a chave não existir, mas sobrescreverá o valor da chave se ela já existir no dicionário.

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] = valuetêm finalidades diferentes:

• Use o Addmétodo para adicionar um novo par de chave / valor, as chaves existentes não serão substituídas (um ArgumentExceptioné lançado).
• Use o indexador se você não se importa se a chave já existe no dicionário, em outras palavras: adicione o par chave / valor se a chave não estiver no dicionário ou substitua o valor pela chave especificada se a chave já estiver no dicionário.

Para responder à pergunta, primeiro precisamos dar uma olhada no propósito de um dicionário e da tecnologia subjacente.

Dictionaryé a lista de KeyValuePair<Tkey, Tvalue>onde cada valor é representado por sua chave exclusiva. Digamos que temos uma lista de suas comidas favoritas. Cada valor (nome do alimento) é representado por sua chave exclusiva (a posição = o quanto você gosta desse alimento).

Código de exemplo:

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

Digamos que você queira se manter saudável, mudou de ideia e deseja substituir seu "hambúrguer" favorito por salada. Sua lista ainda é uma lista de seus favoritos, você não mudará a natureza da lista. Seu favorito permanecerá em primeiro lugar na lista, apenas seu valor será alterado. É quando você chama isso de:

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

Mas não se esqueça que você é o programador, e a partir de agora você termina suas frases com; você se recusa a usar emojis porque eles gerariam um erro de compilação e toda a lista de favoritos é baseada em 0 índice.

Sua dieta também mudou! Então, você altera sua lista novamente:

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

Existem duas possibilidades com a definição: você deseja fornecer uma nova definição para algo que não existia antes ou deseja alterar a definição que já existe.

O método Adicionar permite adicionar um registro, mas apenas sob uma condição: a chave para esta definição pode não existir no seu dicionário.

Agora vamos dar uma olhada sob o capô. Quando você está fazendo um dicionário, seu compilador faz uma reserva para o intervalo (espaços na memória para armazenar seus registros). Bucket não armazena chaves da maneira como você as define. Cada chave é hash antes de ir para o balde (definido pela Microsoft), vale a pena mencionar que a parte do valor permanece inalterada.

Usarei o algoritmo de hash CRC32 para simplificar meu exemplo. Quando você define:

myDietFavorites[0] = "Pizza";

O que vai para o balde é db2dc565 "Pizza" (simplificado).

Quando você altera o valor com:

myDietFavorites[0] = "Spaghetti";

Você hash seu 0, que é novamente db2dc565, e então procura esse valor em seu depósito para descobrir se ele está lá. Se estiver lá, você simplesmente reescreve o valor atribuído à chave. Se não estiver lá, você colocará seu valor no balde.

Ao chamar a função Adicionar em seu dicionário, como:

myDietFavorite.Add(0, "Chocolate");

Você hash seu 0 para comparar seu valor com os do intervalo. Você pode colocá-lo no balde somente se ele não estiver lá .

É crucial saber como funciona, especialmente se você trabalha com dicionários de string ou tipo de chave char. É sensível a maiúsculas e minúsculas devido ao hashing em curso. Por exemplo, "nome"! = "Nome". Vamos usar nosso CRC32 para representar isso.

O valor para "nome" é: e04112b1 O valor para "Nome" é: 1107fb5b

Sim, essa é a diferença, o método Add lança uma exceção se a chave já existir.

A razão para usar o método Add é exatamente esta. Se o dicionário ainda não deve conter a chave, você geralmente deseja a exceção para que esteja ciente do problema.

Dadas as semelhanças mais do que prováveis ​​no desempenho, use o que parecer mais correto e legível para o trecho de código que você está usando.

Sinto que uma operação que descreve uma adição, sendo a presença da chave já uma exceção realmente rara, é melhor representada com a adição. Semanticamente, faz mais sentido.

O dict[key] = valuerepresenta melhor uma substituição. Se eu vir esse código, eu meio que espero que a chave já esteja no dicionário de qualquer maneira.

Um está atribuindo um valor, enquanto o outro está adicionando ao Dicionário uma nova Chave e Valor.

Para inserir o valor no dicionário

 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