C# proporciona un amplio conjunto de tipos de colección en System.Collections.Generic para almacenar grupos de datos. Los más comunes son List<T> (array dinámico), Dictionary<K,V> (mapa clave-valor) y HashSet<T> (conjunto único). Elegir el correcto es importante para la claridad y el rendimiento.
var numbers = new List<int> { 1, 2, 3 };
numbers.Add(4); // grows dynamically
numbers[0]; // index access — O(1)
numbers.Contains(3); // O(n) search
numbers.Remove(2);
numbers.Count; // size
foreach (var n in numbers) { } // iterate
List<T> es la colección de propósito general más utilizada — una lista ordenada, redimensionable e indexada. El <T> es un parámetro de tipo genérico (List<string>, List<User>), proporcionando seguridad de tipos en tiempo de compilación.
var ages = new Dictionary<string, int> { ["Ann"] = 30, ["Bob"] = 25 };
ages["Carol"] = 28; // add/set
ages["Ann"]; // get by key — O(1)
ages.ContainsKey("Ann");
ages.TryGetValue("Ann", out var age); // safe lookup (no exception if missing)
foreach (var (name, a) in ages) { } // iterate key-value pairs
Dictionary<K,V> mapea claves a valores con búsquedas rápidas O(1) — para cachés, índices y cualquier acceso basado en clave. TryGetValue es la forma segura de buscar (evitando una excepción cuando falta la clave).
var set = new HashSet<int> { 1, 2, 3 }; // unique elements, O(1) Contains
set.Add(2); // ignored (duplicate)
var queue = new Queue<int>(); // FIFO
var stack = new Stack<int>(); // LIFO
int[] arr = { 1, 2, 3 }; // fixed-size array
var ro = numbers.AsReadOnly(); // read-only wrapper
Ordered, indexed, resizable → List<T>
Key-value lookup (fast) → Dictionary<K,V>
Uniqueness / fast membership → HashSet<T>
FIFO / LIFO processing → Queue<T> / Stack<T>
Fixed size / performance-critical → array (T[])
Las colecciones son fundamentales en casi todo programa — almacenar y procesar grupos de datos es constante — por lo que comprender los tipos de colección comunes de C# y elegir bien es un conocimiento esencial del día a día.
Conocer los tipos principales y sus casos de uso — List<T> para datos ordenados, indexados y redimensionables (la herramienta de propósito general), Dictionary<K,V> para búsqueda rápida basada en clave (cachés, índices), HashSet<T> para unicidad y pruebas rápidas de pertenencia, y Queue/Stack para procesamiento FIFO/LIFO — es necesario para escribir código eficiente y claro.
La elección afecta directamente al rendimiento (por ejemplo, la búsqueda O(1) de un Dictionary vs escanear O(n) de una List, o pertenencia O(1) de HashSet vs O(n) de List) e intención, por lo que elegir la colección apropiada en lugar de usar List<T> por defecto para todo es una habilidad importante.
Estas colecciones también son genéricas (<T>), proporcionando seguridad de tipos en tiempo de compilación.
Conocer detalles prácticos como TryGetValue para búsquedas seguras en diccionarios (evitando excepciones en claves faltantes) y las características de rendimiento de cada tipo cubre las necesidades cotidianas de trabajar con datos en C#.
Ya que las colecciones aparecen en prácticamente todo programa y la elección correcta afecta de manera significativa el rendimiento y la legibilidad, dominar los tipos de colección comunes y su uso apropiado es conocimiento fundamental e imprescindible para el desarrollo efectivo en C#.