Skip to content
← Alle Beiträge
· Delta1 Labs DecompilationGlass

Den stark typisierten Ressourcen-Designer mit Glass.NET wiederherstellen

Eine `Resources.Designer.cs` ist maschinell generierter Klebecode: ein fauler `ResourceManager`, ein Kulturfeld und eine typisierte Eigenschaft pro `.resx`-Schlüssel, die nur `GetString` aufruft. Nichts von dieser Schlüsselwort-Magie überlebt die Kompilierung – es ist reines IL. Glass.NET liest den Attribut-Fingerabdruck und die `GetString`-Form zurück in die vertraute Designer-Klasse. Hier ist der vollständige Hin-und-Rückweg Quellcode → IL → rekonstruiertes C#.

Öffnen Sie fast jede lokalisierte .NET-Anwendung, und Sie finden darin eine Datei, die niemand von Hand geschrieben hat: Resources.Designer.cs. Der ResXFileCodeGenerator von Visual Studio erzeugt sie aus einer .resx-Datei, und sie gibt Ihnen Resources.Greeting statt eines über den gesamten Code verstreuten, zeichenketten-typisierten resourceManager.GetString("Greeting"). Es ist reiner Komfort-Klebecode: ein faul initialisierter ResourceManager, ein Kulturfeld und eine Eigenschaft pro Ressourcenschlüssel.

Wenn Sie ein Assembly dekompilieren, ist diese generierte Klasse nur ein weiterer Typ in den Metadaten. Es gibt keine Markierung, die sagt „dies wurde vom Designer generiert”, keine .resx, die als Quellcode eingebettet ist. Aber die Form ist äußerst regelmäßig, und genau diese Regelmäßigkeit nutzt Glass.NET, der kostenlose .NET-Dekompilierer, um Ihnen eine lesbare Designer-Klasse statt eines Haufens von GetString-Aufrufen zurückzugeben. Dieser Beitrag verfolgt einen Ressourcen-Accessor vom Quellcode bis zum IL und zurück und zeigt, wie Glass sowohl die typisierte Klasse als auch die dahinterliegenden Ressourcenschlüssel wiederherstellt.

Der Quellcode

Beginnen Sie mit einer .resx mit zwei Einträgen. Konzeptionell ist es nur eine Schlüssel/Wert-Tabelle:

NameValue
GreetingHello, {0}!
FarewellGoodbye.

Der Generator macht daraus eine Klasse. Hier ist der relevante Kern dessen, was ResXFileCodeGenerator ausgibt (auf zwei Mitglieder gekürzt, vollqualifizierte Namen zur besseren Lesbarkeit zusammengefasst):

[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);
}

Zwei Teile sind für die Rekonstruktion wichtig: der faule ResourceManager-Getter (eine Nullprüfung, die den Manager einmal erstellt und zwischenspeichert) und die typisierte Eigenschaft (Greeting), die nichts weiter ist als ein weitergeleitetes GetString, dessen Schlüssel dem eigenen Namen entspricht.

Was der Compiler ausgibt

Die typisierte Eigenschaft ist die interessante, denn sie ist das Element, das sich einmal pro Schlüssel wiederholt, und dasjenige, das ein Leser am ehesten zusammengefasst sehen möchte. Hier ist get_Greeting, wie ildasm/Glass es anzeigt:

.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
}

Lesen Sie es von vorne bis hinten: die Eigenschaft ResourceManager aufrufen, den literalen Schlüssel "Greeting" ablegen, das statische Feld resourceCulture ablegen, GetString(string, CultureInfo) aufrufen, das Ergebnis zurückgeben. Die Schlüssel-Zeichenkette im ldstr ist identisch mit dem Eigenschaftsnamen – diese Gleichheit ist das Herzstück des Fingerabdrucks.

Der faule Getter reduziert sich auf die vertraute Prüfung-und-Zwischenspeicherung:

.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
}

Das newobj trägt den Basisnamen des Ressourcensatzes – "MyApp.Resources" –, der Ihnen genau sagt, welcher eingebettete .resources-Stream die Werte enthält. Merken Sie ihn sich; so findet Glass die Schlüssel.

Der Fingerabdruck, den Glass nutzt

Glass rät nicht. Eine generierte Ressourcenklasse trägt eine präzise, maschinell angewendete Signatur, und Glass erkennt sie an der Kombination statt an einem einzelnen Hinweis:

Recognizing a generated Resources class Metadata clues [GeneratedCode( "StronglyTyped- ResourceBuilder")] [DebuggerNonUser- Code] static ResourceManager field + lazy getter static CultureInfo field props: GetString(name) Match test builder attribute + manager/culture pair + each getter forwards GetString("Name") where key == property Reconstructed C# [GeneratedCode(...)] internal class Resources ResourceManager { get } Culture { get; set } string Greeting => ... string Farewell => ... The base name in the ResourceManager ctor points Glass at the embedded .resources stream.

