Qué agregar para la parte de actualización en ConcurrentDictionary AddOrUpdate

Estoy tratando de volver a escribir un código usando el Diccionario para usar ConcurrentDictionary. He revisado algunos ejemplos, pero todavía tengo problemas para implementar la función AddOrUpdate. Este es el 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;

No sé qué agregar para la parte de actualización:

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

Cualquier indicador sería apreciada.

Debe pasar un Funcque devuelve el valor que se almacenará en el diccionario en caso de una actualización. Supongo que en su caso (ya que no distingue entre agregar y actualizar) esto sería:

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

Es decir, Funcsiempre devuelve el sessionId, de modo que tanto Add como Update establecen el mismo valor.

Por cierto: hay una muestra en la página de MSDN .

Espero no haberme perdido nada en tu pregunta, pero ¿por qué no así? Es más fácil, atómico y seguro para subprocesos (ver más abajo).

userDic[authUser.UserId] = sessionId;

Almacene un par clave / valor en el diccionario incondicionalmente, sobrescribiendo cualquier valor para esa clave si la clave ya existe: use el definidor del indexador

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

El indexador también es atómico. Si pasa una función en su lugar, es posible que no sea:

Todas estas operaciones son atómicas y seguras para subprocesos con respecto a todas las demás operaciones en ConcurrentDictionary. La única advertencia sobre la atomicidad de cada operación es para aquellas que aceptan un delegado, a saber, AddOrUpdate y GetOrAdd. [...] estos delegados se invocan fuera de las cerraduras

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

Terminé implementando un método de extensión:

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 aquellos que estén interesados, actualmente estoy implementando un caso que es un gran ejemplo para usar el "oldValue" también conocido como valor existente en lugar de forzar uno nuevo (personalmente no me gusta el término "oldValue" ya que no es tan antiguo cuando se creó hace unos pocos pasos de procesador desde dentro de un hilo paralelo).

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