Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C#

Boxing y unboxing de valores en C#

Aprende cuándo C# copia un valor en un objeto, por qué el unboxing exige que el tipo coincida y qué excepción se produce en cada caso.

Versión: C# 12 and .NET 8; later runtimes may add compatible features

Sintaxis

object boxed = value;       // value has a boxable value type T
T copy = (T)boxed;          // T is the original non-nullable value type
T? optional = (T?)boxed;    // also accepts null and yields an empty T?

El boxing convierte implícitamente un valor como int en object o en un tipo de interfaz que su tipo implementa. El entorno de ejecución normalmente asigna un objeto en el montón administrado para guardar una copia del valor. Cambiar después la variable original no modifica esa copia. El boxing frecuente puede aumentar la carga del recolector de basura; List<int> almacena sus elementos sin boxing.

El unboxing es una conversión explícita que comprueba el tipo del valor almacenado y extrae una copia. Para un tipo de valor de destino que no admite null, la regla de C# exige una coincidencia exacta de tipos. Si boxed contiene un int, (int)boxed funciona, pero (long)boxed produce InvalidCastException aunque el número quepa en un long. En long widened = (int)boxed;, primero se extrae el int y luego la asignación lo convierte implícitamente en long.

El unboxing de una referencia null a un tipo que no admite null, como int, produce NullReferenceException. Si la referencia no es null pero no apunta a un objeto compatible, se produce InvalidCastException.

El boxing de T? es distinto: si HasValue es verdadero, se almacena el valor subyacente de tipo T, no la instancia de T?. De lo contrario, el resultado es una referencia null y no se asigna ningún objeto. El unboxing a T? da un valor vacío para null, o un valor que contiene T para un T previamente sometido a boxing. Un objeto incompatible sigue provocando InvalidCastException.

Ejemplos

#nullable enable
using System;

int source = 42;
object boxed = source;
source = 7;

Console.WriteLine(FormattableString.Invariant($"source={source}; boxed={(int)boxed}"));
long widened = (int)boxed;
Console.WriteLine(FormattableString.Invariant($"widened={widened}"));

try
{
    _ = (long)boxed;
}
catch (InvalidCastException)
{
    Console.WriteLine(nameof(InvalidCastException));
}

object? empty = (int?)null;
try
{
    _ = (int)empty!;
}
catch (NullReferenceException)
{
    Console.WriteLine(nameof(NullReferenceException));
}

int? present = (int?)boxed;
int? absent = (int?)empty;
Console.WriteLine(FormattableString.Invariant($"nullable value={present}; empty HasValue={absent.HasValue}"));

Resultado

source=7; boxed=42
widened=42
InvalidCastException
NullReferenceException
nullable value=42; empty HasValue=False

Cambiar `source` a `7` no modifica el `42` almacenado. El `!` de `empty!` solo suprime la advertencia del compilador sobre un posible `null`; no cambia el valor ni evita la excepción.

Lecciones relacionadas

  • C# · Lección 37 · Intermedio · Versión: 2

Fuentes