Skip to content
← Tous les articles
· Delta1 Labs InteropGlass

Comment se décompile le P/Invoke généré par source

Les méthodes [DllImport] classiques n'ont pas de corps managé : un décompilateur les reconstruit depuis la table ImplMap. Une méthode [LibraryImport] est l'inverse : le stub de marshalling est du C# compilé réel, et Glass l'affiche en entier.

Décompilez une méthode marquée [DllImport] et vous ne récupérez presque rien : une signature extern, un attribut reconstruit, et aucun corps. Décompilez une méthode marquée [LibraryImport] et vous obtenez une page de vrai C# : des blocs fixed, des conversions de pointeurs, un appel imbriqué. Le même appel natif, des sorties décompilées radicalement différentes. La raison tient à l’endroit où réside le code de marshalling, et elle mérite d’être comprise, car elle change ce que vous pouvez apprendre d’un assembly en le lisant.

La vraie question

Les deux attributs décrivent la même chose : une méthode managée qui est en réalité un appel à travers la frontière native. Alors pourquoi l’une survit-elle à la décompilation sous forme de coquille vide et l’autre sous forme de méthode entièrement lisible ? La réponse est que le [DllImport] classique délègue tout le marshalling au CLR à l’exécution, tandis que [LibraryImport] — le générateur de source introduit dans .NET 7 — écrit le marshalling en C# au moment de la compilation. L’un laisse le stub dans le runtime ; l’autre le cuit dans votre assembly.

DllImport classique : une méthode sans corps

Commençons par l’ancien style :

[DllImport("user32.dll", EntryPoint = "MessageBoxW",
    CharSet = CharSet.Unicode, ExactSpelling = true)]
internal static extern int MessageBox(IntPtr hWnd, string lpText, string lpCaption, uint uType);

Dans les métadonnées, cette méthode est inhabituelle. Sa ligne MethodDef porte l’indicateur pinvokeimpl, et elle n’a pas de CIL. Les données de la déclaration vivent dans une table de métadonnées distincte, ImplMap, qui relie la méthode à un ModuleRef (user32.dll), au nom d’importation (MessageBoxW) et à un ensemble d’indicateurs encodant le charset, la convention d’appel et SetLastError. Quand vous l’ouvrez dans Glass, la vue IL montre une méthode vide et le décompilateur reconstruit l’attribut à partir de la ligne ImplMap :

// décompilé — le corps n'est vraiment pas ici
[DllImport("user32.dll", EntryPoint = "MessageBoxW", ExactSpelling = true)]
internal static extern int MessageBox(IntPtr hWnd, string lpText, string lpCaption, uint uType);

Alors, où est le code qui transforme une string en char* et la pousse sur la pile native ? Il n’existe pas dans l’assembly. Le CLR construit un stub de marshalling à la première invocation de la méthode, guidé par les indicateurs d’ImplMap et par la signature. Ce stub est compilé par le JIT en mémoire et jeté à la fin du processus. Un décompilateur ne peut jamais le montrer, car il n’a jamais été sur disque.

LibraryImport : le stub devient du C#

Passons à la forme générée par source. La méthode est partial, et l’attribut vit sur une déclaration sans corps :

[LibraryImport("user32.dll", EntryPoint = "MessageBoxW",
    StringMarshalling = StringMarshalling.Utf16)]
internal static partial int MessageBox(IntPtr hWnd, string lpText, string lpCaption, uint uType);

Au moment de la compilation, le LibraryImportGenerator fournit l’autre moitié de la méthode partielle. C’est du C# ordinaire — et c’est ce qui finit dans votre assembly :

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;

    // le vrai franchissement de frontière — une fonction locale
    [DllImport("user32.dll", EntryPoint = "MessageBoxW", ExactSpelling = true)]
    static extern int __PInvoke(IntPtr hWnd, ushort* lpText, ushort* lpCaption, uint uType);
}

Lisez ce qu’a fait le générateur. Comme StringMarshalling.Utf16 correspond à la disposition UTF-16 de la string du CLR, aucune copie n’est nécessaire : les deux chaînes sont épinglées avec fixed, leurs pointeurs réinterprétés comme ushort* et passés directement. L’appel natif réel est une fonction locale static extern imbriquée — toujours un [DllImport] classique, mais désormais un détail d’implémentation privé et nommé par le compilateur. La méthode publique est de la pure glu de marshalling visible.

