0Pricing
C# Academy · Lektion

ConcurrentDictionary<T> und unveränderliche Sammlungen

Verwenden Sie ConcurrentDictionary für threadsichere Aktualisierungen und lernen Sie einfache unveränderliche Ansätze kennen: schreibgeschützte Ansichten und Copy-on-Write.

ConcurrentDictionary<T> und unveränderliche Sammlungen ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.

Grundlagen zu Thread-Sicherheit und Unveränderlichkeit

Heute:

  • ConcurrentDictionary<TKey,TValue>: sichere Aktualisierungen durch mehrere Threads
  • Schreibgeschützte Ansichten im Vergleich zu echter Unveränderlichkeit
  • Das Prinzip Copy-on-write für einfache Sicherheit

Atomare Operationen: GetOrAdd/AddOrUpdate

Verwenden Sie GetOrAdd und AddOrUpdate für atomare Operationen sowie TryGetValue zum sicheren Lesen.

using System;
using System.Collections.Concurrent;

public class Program
{
  public static void Main(string[] args)
  {
    ConcurrentDictionary<string, int> counts = new ConcurrentDictionary<string, int>();

    // Add if missing
    int a = counts.GetOrAdd("apple", 0); // 0
    // Increment safely
    int newVal = counts.AddOrUpdate("apple", 1, (key, oldValue) => oldValue + 1);

    Console.WriteLine("apple was " + a + ", now " + newVal);

    int value;
    bool ok = counts.TryGetValue("apple", out value);
    Console.WriteLine("Has apple? " + ok + " -> " + value);
  }
}

Idee für eine race-freie Erhöhung

AddOrUpdate vermeidet die klassische Race Condition beim Lesen, Ändern und Schreiben, indem die Aktualisierung atomar erfolgt.

using System;
using System.Collections.Concurrent;

public class Program
{
  static int Inc(int oldValue) { return oldValue + 1; }

  public static void Main(string[] args)
  {
    ConcurrentDictionary<string, int> clicks = new ConcurrentDictionary<string, int>();

    // Simulate multiple updates
    for (int i = 0; i < 5; i++)
    {
      clicks.AddOrUpdate("home", 1, delegate(string k, int v) { return Inc(v); });
    }

    Console.WriteLine("home clicks = " + clicks["home"]); // 5 (starting at 1 then +4)
  }
}

Schreibgeschützte Ansicht (nicht unveränderlich)

AsReadOnly gibt eine schreibgeschützte Ansicht zurück, keine tatsächlich unveränderliche Collection: Änderungen an der Quelle werden in der Ansicht sichtbar.

using System;
using System.Collections.Generic;

public class Program
{
  public static void Main(string[] args)
  {
    List<string> items = new List<string>(new string[] { "A", "B" });
    var ro = items.AsReadOnly(); // ReadOnlyCollection<string>

    foreach (string s in ro) Console.WriteLine(s); // A, B

    // ro.Add("C"); // not available: read-only view has no Add

    // But changing the source list reflects in the view:
    items.Add("C");
    Console.WriteLine("After source change:");
    foreach (string s in ro) Console.WriteLine(s); // A, B, C
  }
}

Copy-on-write-Snapshot

Copy-on-write: Geben Sie bei Änderungen eine neue Liste zurück. Aufrufer, die die alte Liste behalten, sehen einen stabilen Snapshot.

using System;
using System.Collections.Generic;

public class Program
{
  static List<int> AddWithoutTouchingOriginal(List<int> original, int item)
  {
    // create a copy and modify the copy
    List<int> copy = new List<int>(original);
    copy.Add(item);
    return copy;
  }

  public static void Main(string[] args)
  {
    List<int> a = new List<int>(new int[] { 1, 2 });
    List<int> b = AddWithoutTouchingOriginal(a, 3);

    Console.WriteLine("Original:");
    foreach (int x in a) Console.WriteLine(x); // 1,2

    Console.WriteLine("Copy:");
    foreach (int x in b) Console.WriteLine(x); // 1,2,3
  }
}

Tipps und Abwägungen

Tipps:

  • Verwenden Sie ConcurrentDictionary für gemeinsam genutzte Zähler und Caches.
  • AsReadOnly verhindert versehentliche Änderungen durch Consumer.
  • Für eine stabile Ansicht kopieren Sie die Liste, bevor Sie sie ändern.
  • Echte unveränderliche Collections befinden sich in System.Collections.Immutable (Paket); sie werden hier nicht verwendet, damit der Code eigenständig bleibt.

Auswahl eines thread-sicheren Dictionarys

Kurzer Check: Welche Collection unterstützt thread-sichere Hinzufügungen und Aktualisierungen ohne externe Sperren?

Zusammenfassung

Zusammenfassung: Verwenden Sie ConcurrentDictionary für nebenläufige Aktualisierungen. Stellen Sie Aufrufern schreibgeschützte Ansichten bereit und verwenden Sie Copy-on-write, wenn Sie stabile Snapshots benötigen.

Häufig gestellte Fragen

Ist die Lektion „ConcurrentDictionary<T> und unveränderliche Sammlungen“ kostenlos?

Ja — der vollständige Text von „ConcurrentDictionary<T> und unveränderliche Sammlungen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „ConcurrentDictionary<T> und unveränderliche Sammlungen“?

Verwenden Sie ConcurrentDictionary für threadsichere Aktualisierungen und lernen Sie einfache unveränderliche Ansätze kennen: schreibgeschützte Ansichten und Copy-on-Write. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.

Wie lange dauert die Lektion „ConcurrentDictionary<T> und unveränderliche Sammlungen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. HashSet , SortedSet , Queue , Stack
  2. ConcurrentDictionary und unveränderliche Sammlungen
  3. Gleichheit und Hashing (Wert und Referenz)
← Zurück zu C# Academy