Résoudre les références depuis un lockfile NuGet dans Glass.NET
Un décompilateur ne vaut que les références qu'il peut résoudre. Pointez Glass.NET vers votre packages.lock.json et il charge les versions épinglées exactes — les types, classes de base et surcharges se résolvent alors selon ce qui a réellement été restauré, pas une supposition.
Un décompilateur gagne votre confiance une référence à la fois. Ouvrez un assembly qui tient entièrement seul et le C# revient propre. Ouvrez-en un vrai — un service qui s’appuie sur une douzaine de paquets NuGet — et la qualité de la reconstruction dépend soudain de quelque chose d’extérieur au fichier que vous avez ouvert : le décompilateur peut-il trouver les assemblys référencés, et les bonnes versions de ceux-ci ?
Quand il ne le peut pas, les symptômes sont familiers. Une méthode renvoie JToken mais le décompilateur ne développe pas le type ni ne le suit jusqu’à sa base. Une surcharge qui ne diffère que par le type d’un paramètre d’une dépendance se résout en // unresolved ou vers le mauvais candidat. Aller à la définition sur un symbole externe débouche sur une impasse. Rien de tout cela n’est Glass qui devine mal — c’est Glass qui est honnête : une référence qu’il ne peut pas charger est une référence à travers laquelle il ne peut pas voir.
Glass.NET — le décompilateur .NET gratuit et strictement statique — comble cet écart en lisant votre packages.lock.json. Le lockfile est le seul artefact qui dit, de façon faisant autorité, quelles versions exactes de paquet votre projet a restaurées. Remettez-le à Glass et chaque référence externe se résout vers l’assembly qui a réellement été distribué, pas vers une approximation.
Pourquoi un nom ne suffit pas
Un assembly compilé n’incorpore pas ses dépendances. Il incorpore des références vers elles. Deux tables de métadonnées portent toute l’histoire :
- AssemblyRef — une ligne par assembly référencé : son nom, sa version, sa culture et son jeton de clé publique.
- TypeRef — une ligne par type externe que le code touche : le nom et l’espace de noms du type, et un pointeur vers la ligne AssemblyRef qui le possède.
Cela suffit pour nommer un type à un point d’appel. Cela ne suffit pas pour le comprendre. La classe de base, la liste des interfaces, les membres, les valeurs constantes, les redirections de type — tout cela vit dans les propres métadonnées TypeDef de l’assembly référencé, que l’assembly qui référence ne copie jamais. Ainsi un décompilateur n’ayant que le TypeRef peut afficher Newtonsoft.Json.Linq.JObject mais ne peut pas savoir que JObject : JContainer : JToken, ne peut pas lister ses membres et ne peut pas résoudre quelle conversion op_Explicit un cast a sélectionnée. Pour voir à travers la référence, il doit charger l’assembly réel.
Prenez cette toute petite méthode, compilée contre Newtonsoft.Json :
using Newtonsoft.Json.Linq;
public static class Config
{
public static string? ReadName(string json)
{
JObject root = JObject.Parse(json);
return (string?)root["name"];
}
}
Son IL est sans ambiguïté sur *ce qu’*il appelle — chaque membre externe est un jeton pleinement qualifié :
.method public hidebysig static string ReadName(string json) cil managed
{
.maxstack 2
.locals init (class [Newtonsoft.Json]Newtonsoft.Json.Linq.JObject V_0)
ldarg.0
call class [Newtonsoft.Json]Newtonsoft.Json.Linq.JObject
[Newtonsoft.Json]Newtonsoft.Json.Linq.JObject::Parse(string)
stloc.0
ldloc.0
ldstr "name"
callvirt instance class [Newtonsoft.Json]Newtonsoft.Json.Linq.JToken
[Newtonsoft.Json]Newtonsoft.Json.Linq.JToken::get_Item(object)
call string [Newtonsoft.Json]Newtonsoft.Json.Linq.JToken::
op_Explicit(class [Newtonsoft.Json]Newtonsoft.Json.Linq.JToken)
ret
}
Lisez les jetons et remarquez ce qui est déjà dans votre assembly et ce qui ne l’est pas. Le préfixe [Newtonsoft.Json] est un AssemblyRef. get_Item est déclaré sur JToken, mais il est appelé via JObject — l’IL ne fonctionne que parce que JObject en hérite, et cet héritage est enregistré dans Newtonsoft.Json, pas ici. Le op_Explicit final est l’une de plusieurs conversions explicites de JToken ; la signature du jeton nomme celle qui renvoie une string, mais pour le présenter comme un cast (string?) propre et pour vous laisser y entrer, Glass a besoin de la définition du type. Sans l’assembly, Glass affiche la forme qu’il peut prouver à partir des jetons et marque le reste comme externe. Avec lui, le cast, l’héritage et la liste des membres se complètent.
Le piège de la version : ce que dit l’AssemblyRef face à ce qui a été restauré
Vous pourriez penser que la version de l’AssemblyRef règle le problème du « lequel ». Généralement non. Les bibliothèques .NET gardent délibérément leur version d’assembly stable d’une version corrective à l’autre — Newtonsoft.Json a traîné la version d’assembly 13.0.0.0 à travers de nombreuses versions NuGet 13.0.x — si bien que le numéro gravé dans votre AssemblyRef n’est pas la version de paquet qui a été restaurée. Ajoutez une référence flottante comme <PackageReference Include="Newtonsoft.Json" Version="13.*" /> et l’écart s’élargit : le projet a compilé contre la 13.0.x du moment, l’AssemblyRef indique toujours 13.0.0.0, et un sondage qui cherche seulement « un Newtonsoft.Json nommé 13.0.0.0 » dans votre cache pourrait lier n’importe lequel de plusieurs dossiers.
packages.lock.json est l’artefact qui supprime l’ambiguïté. Quand RestorePackagesWithLockFile est activé, NuGet écrit la version résolue exacte et un hachage de contenu pour chaque paquet — direct et transitif :
{
"version": 1,
"dependencies": {
"net8.0": {
"Newtonsoft.Json": {
"type": "Direct",
"requested": "[13.*, )",
"resolved": "13.0.3",
"contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lAReUcg2cFTjaQ=="
}
}
}
}
"resolved": "13.0.3" est le fait que Glass veut. Il correspond directement à ~/.nuget/packages/newtonsoft.json/13.0.3/ dans votre cache local, donc Glass charge cet assembly — celui que votre build a réellement utilisé — et pas un voisin proche.
Pointez Glass vers le lockfile
Depuis la CLI
La commande decompile de Glass prend un lockfile et résout chaque référence à partir de lui avant de reconstruire une seule ligne :
glass decompile ./bin/Release/net8.0/Billing.dll \
--lockfile ./packages.lock.json \
--out ./recovered
Glass lit le lockfile, parcourt chaque entrée resolved jusqu’au dossier ~/.nuget/packages/<id>/<version>/lib/<tfm>/ correspondant et charge ces assemblys comme ensemble de références. Si un paquet traîne ses propres dépendances transitives épinglées par le lockfile, elles sont aussi dans le fichier, donc la fermeture se résout en une seule passe — pas de restauration réseau, pas d’exécution. Tout ce que le lockfile ne peut pas couvrir (une référence de framework, une sortie de projet locale à côté de la DLL) se résout encore par le sondage normal de Glass : le répertoire de l’application, puis les packs de référence du framework partagé pour le TFM cible.
Vous pouvez confirmer ce qui a été résolu avant de faire confiance à la sortie. glass sbom lit les mêmes entrées et affiche l’ensemble de références fusionné avec les versions exactes que Glass a liées, de sorte que vous pouvez comparer « ce que disait le lockfile » à « ce que Glass a chargé » et repérer un manque — un paquet absent du cache, par exemple — plutôt que de le découvrir comme un type non résolu trois fichiers plus loin.
Dans l’interface
Ouvrez Billing.dll de la manière habituelle — glissez-le sur la fenêtre, ou File ▸ Open Assembly. Quand un packages.lock.json se trouve à côté du binaire dans l’arbre du projet, Glass le remarque et propose Resolve references from lockfile dans le menu contextuel de l’assembly (et dans le bandeau de notification). Acceptez et le nœud references se repeuple : les entrées qui étaient en italique-et-non-résolues deviennent pleines, chacune étiquetée avec la version exacte du lockfile. Le bénéfice apparaît désormais partout où l’interface touche un type externe :
- Go to Definition (F12) sur
JObjectouvre le type réel de13.0.3, avec sa chaîne de bases et ses membres, au lieu de s’arrêter à un stub externe. - Le C# décompilé de
ReadNameprésente un(string?)root["name"]propre parce que l’indexeur et la conversion explicite se sont résolus contre le type chargé. - Find All References et la hiérarchie d’appels peuvent suivre les appels par-delà la frontière jusque dans la dépendance, si bien que « où cette valeur est-elle réellement validée ? » tient en quelques clics plutôt qu’en une conjecture.
Si vous avez un jour besoin de savoir si un détail précis vient de l’assembly réel ou de Glass inférant la forme à partir des seuls jetons, descendez le membre vers la vue IL. Les jetons y sont la vérité de base sur laquelle la résolution se construit, et ils se lisent de la même façon que la référence ait été chargée ou non — c’est exactement pourquoi ce sont eux vers quoi se replier.
Quand le lockfile gagne sa place
- Auditer une DLL tierce distribuée. Vous avez le
.dlldu fournisseur et, à côté, lepackages.lock.jsonde son build. Résoudre contre le lockfile vous donne leur graphe de dépendances exact, de sorte que votre lecture de leur code correspond aux assemblys qu’ils ont réellement liés — sans dérive due à ce qui se trouve par hasard dans votre cache. - Récupérer une bibliothèque dont le code source est perdu. Quand vous exportez un assembly décompilé vers un projet compilable, des références précises sont ce qui fait que le résultat compile réellement. Résoudre d’abord depuis le lockfile signifie que le projet récupéré pointe vers les mêmes versions de paquet que l’original.
- Reproduire un bug spécifique à une version. Un défaut qui n’apparaît qu’avec un correctif d’une dépendance est invisible si votre décompilateur a lié un autre correctif. Épingler à la version
resolveddu lockfile fait que le code que vous lisez est le code qui a dysfonctionné.
Le fil conducteur est le même que celui qui traverse chaque flux de travail de Glass : il lit, il n’exécute jamais. Résoudre les références depuis un lockfile reste de l’analyse purement statique — Glass lit le lockfile, lit les métadonnées du paquet en cache et reconstruit du C#. Rien n’est restauré depuis le réseau, rien n’est exécuté. Vous obtenez simplement une décompilation honnête sur la seule chose qu’un .dll solitaire ne pourra jamais vous dire par lui-même : contre quelle dépendance il a réellement été compilé.
Glass.NET est gratuit — pas de licence, pas de sièges, pas d’inscription. Pointez-le vers vos propres binaires, vers des dépendances que vous avez le droit d’inspecter, ou vers du code dont vous apprenez le compilateur, et laissez le lockfile rendre les références exactes.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.