Präzise formuliert lautet die Erkennungsregel: ein Typ, der GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", …) trägt, ein statisches ResourceManager-Feld mit einem fauligen, zwischenspeichernden Getter und ein statisches CultureInfo-Feld besitzt und dessen übrige instanzlose Eigenschaften jeweils aus einem einzigen GetString-Aufruf bestehen, dessen literaler Schlüssel dem eigenen Namen der Eigenschaft entspricht. Wenn das zutrifft, kennzeichnet Glass den Typ als Ressourcen-Accessor und stellt die Getter in ihrer idiomatischen Einzeilerform dar statt als ausgeklappte GetString-Rümpfe.

Was Glass rekonstruiert

Richten Sie den Dekompilierer auf das Assembly:

glass decompile MyApp.dll --type Resources

Glass erzeugt die Designer-Klasse im Wesentlichen so, wie der Generator sie geschrieben hat: Attribute intakt, der faule ResourceManager-Getter in seiner kanonischen Form wiederhergestellt und jeder Schlüssel als saubere ausdrucksbasierte Eigenschaft:

[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);
}

Das ist die ursprüngliche Designer-Datei, bis hin zum Basisnamen der Ressource und den Eigenschaftsnamen pro Schlüssel. Der vom Generator ausgegebene Aufruf ReferenceEquals(resourceMan, null) wird als das gleichwertige is null dargestellt; beide sind dieselbe Prüfung, und Glass wählt die Form, die ein Leser erwartet.

Die Werte wiederherstellen, nicht nur die Schlüssel

Die Klasse nennt Ihnen die Schlüssel; die Werte liegen in einem eingebetteten .resources-Stream, benannt nach dem Basisnamen – MyApp.Resources.resources. Glass kann diesen Stream direkt lesen und die Schlüssel/Wert-Tabelle anzeigen, was Sie tatsächlich wollen, wenn Sie einen lokalisierten Build verstehen oder Text aus einer Anwendung wiederherstellen möchten, deren .resx-Quelle verloren ging:

glass resources MyApp.dll --set MyApp.Resources
Key        Type      Value
---------  --------  -----------------
Greeting   string    "Hello, {0}!"
Farewell   string    "Goodbye."

Kombinieren Sie das mit der rekonstruierten Klasse, und Sie haben das Gesamtbild: die typisierte API-Oberfläche und die Zeichenketten dahinter. Wenn das Assembly Satelliten-Assemblys für andere Kulturen ausliefert (fr/MyApp.resources.dll, de/MyApp.resources.dll), führen Sie denselben Befehl gegen jedes aus, um die Übersetzungen zu vergleichen – eine schnelle Möglichkeit zu prüfen, welche Schlüssel ein Übersetzer tatsächlich ausgefüllt hat.

Wenn das Muster nicht zutrifft

Die Übereinstimmung degradiert ehrlich. Wenn eine Eigenschaft, die wie ein Accessor aussieht, etwas tut, das eine schlichte GetString-Weiterleitung nicht ausdrücken kann – ein byte[] über GetObject für ein eingebettetes Bild zurückgeben, eine Formatierung anwenden oder einen Schlüssel lesen, dessen Name vom Eigenschaftsnamen abweicht –, gibt Glass nicht vor, es handle sich um die einfache Zeichenkettenform. Bild- und Audioressourcen (die der Builder als GetObject/Bitmap-Umwandlungen ausgibt) werden genau als solche rekonstruiert, und jede Eigenschaft, deren literaler Schlüssel von ihrem Namen abweicht, wird mit dem echten, erhaltenen Schlüssel angezeigt. Sie erhalten nie eine Rekonstruktion, die zu einem anderen Verhalten kompilieren würde, als die Metadaten beschreiben.

Warum das für das Lesen von echtem Code wichtig ist

Eine dekompilierte Ressourcenklasse ist, unerkannt gelassen, eines der lautesten Dinge in einem Assembly: Dutzende nahezu identischer Getter, jeder mit eigenem GetString-Rumpf, die die Handvoll Fakten vergraben, derentwegen Sie gekommen sind – welche Schlüssel existieren und was sagen sie. Sie zurück in die Designer-Form zu verdichten, verwandelt dieses Rauschen in eine Tabelle, die Sie in Sekunden überfliegen können, und das Zutageförden des eingebetteten .resources-Streams liefert Ihnen die Werte, ohne das Werkzeug je zu verlassen.

Glass ist ein kostenloser, rein statischer Dekompilierer, gebaut genau für diese Art des Verstehens – Ihre eigenen Assemblys, Ihre Abhängigkeiten, ein lokalisierter Build, dessen Quelle sich vom Binary entfernt hat. Er liest IL und eingebettete Metadaten zu C#; er führt nichts aus, patcht nichts und ändert nichts. Richten Sie ihn in der Visual-Studio-nativen Oberfläche, in der CLI oder über MCP auf eine DLL, und die Designer-Klasse – und die Zeichenketten, die sie umhüllt – kommen so zurück, wie Sie sich erinnern, sie geschrieben zu haben.

Nebula.NET testen

Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.