Boxing es convertir un tipo de valor (como int) en un tipo de referencia (object) — envolviéndolo en un objeto en el heap. Unboxing es lo inverso (extrayendo el valor de nuevo). Ambos tienen un costo de rendimiento (asignación en heap, copia), y comprenderlos te ayuda a evitar sobrecarga innecesaria.
int number = 42; // a value type (on the stack)
object boxed = number; // BOXING — wraps 42 in an object ON THE HEAP (allocation + copy)
int unboxed = (int)boxed; // UNBOXING — extracts the value back (copy, requires a cast)
Boxing asigna un nuevo objeto en el heap y copia el valor en él; unboxing lo copia de nuevo. Cada operación de boxing es una asignación en heap — barata una vez, pero costosa en rutas críticas o bucles.
// ❌ using a value type where an `object` is expected → implicit boxing
object obj = 42; // boxing
ArrayList list = new(); list.Add(42); // boxes (non-generic — stores object)
string s = string.Format("{0}", 42); // boxing for the object[] params
// these can box repeatedly in loops → significant GC pressure
Boxing frecuentemente ocurre implícitamente — siempre que un tipo de valor se usa donde object (o una interfaz no genérica) es esperada. En bucles o rutas críticas, el boxing repetido crea muchos objetos de corta vida en el heap, afectando el rendimiento.
// ❌ non-generic collection — boxes every value type added
ArrayList list = new();
list.Add(42); // boxes
// ✅ generic collection — NO boxing, type-safe
List<int> list = new();
list.Add(42); // no boxing — stored as int directly
La solución principal es usar genéricos (List<int> en lugar de ArrayList) — los genéricos almacenan tipos de valor directamente sin boxing. Este es uno de los beneficios clave de rendimiento de los genéricos sobre las antiguas colecciones no genéricas.
Comprender boxing y unboxing es importante para escribir C# performante y para apreciar por qué los genéricos importan.
Boxing — convertir un tipo de valor a un tipo de referencia (object) — incurre en una asignación en heap y copia, y unboxing copia el valor de nuevo, por lo que ambos tienen un costo de rendimiento.
Aunque una sola operación de boxing es barata, el problema es que boxing frecuentemente ocurre implícitamente (siempre que un tipo de valor se usa donde object es esperado) y puede ocurrir repetidamente en bucles o rutas críticas, creando muchos objetos de corta vida en el heap que aumentan la presión del GC y degradan el rendimiento — un problema de rendimiento sutil y fácil de pasar por alto.
El punto clave práctico es que los genéricos evitan boxing: usar List<int> en lugar de la antigua ArrayList no genérica almacena tipos de valor directamente sin boxing, lo que es uno de los principales beneficios de rendimiento de los genéricos sobre las colecciones no genéricas heredadas (y una razón clave para siempre usar colecciones genéricas).
Comprender qué son boxing/unboxing, cuándo ocurren (a menudo invisiblemente), su costo de rendimiento (asignación, presión del GC, especialmente en bucles), y cómo los genéricos los previenen es conocimiento importante para escribir C# eficiente y para entender por qué las colecciones genéricas son preferidas.
Ya que boxing es una fuente común y sutil de sobrecarga de rendimiento, y ya que evitarlo (vía genéricos) es una práctica fundamental de rendimiento, comprender boxing/unboxing es conocimiento valioso y prácticamente relevante que distingue a desarrolladores de C# conscientes del rendimiento y es un tema frecuente en entrevistas que refleja comprensión del modelo de tipo valor/referencia y los beneficios de los genéricos.