Compartir a través de

Conversión boxing y unboxing (Guía de programación de C#)

La conversión boxing es el proceso de convertir un tipo de valor en el tipo object o en cualquier tipo de interfaz implementado por este tipo de valor. Cuando el Common Language Runtime (CLR) empaqueta un tipo de valor, encapsula el valor dentro de una instancia de System.Object y lo almacena en el montón administrado. La conversión unboxing extrae el tipo de valor del objeto. La conversión boxing es implícita y la conversión unboxing es explícita. El concepto de conversión boxing y unboxing es la base de la vista unificada del sistema de tipos de C#, en el que un valor de cualquier tipo se puede tratar como objeto.

En el ejemplo siguiente, se aplica i a la variable de entero y esta se asigna al objeto o.

int i = 123;
// The following line boxes i.
object o = i;

A continuación, el objeto o se puede desempaquetar y asignar a la variable ide entero :

o = 123;
i = (int)o;  // unboxing

En los siguientes ejemplos se ilustra el uso de boxing en C#.

// String.Concat example.
// String.Concat has many versions. Rest the mouse pointer on
// Concat in the following statement to verify that the version
// that is used here takes three object arguments. Both 42 and
// true must be boxed.
Console.WriteLine(String.Concat("Answer", 42, true));

// List example.
// Create a list of objects to hold a heterogeneous collection
// of elements.
List<object> mixedList = new List<object>();

// Add a string element to the list.
mixedList.Add("First Group:");

// Add some integers to the list.
for (int j = 1; j < 5; j++)
{
    // Rest the mouse pointer over j to verify that you are adding
    // an int to a list of objects. Each element j is boxed when
    // you add j to mixedList.
    mixedList.Add(j);
}

// Add another string and more integers.
mixedList.Add("Second Group:");
for (int j = 5; j < 10; j++)
{
    mixedList.Add(j);
}

// Display the elements in the list. Declare the loop variable by
// using var, so that the compiler assigns its type.
foreach (var item in mixedList)
{
    // Rest the mouse pointer over item to verify that the elements
    // of mixedList are objects.
    Console.WriteLine(item);
}

// The following loop sums the squares of the first group of boxed
// integers in mixedList. The list elements are objects, and cannot
// be multiplied or added to the sum until they are unboxed. The
// unboxing must be done explicitly.
var sum = 0;
for (var j = 1; j < 5; j++)
{
    // The following statement causes a compiler error: Operator
    // '*' cannot be applied to operands of type 'object' and
    // 'object'.
    //sum += mixedList[j] * mixedList[j];

    // After the list elements are unboxed, the computation does
    // not cause a compiler error.
    sum += (int)mixedList[j] * (int)mixedList[j];
}

// The sum displayed is 30, the sum of 1 + 4 + 9 + 16.
Console.WriteLine("Sum: " + sum);

// Output:
// Answer42True
// First Group:
// 1
// 2
// 3
// 4
// Second Group:
// 5
// 6
// 7
// 8
// 9
// Sum: 30

Rendimiento

Con relación a las asignaciones simples, las conversiones boxing y unboxing son procesos que consumen muchos recursos. Cuando se encapsula un tipo de valor, se debe asignar y construir un nuevo objeto. En menor grado, la conversión de tipos requerida para aplicar la conversión unboxing también es costosa. Para obtener más información, consulte Rendimiento.

Boxeo

La conversión boxing se utiliza para almacenar tipos de valor en el montón de recolección de elementos no utilizados. Boxing es una conversión implícita de un tipo de valor al tipo object o a cualquier tipo de interfaz que implemente este tipo de valor. Al aplicar la conversión boxing a un tipo de valor se asigna una instancia de objeto en el montón y se copia el valor en el nuevo objeto.

Tenga en cuenta la siguiente declaración de una variable de tipo de valor:

int i = 123;

La siguiente instrucción aplica implícitamente la operación de conversión boxing en la variable i:

// Boxing copies the value of i into object o.
object o = i;

El resultado de esta instrucción es crear una referencia de objeto o en la pila que hace referencia a un valor del tipo int en el montón. Este valor es una copia del valor de tipo de valor asignado a la variable i. La diferencia entre las dos variables, i y o, se muestra en la imagen siguiente de la conversión boxing:

Gráfico que muestra la diferencia entre las variables i y o.

También es posible realizar la conversión boxing de manera explícita, tal como se muestra en el ejemplo siguiente, pero esta nunca es necesaria:

int i = 123;
object o = (object)i;  // explicit boxing

Ejemplo

En este ejemplo, se convierte una variable i de tipo entero en un objeto o utilizando el proceso de 'boxing'. A continuación, el valor almacenado en la variable i se cambia de 123 a 456. En el ejemplo se muestra que el tipo de valor original y el objeto boxed usan ubicaciones de memoria independientes y, por tanto, pueden almacenar valores diferentes.

        // Create an int variable
        int i = 123;
        
        // Box the value type into an object reference
        object o = i;  // boxing
        
        // Display the initial values
        Console.WriteLine($"Value of i: {i}");
        Console.WriteLine($"Value of boxed object o: {o}");
        
        // Modify the original value type
        i = 456;
        
        // Display the values after modification
        Console.WriteLine("\nAfter changing i to 456:");
        Console.WriteLine($"Value of i: {i}");
        Console.WriteLine($"Value of boxed object o: {o}");
        
        // Output:
        // Value of i: 123
        // Value of boxed object o: 123

        // After changing i to 456:
        // Value of i: 456
        // Value of boxed object o: 123

Desempaquetado

Unboxing es una conversión explícita del tipo object a un tipo de valor o de un tipo de interfaz a un tipo de valor que implementa la interfaz. Una operación de unboxing consta de:

  • Verifique la instancia de objeto para asegurarse de que es un valor encapsulado del tipo de valor especificado.

  • Copiando el valor de la instancia a una variable de tipo valor.

Las siguientes instrucciones muestran las operaciones de conversión boxing y unboxing:

int i = 123;      // a value type
object o = i;     // boxing
int j = (int)o;   // unboxing

En la ilustración siguiente se muestra el resultado de las instrucciones anteriores:

Gráfico que ilustra una conversión durante el desembalaje.

Para que la conversión unboxing de tipos de valor sea correcta en tiempo de ejecución, el elemento al que se aplica debe ser una referencia a un objeto creado previamente mediante la conversión boxing de una instancia de ese tipo de valor. Si se intenta aplicar la conversión unboxing a null, se producirá una excepción NullReferenceException. Si se intenta aplicar la conversión unboxing a una referencia de un tipo de valor incompatible, se producirá una excepción InvalidCastException.

Ejemplo

El ejemplo siguiente muestra un caso de conversión unboxing no válida y la excepción InvalidCastException resultante. Con try y catch, se muestra un mensaje de error cuando se produce el error.

class TestUnboxing
{
    static void Main()
    {
        int i = 123;
        object o = i;  // implicit boxing

        try
        {
            int j = (short)o;  // attempt to unbox

            System.Console.WriteLine("Unboxing OK.");
        }
        catch (System.InvalidCastException e)
        {
            System.Console.WriteLine($"{e.Message} Error: Incorrect unboxing.");
        }
    }
}

Este programa genera:

Specified cast is not valid. Error: Incorrect unboxing.

Si cambia la instrucción:

int j = (short)o;

para:

int j = (int)o;

La conversión se realizará y obtendrá la salida:

Unboxing OK.

Especificación del lenguaje C#

Para obtener más información, consulte la Especificación del lenguaje C#. La especificación del lenguaje es el origen definitivo de la sintaxis y el uso de C#.

Consulte también