Cómo se decompilan el boxing y el unboxing en C#
Una conversión implícita de int a object es invisible en C#, pero asigna en el heap, y el IL lo deja claro con un opcode box. Esto recorre de dónde salen box, unbox.any y el prefijo constrained., por qué el código genérico usa constrained. para esquivar una asignación por boxing, y cómo Glass.NET reconstruye C# legible mientras el IL revela la asignación que el código fuente oculta.
Una conversión implícita de int a object es una de las cosas caras más silenciosas de C#. Escribes object o = n; (sin cast, sin ceremonia) y ocurre una asignación en el heap. El C# no dice nada de ella. El IL lo dice todo, en un único opcode: box. El boxing, su inverso unbox.any y el prefijo constrained. que el código genérico usa para evitar el boxing son una pequeña familia de instrucciones que, juntas, explican de dónde salen las asignaciones ocultas en .NET. También son una buena ilustración del trabajo de un decompilador: Glass.NET te devuelve el C# legible que escribió el autor, y la vista de IL te devuelve la asignación que el autor nunca tecleó.
Glass.NET es un decompilador y explorador de ensamblados de .NET gratuito, construido sobre el motor de ILSpy. Todo lo de abajo es análisis estático: lee los metadatos y los cuerpos de los métodos de un ensamblado que ya tienes; nunca carga ni ejecuta el objetivo.
El opcode box
Empecemos con la conversión por boxing más simple posible:
public static object Wrap(int n) => n;
El tipo de retorno es object y el argumento es int, así que tiene que ocurrir una conversión. En el IL es explícita:
ldarg.0
box [System.Runtime]System.Int32
ret
box saca el int, asigna un Int32 encajonado en el heap administrado y empuja la referencia. Esa es toda la historia del boxing: un tipo por valor se copia dentro de un objeto recién asignado para que un hueco de tipo por referencia pueda contenerlo. El mismo opcode aparece para una conversión a una interfaz que el valor implementa, a System.ValueType, a System.Enum o a dynamic: en cualquier sitio donde un valor necesite volverse una referencia.
Glass.NET decompila Wrap de vuelta a return n;, que es exactamente el código fuente. La asignación no es visible en esa línea porque tampoco lo era nunca en la línea original. Cambia el mismo método a la vista de IL y ahí está el box Int32: la única instrucción que convierte un retorno inocuo en una asignación.
El unboxing es un cast
La dirección inversa es un cast de object de vuelta a un tipo por valor:
public static int Unwrap(object o) => (int)o;
ldarg.0
unbox.any [System.Runtime]System.Int32
ret
unbox.any es la forma moderna y cómoda: extrae el valor int de la caja y lo deja en la pila, lanzando InvalidCastException si o no es realmente un Int32 encajonado. Es equivalente al par más antiguo unbox (que produce un puntero administrado dentro de la caja sin copiar) seguido de ldobj (que lee el valor a través de ese puntero). Lo que verás casi siempre en la salida decompilada es unbox.any, porque el cast de C# (int)o encaja directamente con él; el unbox pelado aparece cuando el código fuente tomó la dirección de un valor encajonado o lo mutó in situ. Un decompilador que lee unbox.any Int32 lo convierte de vuelta en el cast (int) del que vino.
Dónde se esconde el boxing: string.Format
Las conversiones anteriores son visibles porque los tipos difieren por una línea. El boxing se pone interesante cuando queda enterrado dentro de una llamada a una biblioteca. Un caso clásico es una cadena de formato compuesta:
public static string Line(int id, bool ok) =>
string.Format("{0}:{1}", id, ok);
Aquí string.Format se enlaza con la sobrecarga Format(string, object[]), así que cada uno de los dos argumentos por valor debe volverse un object. El IL construye el array y encajona a medida que lo rellena:
ldstr "{0}:{1}"
ldc.i4.2
newarr [System.Runtime]System.Object
dup
ldc.i4.0
ldarg.0
box [System.Runtime]System.Int32 // id
stelem.ref
dup
ldc.i4.1
ldarg.1
box [System.Runtime]System.Boolean // ok
stelem.ref
call string [System.Runtime]System.String::Format(string, object[])
ret
Una asignación de array más dos boxings para una sola llamada de formato. El C# decompilado es el limpio one-liner que escribiste; el coste está en el newarr y en los dos opcodes box de debajo. Verlo suele ser el primer paso para entender por qué una ruta de logging caliente asigna más de lo que parece.
El famoso: Enum.HasFlag
Enum.HasFlag es la sorpresa canónica. Su firma recibe un System.Enum, que es un tipo por referencia, así que llamarlo sobre un enum por valor encajona, dos veces:
[Flags] enum Access { Read = 1, Write = 2 }
public static bool CanWrite(Access a) => a.HasFlag(Access.Write);
ldarg.0
box Access
ldc.i4.2
box Access
call instance bool [System.Runtime]System.Enum::HasFlag(class [System.Runtime]System.Enum)
ret
El receptor a se encajona, y el argumento Access.Write se encajona. El código fuente decompilado es el pulcro a.HasFlag(Access.Write); el IL es donde las dos asignaciones se anuncian solas. (Esto es exactamente por qué el consejo habitual es escribir (a & Access.Write) != 0 en código caliente; y si decompilas esa versión, los opcodes box simplemente desaparecen, sustituidos por un and y una comparación.)
El prefijo constrained.: boxing que puedes evitar
El código genérico se enfrenta a un dilema. Considera:
public static string Describe<T>(T value) => value.ToString();
En tiempo de compilación el compilador no sabe si T será un struct o una class. Si siempre encajonara value para llamar a object.ToString(), cada struct asignaría. Si nunca encajonara, los tipos por referencia se romperían. La respuesta del CLR es el prefijo constrained., que aplaza la decisión al JIT:
.method public static string Describe<T>(!!T value)
{
ldarga.s value // la dirección del valor, no una copia
constrained. !!T
callvirt instance string [System.Runtime]System.Object::ToString()
ret
}
Fíjate en ldarga: carga la dirección del argumento, un puntero administrado, en lugar del valor. El prefijo constrained. !!T le dice entonces al JIT cómo despachar a través de ese puntero una vez que se conoce T:
Así, Describe(new DateTime()) llama a DateTime.ToString() directamente sin asignación, porque DateTime sobrescribe ToString. Describe(someCustomStruct) que no sobrescribe ToString encajona una vez y llama a object.ToString(). Describe("hello") desreferencia el puntero y hace una llamada virtual ordinaria. Un mismo cuerpo de método IL, tres comportamientos elegidos por el JIT, y toda la razón de ser del prefijo es mantener el primer caso libre de asignaciones.
Glass.NET reconstruye los tres casos como el mismo value.ToString(), porque eso es el código fuente. Lo que añade la vista de IL es el propio prefijo constrained. !!T, que es tu señal de que el sitio de llamada es genérico y de que si asigna o no depende enteramente del T concreto. Es una distinción que no puedes leer en absoluto a partir del C#.
Por qué las dos vistas importan juntas
El patrón a lo largo de los cuatro ejemplos es el mismo. El C# decompilado es fiel a lo que escribió el autor: return n;, string.Format(...), a.HasFlag(...), value.ToString(). Ninguna de esas líneas menciona una asignación, porque el lenguaje está diseñado para hacer implícitas las conversiones. Las asignaciones viven una capa más abajo, en box, en la secuencia newarr/stelem.ref/box, y en el despacho que constrained. resuelve. Un decompilador que solo te mostrara el C# estaría ocultando exactamente lo que cuesta una conversión de tipo por valor.
Por eso leer las dos vistas una al lado de la otra es el hábito útil. Glass.NET reconstruye la forma para que el código sea legible; la vista de IL mantiene los opcodes tal cual para que las asignaciones sean contables. Ambas son lecturas estáticas del mismo ensamblado (sin ejecución, sin instrumentar nada), lo que hace de esto una forma segura de auditar código compilado propio o de terceros en busca de boxing que no pretendías.
Conclusión
El boxing es invisible en C# por diseño y explícito en IL por necesidad. box marca cada conversión de valor a referencia, unbox.any marca el cast de vuelta, y el prefijo constrained. es el mecanismo que permite al código genérico esquivar una asignación por boxing cuando el tipo concreto lo permite. Cuando un método decompilado parece libre de asignaciones pero tu profiler discrepa, abre la vista de IL en Glass.NET y cuenta los opcodes box: el código fuente los ocultó, pero el IL nunca pudo.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.