O que adicionar para a parte de atualização em ConcurrentDictionary AddOrUpdate

Estou tentando reescrever algum código usando o Dicionário para usar o ConcurrentDictionary. Eu revisei alguns exemplos, mas ainda estou tendo problemas para implementar a função AddOrUpdate. Este é o código original:

    dynamic a = HttpContext;
    Dictionary<int, string> userDic = this.HttpContext.Application["UserSessionList"] as Dictionary<int, String>;

   if (userDic != null)
   {
      if (useDic.ContainsKey(authUser.UserId))
      {
        userDic.Remove(authUser.UserId);
      }
   }
  else
  {
     userDic = new Dictionary<int,string>();
  }
  userDic.Add(authUser.UserId, a.Session.SessionID.ToString());
  this.HttpContext.Application["UserDic"] = userDic;

Não sei o que adicionar para a parte de atualização:

userDic.AddOrUpdate(authUser.UserId,
                    a.Session.SessionID.ToString(),
                    /*** what to add here? ***/);

Quaisquer sugestões serão apreciadas.

Você precisa passar um Funcque retorna o valor a ser armazenado no dicionário em caso de atualização. Acho que no seu caso (já que você não faz distinção entre adicionar e atualizar) isso seria:

var sessionId = a.Session.SessionID.ToString();
userDic.AddOrUpdate(
  authUser.UserId,
  sessionId,
  (key, oldValue) => sessionId);

Ou seja, Funcsempre retorna o sessionId, de forma que Add e Update definem o mesmo valor.

BTW: há um exemplo na página do MSDN .

Espero não ter perdido nada na sua pergunta, mas por que não assim? É mais fácil, atômico e thread-safe (veja abaixo).

userDic[authUser.UserId] = sessionId;

Armazene um par de chave / valor no dicionário incondicionalmente, sobrescrevendo qualquer valor para aquela chave se a chave já existir: Use o configurador do indexador

(Consulte: http://blogs.msdn.com/b/pfxteam/archive/2010/01/08/9945809.aspx )

O indexador também é atômico. Se você passar uma função, pode não ser:

Todas essas operações são atômicas e seguras com thread em relação a todas as outras operações no ConcurrentDictionary. A única advertência quanto à atomicidade de cada operação é para aquelas que aceitam um delegado, ou seja, AddOrUpdate e GetOrAdd. [...] esses delegados são invocados fora das fechaduras

Veja: http://blogs.msdn.com/b/pfxteam/archive/2010/01/08/9945809.aspx

Acabei implementando um método de extensão:

static class ExtensionMethods
{
    // Either Add or overwrite
    public static void AddOrUpdate<K, V>(this ConcurrentDictionary<K, V> dictionary, K key, V value)
    {
        dictionary.AddOrUpdate(key, value, (oldkey, oldvalue) => value);
    }
}

Para aqueles que estão interessados ​​em, atualmente estou implementando um caso que é um ótimo exemplo para usar o valor "oldValue" também conhecido como valor existente em vez de forçar um novo (pessoalmente, não gosto do termo "oldValue" porque não é esse antigo quando foi criado há apenas alguns cliques do processador em um thread paralelo).

dictionaryCacheQueues.AddOrUpdate(
    uid,
    new ConcurrentQueue<T>(),
    (existingUid, existingValue) => existingValue
);