Comment Glass reconstruit une struct d'interop native
StructLayout et MarshalAs ne sont pas stockés comme des attributs personnalisés : ils vivent dans les tables de métadonnées ClassLayout et FieldMarshal. Voici comment Glass.NET lit ces tables et reconstruit le contrat d'octets natif exact que décrit une struct P/Invoke.
Une struct P/Invoke porte un contrat qui n’est écrit nulle part dans le C# que vous voyez. [StructLayout(LayoutKind.Sequential, Pack = 1)] et quelques attributs [MarshalAs(...)] décident, à l’octet près, quel bloc de mémoire le runtime remet au code natif. Si la disposition est fausse, l’appel compile quand même, s’exécute quand même et corrompt la mémoire en silence. Alors quand vous ouvrez un assembly inconnu pour comprendre — ou vérifier — une frontière d’interop, la première chose dont vous avez besoin est cette forme native exacte.
Et voici la surprise : ces attributs ne sont pas dans l’assembly. Pas en tant qu’attributs, en tout cas.
La vraie question
Ouvrez n’importe quel décompilateur sur une struct décorée de [MarshalAs] et il vous renverra les attributs. Cela paraît trivial : lire l’attribut personnalisé, l’imprimer. Mais le CLR n’a jamais stocké d’attribut personnalisé. StructLayoutAttribute, MarshalAsAttribute, FieldOffsetAttribute et quelques autres sont des attributs pseudo-personnalisés : le compilateur les lit à la compilation, les supprime et écrit leur sens dans des tables de métadonnées dédiées. Il n’y a aucun blob dans la table CustomAttribute à imprimer.
La vraie question est donc : si l’attribut a disparu, comment Glass le remet-il — correctement, avec le bon SizeConst, le bon UnmanagedType, la bonne largeur de caractère ? La réponse est un petit mappage inverse exact depuis deux tables de métadonnées, et il vaut la peine de le comprendre car c’est aussi ce qui vous indique le vrai contrat natif.
Une struct avec une forme native réelle
Prenons une struct qui reflète une DeviceInfo C renvoyée par une API d’énumération de périphériques dont vous avez les en-têtes :
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;
}
Le contrat natif que cela décrit est précis :
#pragma pack(1)
struct DeviceInfo {
uint32_t Size; // 4 octets
wchar_t Name[32]; // 32 * 2 = 64 octets (CharSet.Unicode)
uint8_t MacAddress[6]; // 6 octets, en ligne
int8_t IsOnline; // 1 octet (I1), pas le BOOL par défaut de 4 octets
}; // Pack = 1 -> aucun remplissage -> 75 octets au total
Chaque nombre vient des attributs. ByValTStr fait de Name un buffer fixe en ligne de 32 caractères plutôt qu’un pointeur vers une chaîne ; CharSet.Unicode fait que chaque caractère occupe 2 octets ; ByValArray incorpore en ligne 6 octets là où le défaut marshalerait byte[] comme un pointeur ; et [MarshalAs(I1)] réduit bool de son défaut Win32 de 4 octets à un seul octet. Perdez l’un d’eux et la struct a une autre taille et les champs tombent à d’autres décalages.
Où le compilateur l’a vraiment mis
Compilez cela et regardez les métadonnées, pas l’IL. Trois choses ont changé, aucune n’étant un attribut personnalisé.
1. Les drapeaux du TypeDef. LayoutKind.Sequential active tdSequentialLayout ; CharSet.Unicode active tdUnicodeClass. L’en-tête de la classe les porte directement :
.class public sequential unicode sealed beforefieldinit DeviceInfo
extends [System.Runtime]System.ValueType
{
.pack 1
.size 0
2. La table ClassLayout (0x0F). Le Pack et toute taille explicite vivent ici, une ligne rattachée au TypeDef :
ClassLayout
Parent PackingSize ClassSize
DeviceInfo 1 0
PackingSize = 1 est le Pack = 1. ClassSize = 0 signifie « calcule-le à partir des champs » : le runtime les additionne selon la règle d’empaquetage.
3. La table FieldMarshal (0x0D). C’est le cœur. Chaque [MarshalAs] devient une ligne : un Parent (un index codé pointant vers le champ) et un NativeType (un index dans le tas de blobs). Le blob est un descripteur de marshalling : un petit script d’octets dans l’encodage NATIVE_TYPE_* d’ECMA-335 :
FieldMarshal
Parent (champ) NativeType blob
Name 17 20 ; FIXEDSYSSTRING(0x17), SizeConst = 0x20 (32)
MacAddress 1e 06 04 ; FIXEDARRAY(0x1e), compte = 6, élément U1(0x04)
IsOnline 03 ; I1(0x03)
Ces octets sont tout le contrat. 0x17 est NATIVE_TYPE_FIXEDSYSSTRING (ce que C# écrit ByValTStr) et le 0x20 qui suit est le compte d’éléments compressé. 0x1e est NATIVE_TYPE_FIXEDARRAY, suivi du compte et du type natif de l’élément. 0x03 est NATIVE_TYPE_I1. Il n’y a pas de ligne FieldMarshal pour les champs sans attribut : Size n’apparaît tout simplement pas dans la table, et c’est déjà une information : pas de ligne signifie marshalling par défaut.
Le mappage inverse, étape par étape
Glass parcourt les trois sources et compose un jeu d’attributs par champ et un par type.
Pour le type, il lit le bit de disposition des drapeaux du TypeDef (tdSequentialLayout → LayoutKind.Sequential, tdExplicitLayout → Explicit, aucun → Auto) et les bits de charset (tdUnicodeClass → CharSet.Unicode, tdAnsiClass → Ansi, tdAutoClass → Auto). Il joint la ligne ClassLayout pour extraire Pack et, s’il est non nul, Size. Cela devient les arguments de [StructLayout(...)].
Pour chaque champ, il cherche une ligne FieldMarshal dont le Parent résout vers ce champ. S’il n’y en a pas, le champ se marshale par défaut et ne reçoit aucun attribut. S’il y en a une, Glass décode le blob : le premier octet est l’UnmanagedType et, selon lequel, zéro opérande ou plus le suivent. 0x17 (ByValTStr) prend un compte → SizeConst. 0x1e (ByValArray) prend un compte et un type natif d’élément → SizeConst plus, lorsque le type d’élément n’est pas le défaut évident, ArraySubType. Les scalaires comme 0x03 (I1) ne prennent rien. Le résultat décodé est émis sous la forme [MarshalAs(UnmanagedType.X, ...)].
La récompense, c’est que la struct récupérée n’est pas une supposition. Les 75 octets, les caractères de 2 octets, le bool d’un seul octet : tout cela est reconstruit à partir d’octets que le compilateur a consignés, donc Glass peut afficher la taille native à côté du type. Ce nombre est exactement ce que vous êtes venu chercher quand vous vérifiez une frontière d’interop face à un en-tête C.
Quand la récupération est partielle
Les limites honnêtes concernent toutes une information que les métadonnées ne conservent véritablement pas.
- Les noms des champs dans une disposition sequential ou explicit ne sont pas déterminants pour le marshalling, mais ce sont toujours de vrais noms de champ et ils survivent. Ce qui ne survit pas, c’est ce que l’attribut a calculé plutôt que stocké. Les structs
LayoutKind.Autone portent niClassLayoutni garantie d’ordre des champs, donc il n’y a rien à récupérer au-delà du drapeau. - Les tableaux de longueur variable perdent leur taille littérale.
UnmanagedType.LPArrayavec unSizeParamIndexencode un index de paramètre dans le blob, pas une constante, donc Glass récupèreSizeParamIndex = n, qui est exactement ce qui était là, mais il n’y a pas deSizeConstà afficher. - Le marshalling par défaut est invisible par conception. Un
byte[]sans[MarshalAs]se marshale comme un pointeur. Glass, correctement, n’émet aucun attribut, mais un lecteur qui attend un buffer en ligne doit savoir que l’absence de ligne signifie « pointeur, pas en ligne ». C’est une propriété de la plateforme, pas une lacune du décompilateur. [StructLayout]avecCharSet.Autosignifie que la largeur native des champs string dépend de l’OS sur lequel le code s’exécute. Glass ne peut montrer queAuto; il ne peut pas vous dire à quelle largeur un déploiement donné l’a résolu.
À retenir
Les attributs qui définissent un contrat d’interop sont compilés vers l’extérieur : StructLayout en drapeaux du TypeDef et une ligne ClassLayout, chaque MarshalAs en un blob FieldMarshal. Un décompilateur qui n’imprime que les attributs personnalisés vous montrerait une struct dépourvue de tout cela, ce qui est pire qu’inutile à une frontière d’interop. Glass.NET remappe les vraies tables, décode les descripteurs NATIVE_TYPE_* et reconstruit les attributs exacts et la taille native en octets, de sorte que ce que vous relisez est le contrat que le code natif voit réellement. Glass est un décompilateur .NET gratuit ; vous pouvez inspecter tout assembly que vous avez le droit d’analyser, depuis la page produit Glass.NET ou la documentation CLI et MCP.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.