ConcurrentDictionary<T> y colecciones inmutables
Use ConcurrentDictionary para actualizaciones seguras en entornos multihilo y aprenda enfoques inmutables sencillos: vistas de solo lectura y copia al escribir.
ConcurrentDictionary<T> y colecciones inmutables es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 2 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 3 lecciones en total.
Conceptos básicos de seguridad de subprocesos e inmutabilidad
En esta lección:
- ConcurrentDictionary<TKey,TValue>: actualizaciones seguras desde varios subprocesos
- Vistas de solo lectura frente a la inmutabilidad real
- Concepto de Copy-on-write para una seguridad sencilla
Operaciones atómicas: GetOrAdd/AddOrUpdate
Utilice GetOrAdd y AddOrUpdate para realizar operaciones atómicas; utilice TryGetValue para leer de forma segura.
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);
}
}
Concepto de incremento sin condiciones de carrera
AddOrUpdate evita la condición de carrera clásica de lectura-modificación-escritura al actualizar de forma atómica.
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 de solo lectura (no inmutable)
AsReadOnly devuelve una vista de solo lectura, no una colección verdaderamente inmutable: los cambios en el origen aparecen en la 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
}
}
Instantánea mediante Copy-on-write
Copy-on-write: devuelva una lista nueva al realizar cambios. Los llamadores que conservan la lista anterior ven una instantánea estable.
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
}
}
Consejos y ventajas e inconvenientes
Consejos:
- Utilice ConcurrentDictionary para contadores o cachés compartidos.
- AsReadOnly evita que los consumidores modifiquen los datos accidentalmente.
- Para obtener una vista estable, copie la lista antes de modificarla.
- Las colecciones verdaderamente inmutables se encuentran en System.Collections.Immutable (paquete); no se utilizan aquí para mantener el código independiente.
Elección de un diccionario seguro para subprocesos
Resumen
Resumen: utilice ConcurrentDictionary para las actualizaciones simultáneas. Exponga vistas de solo lectura a los llamadores y utilice Copy-on-write cuando necesite instantáneas estables.
Preguntas frecuentes
¿La lección «ConcurrentDictionary<T> y colecciones inmutables» es gratis?
Sí — el texto completo de «ConcurrentDictionary<T> y colecciones inmutables» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 3 lecciones en total.
¿Qué aprenderé en «ConcurrentDictionary<T> y colecciones inmutables»?
Use ConcurrentDictionary para actualizaciones seguras en entornos multihilo y aprenda enfoques inmutables sencillos: vistas de solo lectura y copia al escribir. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C# Academy?
No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 3.
¿Cuánto tiempo toma la lección «ConcurrentDictionary<T> y colecciones inmutables»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C# Academy?
Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- HashSet , SortedSet , Queue y Stack
- ConcurrentDictionary y colecciones inmutables
- Igualdad y hashing (por valor frente a por referencia)