Boxeo y desembalaje: ¿cuándo aparece?

Question

Así que entiendo lo que es boxeo y unboxing. ¿Cuándo aparece en el código del mundo real, o en qué ejemplos es un problema? No me puedo imaginar haciendo algo como este ejemplo:

int i = 123; 
object o = i;   // Boxing 
int j = (int)o;  // Unboxing 

... pero eso es casi seguro que muy simplificada y que podría haber hecho, incluso el boxeo/unboxing sin saberlo antes.

Answer 1

Es mucho menos de un problema ahora de lo que era antes de los genéricos. Ahora, por ejemplo, podemos usar:

List<int> x = new List<int>(); 
x.Add(10); 
int y = x[0]; 

No requiere boxeo ni desempaquetado.

Anteriormente, nos hemos tenido:

ArrayList x = new ArrayList(); 
x.Add(10); // Boxing 
int y = (int) x[0]; // Unboxing 

Esa era mi experiencia más común de boxeo y unboxing, por lo menos.

Sin la participación de los genéricos, creo que probablemente diría que la reflexión es la causa más común del boxeo en los proyectos en los que he trabajado. Las API de reflexión siempre usan "objeto" para cosas como el valor de retorno de un método, porque no tienen otra manera de saber qué usar.

Otra causa que podría atraparlo si no lo sabe es si usa un tipo de valor que implementa una interfaz, y pasa ese valor a otro método que tiene el tipo de interfaz como su parámetro. Una vez más, los genéricos hacen de este un problema menor, pero puede ser una sorpresa desagradable si no eres consciente de ello.

Answer 2

Boxeo (en mi experiencia) por lo general se produce en estos casos:

• un tipo de valor se pasa a un método que acepta un argumento de tipo Object.
• Se agrega un tipo de valor a una colección no genérica (como un ArrayList).

Otras veces puede ver el boxeo y el desempaquetado es cuando utiliza la reflexión como la API de reflexión de .NET Framework hace un uso intensivo de Object.

Answer 3

El boxeo y el desempaquetado se está moviendo realmente del tipo de valor al tipo de referencia. Por lo tanto, piense en ello como pasar de la pila al montón y viceversa.

Ciertamente hay casos donde esto es relevante. La inclusión de genéricos en el marco 2.0 cortó muchos casos comunes de boxeo fuera de la práctica.

Answer 4

Desde el advenimiento de listas fuertemente tipadas y diccionarios utilizando genéricos con C# 2.0 (Visual Studio 2005), creo que la importancia de mantener el boxeo/unboxing en cuenta se ha minimizado de forma asombrosa. Agregue a los tipos anulables (int?, etc.) y utilizando el operador coalescente nulo (??) y realmente no debería ser una gran preocupación y probablemente no lo vea en ningún código que no sea 1.1 Framework o anterior.

Answer 5

El boxeo/unboxing se produce cuando se pasa un tipo de valor (como una estructura, int, largo) en algún lugar que acepta un tipo de referencia, como object.

Esto ocurre cuando se crea explícitamente un método que toma parámetros de tipo objeto que se pasarán tipos de valores. También aparece cuando utiliza las colecciones antiguas no genéricas para almacenar tipos de valores (típicamente primitivos).

También verá el boxeo cuando usa String.Format() y le transfiere las primitivas. Esto se debe a que String.Format() acepta un objeto params [], lo que da como resultado el encajamiento de los parámetros adicionales en la llamada.

El uso de la reflexión para invocar métodos también puede dar como resultado boxing/unboxing, porque las API de reflexión no tienen otra opción que devolver object ya que el tipo real no se conoce en tiempo de compilación (y las Reflection API no pueden ser genéricas).

Las colecciones genéricas más nuevas no dan como resultado el boxeo/unboxing, por lo que son preferibles a las colecciones más antiguas por este motivo (por ejemplo, ArrayList, Hashtable, etc.). Sin mencionar que son seguros de tipo.

Puede evitar las preocupaciones del boxeo cambiando los métodos que aceptan objetos para ser genéricos. Por ejemplo:

public void string Decorate(object a) // passing a value type results in boxing 
{ 
    return a.ToString() + " Some other value"; 
} 

vs:

public void string Decorate<T>(T a) 
{ 
    return a.ToString() + " some other value"; 
} 

Answer 6

Sucede todo el tiempo en que la gente no sabe cuáles son las implicaciones, simplemente no les importa o, a veces uno no puede dejar de aceptar el boxeo como el menor Evel.

Los datarows fuertemente tipeados encajonarán/desempaquetarán prácticamente todo el tiempo cuando acceda a una propiedad de tipo valor. Además, al usar un tipo de valor como referencia de interfaz también se incluirá en la caja. O obtener un delegado de un método de instancia de un tipo de valor. (Objetivo del delegado es de tipo Object)

Answer 7

Aquí es una realidad desagradable una :)

SqlCommand cmd = <a command that returns a scalar value stored as int>; 

// This code works very well. 
int result = (int)cmd.ExecuteScalar(); 

// This code will throw an exception. 
uint result = (uint)cmd.ExecuteScalar(); 

La segunda ejecutar falla porque se trata de desempacar un Int32 en un UInt32 que no es posible. Entonces debes primero desempaquetar y luego lanzar.

uint result = (uint)(int)cmd.ExecuteScalar();