Conversión boxing y unboxing (Guía de programación de C#)Boxing and Unboxing (C# Programming Guide)

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.Boxing is the process of converting a value type to the type object or to any interface type implemented by this value type. Cuando CLR aplica la conversión boxing a un tipo de valor, ajusta el valor dentro de una instancia System.Objecty lo almacena en el montón administrado.When the CLR boxes a value type, it wraps the value inside a System.Object instance and stores it on the managed heap. La conversión unboxing extrae el tipo de valor del objeto.Unboxing extracts the value type from the object. La conversión boxing es implícita y la conversión unboxing es explícita.Boxing is implicit; unboxing is explicit. 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.The concept of boxing and unboxing underlies the C# unified view of the type system in which a value of any type can be treated as an object.

En el ejemplo siguiente, se aplica conversión boxing a la variable de entero i y esta se asigna al objeto o.In the following example, the integer variable i is boxed and assigned to object o.

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

Luego se puede aplicar conversión unboxing al objeto o y asignarlo a la variable de entero i:The object o can then be unboxed and assigned to integer variable i:

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

En los ejemplos siguientes se muestra cómo usar la conversión boxing en C#.The following examples illustrate how boxing is used in 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

RendimientoPerformance

Con relación a las asignaciones simples, las conversiones boxing y unboxing son procesos que consumen muchos recursos.In relation to simple assignments, boxing and unboxing are computationally expensive processes. Cuando se aplica la conversión boxing a un tipo de valor, se debe asignar y construir un objeto completamente nuevo.When a value type is boxed, a new object must be allocated and constructed. En menor grado, la conversión de tipos requerida para aplicar la conversión unboxing también es costosa.To a lesser degree, the cast required for unboxing is also expensive computationally. Para más información, vea Rendimiento.For more information, see Performance.

BoxingBoxing

La conversión boxing se utiliza para almacenar tipos de valor en el montón de recolección de elementos no utilizados.Boxing is used to store value types in the garbage-collected heap. La conversión boxing es una conversión implícita de un tipo de valor en el tipo object o en cualquier tipo de interfaz implementado por este tipo de valor.Boxing is an implicit conversion of a value type to the type object or to any interface type implemented by this value type. 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.Boxing a value type allocates an object instance on the heap and copies the value into the new object.

Considere la siguiente declaración de una variable de tipo de valor:Consider the following declaration of a value-type variable:

int i = 123;

La siguiente instrucción aplica implícitamente la operación de conversión boxing en la variable i:The following statement implicitly applies the boxing operation on the 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.The result of this statement is creating an object reference o, on the stack, that references a value of the type int, on the heap. Este valor es una copia del tipo de valor asignado a la variable i.This value is a copy of the value-type value assigned to the variable i. La diferencia entre las dos variables, i y o, se muestra en la imagen siguiente de la conversión boxing:The difference between the two variables, i and o, is illustrated in the following image of boxing conversion:

Gráfico en el que se 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:It is also possible to perform the boxing explicitly as in the following example, but explicit boxing is never required:

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

DESCRIPCIÓNDescription

Este ejemplo convierte una variable de entero i en un objeto o mediante la conversión boxing.This example converts an integer variable i to an object o by using boxing. A continuación, el valor almacenado en la variable i se cambia de 123 a 456.Then, the value stored in the variable i is changed from 123 to 456. El ejemplo muestra que el tipo de valor original y el objeto al que se ha aplicado la conversión boxing usan ubicaciones de memoria independientes y, por consiguiente, pueden almacenar valores diferentes.The example shows that the original value type and the boxed object use separate memory locations, and therefore can store different values.

EjemploExample

class TestBoxing
{
    static void Main()
    {
        int i = 123;

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

        // Change the value of i.
        i = 456;  

        // The change in i doesn't affect the value stored in o.
        System.Console.WriteLine("The value-type value = {0}", i);
        System.Console.WriteLine("The object-type value = {0}", o);
    }
}
/* Output:
    The value-type value = 456
    The object-type value = 123
*/

Conversión unboxingUnboxing

La conversión unboxing es una conversión explícita del tipo object en un tipo de valor o de un tipo de interfaz en un tipo de valor que implementa la interfaz.Unboxing is an explicit conversion from the type object to a value type or from an interface type to a value type that implements the interface. Una operación de conversión unboxing consiste en lo siguiente:An unboxing operation consists of:

  • Comprobar la instancia de objeto para asegurarse de que se trata de un valor de conversión boxing del tipo de valor dado.Checking the object instance to make sure that it is a boxed value of the given value type.

  • Copiar el valor de la instancia en la variable de tipo de valor.Copying the value from the instance into the value-type variable.

Las siguientes instrucciones muestran las operaciones de conversión boxing y unboxing:The following statements demonstrate both boxing and unboxing operations:

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

En la figura siguiente se muestra el resultado de las instrucciones anteriores:The following figure demonstrates the result of the previous statements:

Gráfico en el que se muestra una conversión unboxing.

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.For the unboxing of value types to succeed at run time, the item being unboxed must be a reference to an object that was previously created by boxing an instance of that value type. Si se intenta aplicar la conversión unboxing a null, se producirá una excepción NullReferenceException.Attempting to unbox null causes a NullReferenceException. Si se intenta aplicar la conversión unboxing a una referencia de un tipo de valor incompatible, se producirá una excepción InvalidCastException.Attempting to unbox a reference to an incompatible value type causes an InvalidCastException.

EjemploExample

El ejemplo siguiente muestra un caso de conversión unboxing no válida y la excepción InvalidCastException resultante.The following example demonstrates a case of invalid unboxing and the resulting InvalidCastException. Si se utiliza try y catch, se muestra un mensaje de error cuando se produce el error.Using try and catch, an error message is displayed when the error occurs.

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("{0} Error: Incorrect unboxing.", e.Message);
        }
    }
}

Este programa produce el resultado siguiente:This program outputs:

Specified cast is not valid. Error: Incorrect unboxing.

Si cambia la instrucción:If you change the statement:

int j = (short) o;  

a:to:

int j = (int) o;  

la conversión se realizará y se obtendrá el resultado:the conversion will be performed, and you will get the output:

Unboxing OK.

Especificación del lenguaje C#C# Language Specification

Para obtener más información, consulte la Especificación del lenguaje C#.For more information, see the C# Language Specification. La especificación del lenguaje es la fuente definitiva de la sintaxis y el uso de C#.The language specification is the definitive source for C# syntax and usage.

Para obtener más información:For more information:

Vea tambiénSee also