Cómo se descompila el P/Invoke generado por fuente
Los métodos [DllImport] clásicos no tienen cuerpo gestionado, así que un descompilador los reconstruye desde la tabla ImplMap. Un método [LibraryImport] es lo contrario: el stub de marshalling es C# compilado real, y Glass lo muestra entero.
Descompila un método marcado con [DllImport] y no recuperas casi nada: una firma extern, un atributo reconstruido y ningún cuerpo. Descompila un método marcado con [LibraryImport] y obtienes una página de C# real: bloques fixed, conversiones de punteros, una llamada anidada. La misma llamada nativa, resultados descompilados radicalmente distintos. La razón es dónde reside el código de marshalling, y vale la pena entenderla, porque cambia lo que puedes aprender de un ensamblado al leerlo.
La verdadera pregunta
Ambos atributos describen lo mismo: un método gestionado que en realidad es una llamada a través de la frontera nativa. Entonces, ¿por qué uno sobrevive a la descompilación como un cascarón vacío y el otro como un método totalmente legible? La respuesta es que el [DllImport] clásico delega todo el marshalling al CLR en tiempo de ejecución, mientras que [LibraryImport] —el generador de fuente introducido en .NET 7— escribe el marshalling como C# en tiempo de compilación. Uno deja el stub en el runtime; el otro lo hornea dentro de tu ensamblado.
DllImport clásico: un método sin cuerpo
Empecemos con el estilo antiguo:
[DllImport("user32.dll", EntryPoint = "MessageBoxW",
CharSet = CharSet.Unicode, ExactSpelling = true)]
internal static extern int MessageBox(IntPtr hWnd, string lpText, string lpCaption, uint uType);
En los metadatos este método es inusual. Su fila MethodDef lleva la bandera pinvokeimpl y no tiene CIL. Los datos de la declaración viven en una tabla de metadatos aparte, ImplMap, que enlaza el método con un ModuleRef (user32.dll), el nombre de importación (MessageBoxW) y un conjunto de banderas que codifican el charset, la convención de llamada y SetLastError. Al abrirlo en Glass, la vista de IL muestra un método vacío y el descompilador reconstruye el atributo a partir de la fila ImplMap:
// descompilado — el cuerpo realmente no está aquí
[DllImport("user32.dll", EntryPoint = "MessageBoxW", ExactSpelling = true)]
internal static extern int MessageBox(IntPtr hWnd, string lpText, string lpCaption, uint uType);
Entonces, ¿dónde está el código que convierte un string en un char* y lo empuja a la pila nativa? No existe en el ensamblado. El CLR construye un stub de marshalling la primera vez que se llama al método, guiado por las banderas de ImplMap y por la firma. Ese stub se compila con el JIT en memoria y se descarta cuando el proceso termina. Un descompilador nunca puede mostrarlo, porque nunca estuvo en disco.
LibraryImport: el stub se vuelve C#
Ahora la forma generada por fuente. El método es partial y el atributo vive en una declaración sin cuerpo:
[LibraryImport("user32.dll", EntryPoint = "MessageBoxW",
StringMarshalling = StringMarshalling.Utf16)]
internal static partial int MessageBox(IntPtr hWnd, string lpText, string lpCaption, uint uType);
En tiempo de compilación, el LibraryImportGenerator aporta la otra mitad del método parcial. Es C# corriente, y es lo que acaba en tu ensamblado:
internal static unsafe partial int MessageBox(IntPtr hWnd, string lpText, string lpCaption, uint uType)
{
int __retVal;
fixed (char* __lpText_native = lpText)
fixed (char* __lpCaption_native = lpCaption)
{
__retVal = __PInvoke(hWnd, (ushort*)__lpText_native, (ushort*)__lpCaption_native, uType);
}
return __retVal;
// el verdadero cruce de frontera — una función local
[DllImport("user32.dll", EntryPoint = "MessageBoxW", ExactSpelling = true)]
static extern int __PInvoke(IntPtr hWnd, ushort* lpText, ushort* lpCaption, uint uType);
}
Lee lo que hizo el generador. Como StringMarshalling.Utf16 coincide con la disposición UTF-16 del string del CLR, no hace falta ninguna copia: las dos cadenas se fijan con fixed, sus punteros se reinterpretan como ushort* y se pasan directamente. La llamada nativa real es una función local static extern anidada —todavía un [DllImport] clásico, pero ahora un detalle de implementación privado y nombrado por el compilador—. El método público es puro pegamento de marshalling visible.
Lo que Glass muestra realmente
La función local [DllImport] anidada no conserva un nombre amistoso en el ensamblado compilado. C# reduce las funciones locales a métodos privados estáticos con un nombre mangled, así que en los metadatos verás algo como <MessageBox>g__PInvoke|0_0. Al abrir el ensamblado en Glass, el descompilador reconoce el mangling y lo vuelve a representar como una función local dentro de MessageBox, cercana a la fuente generada de arriba. Cambia a la vista de IL y podrás confirmar la separación directamente:
.method assembly hidebysig static int32 MessageBox (...) cil managed
{
// IL real: ldarg, conv, el patrón de fixed-pin, call a __PInvoke
}
.method assembly hidebysig static pinvokeimpl("user32.dll" ...) int32 '<MessageBox>g__PInvoke|0_0' (...) cil managed { }
Solo el segundo método lleva pinvokeimpl. Ese es el único cruce de frontera verdadero. Todo lo demás —el pinning, la conversión de punteros, el manejo del retorno— es código que escribió el generador y que ahora puedes leer. Para un parámetro de cadena UTF-8 el stub sería más largo: reserva un búfer nativo, llama al marshaller de UTF-8 para transcodificar, usa el búfer y luego lo libera en un finally. Todo eso, también, es descompilable, porque todo eso es IL real.
Por qué esto importa al leer un ensamblado
Esto no es una curiosidad: cambia qué interop puedes auditar por inspección. Con una superficie [DllImport] clásica, leer el ensamblado te dice el punto de entrada y la firma declarada, y nada sobre cómo se hace realmente el marshalling de los argumentos; la verdad está en las reglas de tiempo de ejecución del CLR. Con [LibraryImport], el marshalling está justo ahí. Puedes ver exactamente qué búferes se fijan, dónde una transcodificación reserva memoria, si un bool se hace marshalling como un int de 4 bytes o como un valor de 1 byte, y cuándo se libera la memoria. Para revisar una capa de interop que tienes derecho a inspeccionar —tu propia compilación, una dependencia que estás evaluando, un fallo que estás depurando— la forma generada por fuente es mucho más transparente.
También te dice algo sobre la procedencia. Una biblioteca que usa [LibraryImport] se compiló para .NET 7 o posterior con el generador habilitado, y es compatible con AOT por diseño, precisamente porque el stub es código estático en lugar de IL generado en tiempo de ejecución. Ver los métodos g__PInvoke en Glass es una señal rápida de una capa de interop moderna, lista para trimming y AOT.
Advertencias
El stub descompilado es C# fiel, pero es el C# del generador, no el tuyo: no esperes que coincida con el marshalling escrito a mano que podrías hacer para la misma llamada. Los nombres de las funciones locales generadas (g__PInvoke|0_0) son artefactos del compilador y pueden cambiar entre versiones del compilador, así que no los trates como una API estable. Y el método anidado sigue siendo un [DllImport] real: el salto final al código nativo es tan opaco como siempre; Glass te muestra el marshalling gestionado, no la función nativa en la que aterriza. Si el ensamblado incluye un PDB, Glass también puede recuperar los nombres originales de los argumentos y hacer el stub aún más fácil de seguir; consulta recuperar nombres desde un PDB.
En resumen
[DllImport] oculta su marshalling en el runtime; [LibraryImport] lo escribe dentro de tu ensamblado. Esa única diferencia es por qué uno se descompila en un cascarón vacío y el otro en un stub legible. Cuando necesites entender cómo una llamada de interop mueve realmente sus argumentos a través de la frontera, ábrela en Glass.NET —y ojalá se haya compilado con el generador—. Glass es un descompilador .NET gratuito y abierto, con una interfaz nativa de VS, una CLI y un servidor MCP.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.