ConcurrentDictionary<T> et collections immuables
Utilisez ConcurrentDictionary pour effectuer des mises à jour sûres dans les environnements multithreads et découvrez des approches simples pour l’immutabilité : vues en lecture seule et copie lors de l’écriture.
ConcurrentDictionary<T> et collections immuables est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 3 leçons au total.
Bases de la sécurité des threads et de l’immuabilité
Aujourd’hui :
- ConcurrentDictionary<TKey,TValue> : mises à jour sécurisées depuis plusieurs threads
- Vues en lecture seule et immuabilité réelle
- Concept de copie à l’écriture pour une sécurité simple
Opérations atomiques : GetOrAdd/AddOrUpdate
Utilisez GetOrAdd et AddOrUpdate pour les opérations atomiques, et TryGetValue pour lire de manière sûre.
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);
}
}
Incrémentation sans condition de concurrence
AddOrUpdate évite la condition de concurrence classique entre lecture, modification et écriture en effectuant une mise à jour atomique.
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)
}
}
Vue en lecture seule (non immuable)
AsReadOnly renvoie une vue en lecture seule, et non une collection réellement immuable : les modifications de la source apparaissent dans la vue.
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
}
}
Instantané par copie à l’écriture
Copie à l’écriture : renvoyez une nouvelle liste lorsque des modifications sont nécessaires. Les appelants qui conservent l’ancienne liste voient un instantané stable.
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
}
}
Conseils et compromis
Conseils :
- Utilisez ConcurrentDictionary pour les compteurs et caches partagés.
- AsReadOnly empêche les consommateurs de modifier accidentellement les données.
- Pour obtenir une vue stable, copiez la liste avant de la modifier.
- Les collections réellement immuables se trouvent dans System.Collections.Immutable (paquet) ; elles ne sont pas utilisées ici afin de conserver un code autonome.
Choix d’un dictionnaire compatible avec les threads
Récapitulatif
Récapitulatif : utilisez ConcurrentDictionary pour les mises à jour concurrentes. Exposez des vues en lecture seule au code appelant et utilisez la copie à l’écriture lorsque vous avez besoin d’instantanés stables.
Questions Fréquemment Posées
La leçon « ConcurrentDictionary<T> et collections immuables » est-elle gratuite ?
Oui — le texte complet de « ConcurrentDictionary<T> et collections immuables » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « ConcurrentDictionary<T> et collections immuables » ?
Utilisez ConcurrentDictionary pour effectuer des mises à jour sûres dans les environnements multithreads et découvrez des approches simples pour l’immutabilité : vues en lecture seule et copie lors d… Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C# Academy ?
Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.
Combien de temps prend la leçon « ConcurrentDictionary<T> et collections immuables » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?
Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- HashSet , SortedSet , Queue et Stack
- ConcurrentDictionary et collections immuables
- Égalité et hachage (valeur et référence)