[DllImport] classiqueMessageBox() — aucun corps ILindicateur pinvokeimpl + ligne ImplMapStub de marshalling créé par le CLR au1er appel — en mémoire, pas sur disqueLe décompilateur voit : méthode vide +attribut reconstruit depuis ImplMap[LibraryImport]MessageBox() — vrai corps ILfixed { } + call __PInvoke__PInvoke() — aucun corps ILfonction locale pinvokeimpl, sur disqueLe décompilateur voit : le stub demarshalling en C# lisible + extern interneappelle
Le DllImport classique laisse le stub dans le runtime, le décompilateur ne récupère donc que des métadonnées. LibraryImport compile le stub dans l'assembly, et Glass le lit comme du C# ordinaire.

Ce que Glass montre réellement

La fonction locale [DllImport] imbriquée ne conserve pas de nom convivial dans l’assembly compilé. C# abaisse les fonctions locales en méthodes privées statiques au nom mutilé (mangled), donc dans les métadonnées vous verrez quelque chose comme <MessageBox>g__PInvoke|0_0. Quand vous ouvrez l’assembly dans Glass, le décompilateur reconnaît ce mangling et le restitue sous forme de fonction locale à l’intérieur de MessageBox, proche de la source générée ci-dessus. Passez à la vue IL et vous pourrez confirmer la séparation directement :

.method assembly hidebysig static int32 MessageBox (...) cil managed
{
    // IL réel : ldarg, conv, le motif fixed-pin, call vers __PInvoke
}
.method assembly hidebysig static pinvokeimpl("user32.dll" ...) int32 '<MessageBox>g__PInvoke|0_0' (...) cil managed { }

Seule la seconde méthode porte pinvokeimpl. C’est le seul vrai franchissement de frontière. Tout le reste — l’épinglage, la conversion de pointeur, la gestion du retour — est du code qu’a écrit le générateur et que vous pouvez désormais lire. Pour un paramètre de chaîne UTF-8, le stub serait plus long : il réserve un tampon natif, appelle le marshaller UTF-8 pour transcoder, utilise le tampon, puis le libère dans un finally. Tout cela, aussi, est décompilable, car tout cela est du vrai IL.

Pourquoi cela compte quand on lit un assembly

Ce n’est pas une curiosité : cela change l’interop que vous pouvez auditer par inspection. Avec une surface [DllImport] classique, lire l’assembly vous indique le point d’entrée et la signature déclarée, et rien sur la façon dont les arguments sont réellement marshallés ; la vérité est dans les règles d’exécution du CLR. Avec [LibraryImport], le marshalling est juste là. Vous pouvez voir exactement quels tampons sont épinglés, où un transcodage réserve de la mémoire, si un bool est marshallé comme un int de 4 octets ou comme une valeur d’1 octet, et quand la mémoire est libérée. Pour examiner une couche d’interop que vous avez le droit d’inspecter — votre propre build, une dépendance que vous évaluez, un plantage que vous déboguez — la forme générée par source est bien plus transparente.

Cela vous dit aussi quelque chose sur la provenance. Une bibliothèque qui utilise [LibraryImport] a été compilée pour .NET 7 ou plus récent avec le générateur activé, et elle est compatible AOT par conception, précisément parce que le stub est du code statique plutôt que de l’IL généré à l’exécution. Voir les méthodes g__PInvoke dans Glass est un signal rapide d’une couche d’interop moderne, prête pour le trimming et l’AOT.

Mises en garde

Le stub décompilé est du C# fidèle, mais c’est le C# du générateur, pas le vôtre : ne vous attendez pas à ce qu’il corresponde au marshalling écrit à la main que vous pourriez produire pour le même appel. Les noms des fonctions locales générées (g__PInvoke|0_0) sont des artefacts du compilateur et peuvent changer entre versions du compilateur, donc ne les traitez pas comme une API stable. Et la méthode imbriquée reste un vrai [DllImport] : le saut final vers le code natif est aussi opaque que jamais — Glass vous montre le marshalling managé, pas la fonction native sur laquelle il atterrit. Si l’assembly est livré avec un PDB, Glass peut aussi récupérer les noms d’arguments d’origine et rendre le stub encore plus facile à suivre ; voir récupérer les noms depuis un PDB.

À retenir

[DllImport] cache son marshalling dans le runtime ; [LibraryImport] l’écrit dans votre assembly. Cette seule différence explique pourquoi l’un se décompile en coquille vide et l’autre en stub lisible. Quand vous devez comprendre comment un appel d’interop déplace réellement ses arguments à travers la frontière, ouvrez-le dans Glass.NET — et espérez qu’il a été compilé avec le générateur. Glass est un décompilateur .NET gratuit et ouvert, doté d’une interface native à VS, d’une CLI et d’un serveur MCP.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.