Was für den Update-Teil in ConcurrentDictionary AddOrUpdate hinzuzufügen ist

Ich versuche, Code mit Dictionary neu zu schreiben, um ConcurrentDictionary zu verwenden. Ich habe einige Beispiele überprüft, habe jedoch immer noch Probleme bei der Implementierung der AddOrUpdate-Funktion. Dies ist der Originalcode:

    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;

Ich weiß nicht, was ich für den Update-Teil hinzufügen soll:

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

Alle Hinweise wäre dankbar.

Sie müssen a übergeben, Funcdas den Wert zurückgibt, der im Falle einer Aktualisierung im Wörterbuch gespeichert werden soll. Ich denke in Ihrem Fall (da Sie nicht zwischen Hinzufügen und Aktualisieren unterscheiden) wäre dies:

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

FuncDh das gibt immer die sessionId zurück, so dass sowohl Add als auch Update den gleichen Wert setzen.

Übrigens: Auf der MSDN-Seite befindet sich ein Beispiel .

Ich hoffe, dass ich in Ihrer Frage nichts verpasst habe, aber warum nicht einfach so? Es ist einfacher, atomar und threadsicher (siehe unten).

userDic[authUser.UserId] = sessionId;

Speichern Sie ein Schlüssel / Wert-Paar bedingungslos im Wörterbuch und überschreiben Sie einen beliebigen Wert für diesen Schlüssel, wenn der Schlüssel bereits vorhanden ist: Verwenden Sie den Setter des Indexers

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

Der Indexer ist auch atomar. Wenn Sie stattdessen eine Funktion übergeben, ist dies möglicherweise nicht:

Alle diese Operationen sind atomar und in Bezug auf alle anderen Operationen im ConcurrentDictionary threadsicher. Die einzige Einschränkung für die Atomizität jeder Operation betrifft diejenigen, die einen Delegaten akzeptieren, nämlich AddOrUpdate und GetOrAdd. [...] Diese Delegaten werden außerhalb der Sperren aufgerufen

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

Am Ende habe ich eine Erweiterungsmethode implementiert:

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

Für diejenigen, die daran interessiert sind, implementiere ich derzeit einen Fall, der ein großartiges Beispiel für die Verwendung des "alten Werts" oder des vorhandenen Werts ist, anstatt einen neuen zu erzwingen (persönlich mag ich den Begriff "alter Wert" nicht, da dies nicht der Fall ist alt, als es erst vor wenigen Prozessor-Ticks innerhalb eines parallelen Threads erstellt wurde).

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