Cosa aggiungere per la parte di aggiornamento in ConcurrentDictionary AddOrUpdate

Sto cercando di riscrivere del codice usando Dictionary per usare ConcurrentDictionary. Ho esaminato alcuni esempi ma riscontro ancora problemi nell'implementazione della funzione AddOrUpdate. Questo è il codice originale:

    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;

Non so cosa aggiungere per la parte di aggiornamento:

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

Eventuali suggerimenti sarebbero apprezzati.

È necessario passare a Funcche restituisce il valore da memorizzare nel dizionario in caso di aggiornamento. Immagino che nel tuo caso (dal momento che non fai distinzione tra aggiungi e aggiorna) questo sarebbe:

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

Cioè Funcrestituisce sempre il sessionId, in modo che sia Add che Update impostino lo stesso valore.

BTW: c'è un esempio nella pagina MSDN .

Spero di non essermi perso nulla nella tua domanda, ma perché non proprio così? È più facile, atomico e thread-safe (vedi sotto).

userDic[authUser.UserId] = sessionId;

Memorizza una coppia chiave / valore nel dizionario incondizionatamente, sovrascrivendo qualsiasi valore per quella chiave se la chiave esiste già: usa il setter dell'indicizzatore

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

Anche l'indicizzatore è atomico. Se invece passi una funzione, potrebbe non essere:

Tutte queste operazioni sono atomiche e sono thread-safe rispetto a tutte le altre operazioni su ConcurrentDictionary. L'unico avvertimento sull'atomicità di ciascuna operazione è per quelle che accettano un delegato, ovvero AddOrUpdate e GetOrAdd. [...] questi delegati vengono richiamati al di fuori dei blocchi

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

Ho finito per implementare un metodo di estensione:

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

Per coloro che sono interessati, sto attualmente implementando un caso che è un ottimo esempio per utilizzare "oldValue" aka valore esistente invece di forzarne uno nuovo (personalmente non mi piace il termine "oldValue" perché non è quello vecchio quando è stato creato solo pochi tick del processore fa da un thread parallelo).

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