ConcurrentDictionary<T>, raccolte immutabili
Usate ConcurrentDictionary per aggiornamenti thread-safe e imparate semplici approcci immutabili: viste di sola lettura e copia su scrittura.
ConcurrentDictionary<T>, raccolte immutabili è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 2 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 3 lezioni in totale.
Nozioni di base su sicurezza dei thread e immutabilità
Oggi:
- ConcurrentDictionary<TKey,TValue>: aggiornamenti sicuri da più thread
- Viste di sola lettura rispetto alla vera immutabilità
- Concetto di copy-on-write per una sicurezza semplice
Operazioni atomiche: GetOrAdd/AddOrUpdate
Utilizzi GetOrAdd e AddOrUpdate per operazioni atomiche; TryGetValue per leggere in modo sicuro.
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);
}
}
Idea dell'incremento senza race condition
AddOrUpdate evita la classica race condition di lettura-modifica-scrittura aggiornando in modo atomico.
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)
}
}
Vista di sola lettura (non immutabile)
AsReadOnly restituisce una vista di sola lettura, non una raccolta veramente immutabile: le modifiche alla sorgente compaiono nella vista.
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
}
}
Istantanea copy-on-write
Copy-on-write: restituisca una nuova lista per applicare le modifiche. I chiamanti che conservano la vecchia lista vedono un'istantanea stabile.
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
}
}
Suggerimenti e compromessi
Suggerimenti:
- Utilizzi ConcurrentDictionary per contatori e cache condivisi.
- AsReadOnly impedisce ai consumer di modificare accidentalmente i dati.
- Per una vista stabile, copi la lista prima di modificarla.
- Le raccolte veramente immutabili si trovano in System.Collections.Immutable (pacchetto); qui non vengono utilizzate per mantenere il codice autonomo.
Scelta del dizionario thread-safe
Riepilogo
Riepilogo: utilizzi ConcurrentDictionary per gli aggiornamenti concorrenti. Esponga viste di sola lettura ai chiamanti e utilizzi il copy-on-write quando servono istantanee stabili.
Domande Frequenti
La lezione «ConcurrentDictionary<T>, raccolte immutabili» è gratuita?
Sì — il testo completo di «ConcurrentDictionary<T>, raccolte immutabili» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 3 lezioni in totale.
Cosa imparerò in «ConcurrentDictionary<T>, raccolte immutabili»?
Usate ConcurrentDictionary per aggiornamenti thread-safe e imparate semplici approcci immutabili: viste di sola lettura e copia su scrittura. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare C# Academy?
Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 3.
Quanto tempo richiede la lezione «ConcurrentDictionary<T>, raccolte immutabili»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione C# Academy?
Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- HashSet , SortedSet , Queue , Stack
- ConcurrentDictionary , raccolte immutabili
- Uguaglianza e hashing (valore e riferimento)