Récupérer le concepteur de ressources fortement typé avec Glass.NET
Un `Resources.Designer.cs` est du code de liaison généré par la machine : un `ResourceManager` paresseux, un champ de culture et une propriété typée par clé du `.resx` qui ne fait qu'appeler `GetString`. Rien de cette magie de mots-clés ne survit à la compilation : c'est de l'IL pur. Glass.NET lit l'empreinte des attributs et la forme de `GetString` pour vous rendre la classe de concepteur familière. Voici l'aller-retour complet code source → IL → C# reconstruit.
Ouvrez presque n’importe quelle application .NET localisée et vous y trouverez un fichier que personne n’a écrit à la main : Resources.Designer.cs. Le ResXFileCodeGenerator de Visual Studio le produit à partir d’un fichier .resx, et il vous donne Resources.Greeting au lieu d’un resourceManager.GetString("Greeting") à typage par chaîne éparpillé dans tout votre code. C’est du code de liaison de pur confort : un ResourceManager initialisé paresseusement, un champ de culture et une propriété par clé de ressource.
Quand vous décompilez un assembly, cette classe générée n’est qu’un type de plus dans les métadonnées. Il n’y a aucun marqueur disant « ceci a été généré par le concepteur », ni de .resx incorporé en tant que code source. Mais la forme est extrêmement régulière, et c’est précisément cette régularité qu’exploite Glass.NET, le décompilateur .NET gratuit, pour vous rendre une classe de concepteur lisible plutôt qu’un tas d’appels à GetString. Cet article suit un accesseur de ressource depuis le code source jusqu’à l’IL et retour, et montre comment Glass récupère à la fois la classe typée et les clés de ressource qui se cachent derrière.
Le code source
Partez d’un .resx à deux entrées. Conceptuellement, ce n’est qu’une table clé/valeur :
| Name | Value |
|---|---|
Greeting | Hello, {0}! |
Farewell | Goodbye. |
Le générateur en fait une classe. Voici le cœur pertinent de ce qu’émet ResXFileCodeGenerator (réduit à deux membres, les noms pleinement qualifiés condensés pour la lisibilité) :
[System.CodeDom.Compiler.GeneratedCodeAttribute(
"System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
[System.Diagnostics.DebuggerNonUserCodeAttribute]
[System.Runtime.CompilerServices.CompilerGeneratedAttribute]
internal class Resources
{
private static System.Resources.ResourceManager resourceMan;
private static System.Globalization.CultureInfo resourceCulture;
internal static System.Resources.ResourceManager ResourceManager
{
get
{
if (object.ReferenceEquals(resourceMan, null))
{
var temp = new System.Resources.ResourceManager(
"MyApp.Resources", typeof(Resources).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
internal static System.Globalization.CultureInfo Culture
{
get { return resourceCulture; }
set { resourceCulture = value; }
}
internal static string Greeting =>
ResourceManager.GetString("Greeting", resourceCulture);
}
Deux parties comptent pour la reconstruction : le getter paresseux de ResourceManager (un test de nullité qui construit le gestionnaire une seule fois et le met en cache) et la propriété typée (Greeting), qui n’est rien d’autre qu’un GetString relayé, avec une clé identique à son propre nom.
Ce que le compilateur émet
La propriété typée est la plus intéressante, car c’est la pièce qui se répète une fois par clé et celle qu’un lecteur veut le plus voir condensée. Voici get_Greeting tel que l’affiche ildasm/Glass :
.method assembly hidebysig specialname static
string get_Greeting () cil managed
{
.maxstack 8
IL_0000: call class [System.Resources]System.Resources.ResourceManager Resources::get_ResourceManager()
IL_0005: ldstr "Greeting"
IL_000a: ldsfld class [System.Globalization]System.Globalization.CultureInfo Resources::resourceCulture
IL_000f: callvirt instance string [System.Resources]System.Resources.ResourceManager::GetString(string, class [System.Globalization]System.Globalization.CultureInfo)
IL_0014: ret
}
Lisez-le d’un bout à l’autre : appeler la propriété ResourceManager, empiler la clé littérale "Greeting", empiler le champ statique resourceCulture, appeler GetString(string, CultureInfo), renvoyer le résultat. La chaîne de la clé dans le ldstr est identique au nom de la propriété : cette égalité est le cœur de l’empreinte.
Le getter paresseux se réduit au familier test-et-mise-en-cache :
.method assembly hidebysig specialname static
class [System.Resources]System.Resources.ResourceManager get_ResourceManager () cil managed
{
.maxstack 8
.locals init (class [System.Resources]System.Resources.ResourceManager V_0)
IL_0000: ldsfld class ...ResourceManager Resources::resourceMan
IL_0005: ldnull
IL_0006: call bool [System.Runtime]System.Object::ReferenceEquals(object, object)
IL_000b: brfalse.s IL_0021
IL_000d: ldstr "MyApp.Resources"
IL_0012: ldtoken Resources
IL_0017: call class [System.Runtime]System.Type System.Type::GetTypeFromHandle(valuetype ...RuntimeTypeHandle)
IL_001c: callvirt instance class [System.Runtime]System.Reflection.Assembly System.Type::get_Assembly()
IL_0021: ... newobj ResourceManager(string, Assembly) ; stsfld resourceMan
IL_... : ldsfld resourceMan
IL_... : ret
}
Le newobj porte le nom de base du jeu de ressources — "MyApp.Resources" — qui vous dit exactement quel flux .resources incorporé contient les valeurs. Gardez-le en tête ; c’est ainsi que Glass retrouve les clés.
L’empreinte qu’exploite Glass
Glass ne devine pas. Une classe de ressources générée porte une signature précise appliquée par la machine, et Glass la reconnaît par la combinaison plutôt que par un indice isolé :
Formulée précisément, la règle de reconnaissance est : un type portant GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", …), possédant un champ statique ResourceManager avec un getter paresseux à mise en cache et un champ statique CultureInfo, et dont les propriétés restantes sans instance consistent chacune en un unique appel à GetString dont la clé littérale est égale au nom propre de la propriété. Lorsque cela se vérifie, Glass étiquette le type comme un accesseur de ressources et rend les getters sous leur forme idiomatique d’une ligne plutôt que comme des corps GetString déployés.
Ce que Glass reconstruit
Pointez le décompilateur sur l’assembly :
glass decompile MyApp.dll --type Resources
Glass produit la classe de concepteur essentiellement telle que le générateur l’a écrite : attributs intacts, getter paresseux de ResourceManager restauré dans sa forme canonique, et chaque clé sous forme de propriété à corps d’expression soignée :
[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
[DebuggerNonUserCode]
[CompilerGenerated]
internal class Resources
{
private static ResourceManager resourceMan;
private static CultureInfo resourceCulture;
internal static ResourceManager ResourceManager
{
get
{
if (resourceMan is null)
resourceMan = new ResourceManager("MyApp.Resources", typeof(Resources).Assembly);
return resourceMan;
}
}
internal static CultureInfo Culture
{
get => resourceCulture;
set => resourceCulture = value;
}
internal static string Greeting => ResourceManager.GetString("Greeting", resourceCulture);
internal static string Farewell => ResourceManager.GetString("Farewell", resourceCulture);
}
C’est le fichier de concepteur d’origine, jusqu’au nom de base de la ressource et aux noms de propriété par clé. L’appel ReferenceEquals(resourceMan, null) qu’émet le générateur est rendu par son équivalent is null ; les deux sont le même test, et Glass choisit la forme qu’un lecteur attend.
Récupérer les valeurs, pas seulement les clés
La classe vous donne les clés ; les valeurs vivent dans un flux .resources incorporé nommé d’après le nom de base — MyApp.Resources.resources. Glass peut lire ce flux directement et afficher la table clé/valeur, ce que vous voulez vraiment quand vous tentez de comprendre une build localisée ou de récupérer le texte d’une application dont le source .resx a été perdu :
glass resources MyApp.dll --set MyApp.Resources
Key Type Value
--------- -------- -----------------
Greeting string "Hello, {0}!"
Farewell string "Goodbye."
Associez cela à la classe reconstruite et vous avez le tableau complet : la surface d’API typée et les chaînes qui se cachent derrière. Si l’assembly distribue des assemblys satellites pour d’autres cultures (fr/MyApp.resources.dll, de/MyApp.resources.dll), exécutez la même commande contre chacun pour comparer les traductions : un moyen rapide d’auditer quelles clés un traducteur a réellement remplies.
Quand le motif ne tient pas
La correspondance se dégrade honnêtement. Si une propriété qui ressemble à un accesseur fait quelque chose qu’un simple relais de GetString ne peut exprimer — renvoyer un byte[] via GetObject pour une image incorporée, appliquer un formatage ou lire une clé dont le nom diffère de celui de la propriété — Glass ne prétend pas qu’il s’agit de la forme simple de chaîne. Les ressources image et audio (que le constructeur émet sous forme de conversions GetObject/Bitmap) sont reconstruites exactement comme telles, et toute propriété dont la clé littérale diverge de son nom est affichée avec la vraie clé préservée. Vous n’obtenez jamais une reconstruction qui compilerait vers un comportement différent de ce que décrivent les métadonnées.
Pourquoi cela compte pour lire du vrai code
Une classe de ressources décompilée, laissée non reconnue, est l’une des choses les plus bruyantes d’un assembly : des dizaines de getters quasi identiques, chacun avec son propre corps GetString, qui enfouissent la poignée de faits pour lesquels vous êtes venu — quelles clés existent et que disent-elles. Les condenser en forme de concepteur transforme ce bruit en une table que vous pouvez parcourir en quelques secondes, et faire remonter le flux .resources incorporé vous donne les valeurs sans jamais quitter l’outil.
Glass est un décompilateur gratuit et purement statique conçu exactement pour ce genre de compréhension : vos propres assemblys, vos dépendances, une build localisée dont le source s’est écarté du binaire. Il lit l’IL et les métadonnées incorporées vers du C# ; il n’exécute, ne corrige ni ne modifie rien. Pointez-le sur une DLL dans l’interface native de Visual Studio, dans la CLI ou via MCP, et la classe de concepteur — et les chaînes qu’elle enveloppe — reviennent telles que vous vous souvenez les avoir écrites.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.