Cómo Glass reconstruye una struct de interoperabilidad
StructLayout y MarshalAs no se almacenan como atributos personalizados: viven en las tablas de metadatos ClassLayout y FieldMarshal. Así lee Glass.NET esas tablas y reconstruye el contrato de bytes nativo exacto que describe una struct de P/Invoke.
Una struct de P/Invoke lleva un contrato que no está escrito en ninguna parte del C# que ves. [StructLayout(LayoutKind.Sequential, Pack = 1)] y unos pocos atributos [MarshalAs(...)] deciden, byte a byte, qué bloque de memoria entrega el runtime al código nativo. Si la disposición es incorrecta, la llamada igualmente compila, igualmente se ejecuta y corrompe memoria en silencio. Por eso, cuando abres un ensamblado desconocido para entender —o verificar— una frontera de interoperabilidad, lo primero que necesitas recuperar es esa forma nativa exacta.
Y aquí está la sorpresa: esos atributos no están en el ensamblado. No como atributos, al menos.
La verdadera pregunta
Abre cualquier descompilador sobre una struct decorada con [MarshalAs] y te mostrará los atributos de vuelta. Parece trivial: leer el atributo personalizado, imprimirlo. Pero el CLR nunca almacenó un atributo personalizado. StructLayoutAttribute, MarshalAsAttribute, FieldOffsetAttribute y un puñado más son atributos pseudopersonalizados: el compilador los lee en tiempo de compilación, los borra y escribe su significado en tablas de metadatos dedicadas. No hay ningún blob en la tabla CustomAttribute que imprimir.
Así que la verdadera pregunta es: si el atributo desapareció, ¿cómo lo vuelve a poner Glass —correctamente, con el SizeConst adecuado, el UnmanagedType adecuado, el ancho de carácter adecuado? La respuesta es un pequeño mapeo inverso exacto desde dos tablas de metadatos, y vale la pena entenderlo porque es también lo que te dice el verdadero contrato nativo.
Una struct con una forma nativa real
Tomemos una struct que refleja una DeviceInfo de C devuelta por una API de enumeración de dispositivos de la que tienes las cabeceras:
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
public struct DeviceInfo
{
public uint Size;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
public string Name;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
public byte[] MacAddress;
[MarshalAs(UnmanagedType.I1)]
public bool IsOnline;
}
El contrato nativo que esto describe es preciso:
#pragma pack(1)
struct DeviceInfo {
uint32_t Size; // 4 bytes
wchar_t Name[32]; // 32 * 2 = 64 bytes (CharSet.Unicode)
uint8_t MacAddress[6]; // 6 bytes, en línea
int8_t IsOnline; // 1 byte (I1), no el BOOL por defecto de 4 bytes
}; // Pack = 1 -> sin relleno -> 75 bytes en total
Cada número de ahí procede de los atributos. ByValTStr convierte Name en un búfer fijo en línea de 32 caracteres en lugar de un puntero a una cadena; CharSet.Unicode hace que cada carácter ocupe 2 bytes; ByValArray incorpora en línea 6 bytes donde el valor por defecto marshalearía byte[] como un puntero; y [MarshalAs(I1)] reduce bool de su valor por defecto de 4 bytes en Win32 a un solo byte. Si pierdes cualquiera de esos, la struct tiene otro tamaño y los campos caen en otros desplazamientos.
Dónde lo puso realmente el compilador
Compila eso y mira los metadatos, no el IL. Cambiaron tres cosas, ninguna de ellas un atributo personalizado.
1. Las marcas del TypeDef. LayoutKind.Sequential activa tdSequentialLayout; CharSet.Unicode activa tdUnicodeClass. La cabecera de la clase las lleva directamente:
.class public sequential unicode sealed beforefieldinit DeviceInfo
extends [System.Runtime]System.ValueType
{
.pack 1
.size 0
2. La tabla ClassLayout (0x0F). El Pack y cualquier tamaño explícito viven aquí, una fila ligada al TypeDef:
ClassLayout
Parent PackingSize ClassSize
DeviceInfo 1 0
PackingSize = 1 es el Pack = 1. ClassSize = 0 significa «calcúlalo a partir de los campos»: el runtime los suma bajo la regla de empaquetado.
3. La tabla FieldMarshal (0x0D). Aquí está el núcleo. Cada [MarshalAs] se convierte en una fila: un Parent (un índice codificado que apunta al campo) y un NativeType (un índice al heap de blobs). El blob es un descriptor de marshalling: un pequeño guion de bytes en la codificación NATIVE_TYPE_* de ECMA-335:
FieldMarshal
Parent (campo) NativeType blob
Name 17 20 ; FIXEDSYSSTRING(0x17), SizeConst = 0x20 (32)
MacAddress 1e 06 04 ; FIXEDARRAY(0x1e), conteo = 6, elemento U1(0x04)
IsOnline 03 ; I1(0x03)
Esos bytes son todo el contrato. 0x17 es NATIVE_TYPE_FIXEDSYSSTRING (lo que C# escribe como ByValTStr) y el 0x20 que le sigue es el conteo de elementos comprimido. 0x1e es NATIVE_TYPE_FIXEDARRAY, seguido del conteo y del tipo nativo del elemento. 0x03 es NATIVE_TYPE_I1. No hay fila de FieldMarshal para los campos que no tienen atributo: Size simplemente no aparece en la tabla, y eso ya es información: sin fila significa marshalling por defecto.
El mapeo inverso, paso a paso
Glass recorre las tres fuentes y compone un conjunto de atributos por campo y uno por tipo.
Para el tipo, lee el bit de disposición de las marcas del TypeDef (tdSequentialLayout → LayoutKind.Sequential, tdExplicitLayout → Explicit, ninguno → Auto) y los bits de charset (tdUnicodeClass → CharSet.Unicode, tdAnsiClass → Ansi, tdAutoClass → Auto). Une la fila de ClassLayout para extraer Pack y, si no es cero, Size. Eso se convierte en los argumentos de [StructLayout(...)].
Para cada campo, busca una fila de FieldMarshal cuyo Parent resuelva a ese campo. Si no hay ninguna, el campo se marshalea por defecto y no recibe atributo. Si hay una, Glass decodifica el blob: el primer byte es el UnmanagedType y, según cuál sea, le siguen cero o más operandos. 0x17 (ByValTStr) toma un conteo → SizeConst. 0x1e (ByValArray) toma un conteo y un tipo nativo de elemento → SizeConst más, cuando el tipo de elemento no es el valor por defecto obvio, ArraySubType. Los escalares como 0x03 (I1) no toman nada. El resultado decodificado se emite como [MarshalAs(UnmanagedType.X, ...)].
La recompensa es que la struct recuperada no es una conjetura. La cifra de 75 bytes, los caracteres de 2 bytes, el bool de un solo byte: todo ello se reconstruye a partir de bytes que el compilador consignó, así que Glass puede mostrar el tamaño nativo junto al tipo. Ese número es justo lo que buscabas cuando compruebas una frontera de interoperabilidad contra una cabecera de C.
Cuándo la recuperación es parcial
Los límites honestos tienen que ver todos con información que los metadatos genuinamente no conservan.
- Los nombres de los campos en una disposición sequential o explicit no son determinantes para el marshalling, pero siguen siendo nombres de campo reales y sobreviven. Lo que no sobrevive es lo que el atributo calculó en vez de almacenar. Las structs con
LayoutKind.Autono llevanClassLayoutni garantía de orden de campos, así que no hay nada que recuperar más allá de la marca. - Los arrays de longitud variable pierden su tamaño literal.
UnmanagedType.LPArraycon unSizeParamIndexcodifica un índice de parámetro en el blob, no una constante, así que Glass recuperaSizeParamIndex = n, que es exactamente lo que había, pero no haySizeConstque mostrar. - El marshalling por defecto es invisible por diseño. Un
byte[]sin[MarshalAs]se marshalea como un puntero. Glass, correctamente, no emite ningún atributo, pero un lector que espera un búfer en línea tiene que saber que la ausencia de fila significa «puntero, no en línea». Eso es una propiedad de la plataforma, no una carencia del descompilador. [StructLayout]conCharSet.Autosignifica que el ancho nativo de los campos string depende del SO en el que se ejecute el código. Glass solo puede mostrarAuto; no puede decirte a qué ancho lo resolvió un despliegue concreto.
Conclusión
Los atributos que definen un contrato de interoperabilidad se compilan hacia fuera: StructLayout en marcas del TypeDef y una fila de ClassLayout, cada MarshalAs en un blob de FieldMarshal. Un descompilador que solo imprima atributos personalizados te mostraría una struct sin nada de esto, lo cual es peor que inútil en una frontera de interoperabilidad. Glass.NET mapea al revés las tablas reales, decodifica los descriptores NATIVE_TYPE_* y reconstruye los atributos exactos y el tamaño nativo en bytes, de modo que lo que lees de vuelta es el contrato que el código nativo realmente ve. Glass es un descompilador .NET gratuito; puedes inspeccionar cualquier ensamblado que tengas derecho a analizar, desde la página del producto Glass.NET o la documentación de CLI y MCP.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.