Skip to content
← Todas las publicaciones
· Delta1 Labs DecompilationGlass

Recuperar el diseñador de recursos con tipado fuerte con Glass.NET

Un `Resources.Designer.cs` es pegamento generado por máquina: un `ResourceManager` perezoso, un campo de cultura y una propiedad tipada por cada clave del `.resx` que solo llama a `GetString`. Nada de esa magia de palabras clave sobrevive a la compilación: es IL puro. Glass.NET lee la huella de atributos y la forma de `GetString` para devolverte la clase de diseñador familiar. Aquí está el recorrido completo de ida y vuelta de código fuente → IL → C# reconstruido.

Abre casi cualquier aplicación .NET localizada y encontrarás un archivo que nadie escribió a mano: Resources.Designer.cs. El ResXFileCodeGenerator de Visual Studio lo produce a partir de un archivo .resx, y te da Resources.Greeting en lugar de un resourceManager.GetString("Greeting") con tipado de cadena repartido por todo el código. Es pegamento de pura conveniencia: un ResourceManager inicializado de forma perezosa, un campo de cultura y una propiedad por cada clave de recurso.

Cuando descompilas un ensamblado, esa clase generada es solo otro tipo en los metadatos. No hay ninguna marca que diga «esto lo generó el diseñador», ni un .resx incrustado como código fuente. Pero la forma es extremadamente regular, y esa regularidad es exactamente lo que Glass.NET, el descompilador de .NET gratuito, aprovecha para devolverte una clase de diseñador legible en lugar de un montón de llamadas a GetString. Esta publicación recorre un descriptor de acceso a recursos desde el código fuente hasta el IL y de vuelta, y muestra cómo Glass recupera tanto la clase tipada como las claves de recurso que hay detrás.

El código fuente

Empieza con un .resx de dos entradas. Conceptualmente es solo una tabla de clave/valor:

NameValue
GreetingHello, {0}!
FarewellGoodbye.

El generador convierte eso en una clase. Aquí está el núcleo relevante de lo que emite ResXFileCodeGenerator (recortado a dos miembros, con los nombres completamente cualificados colapsados para facilitar la lectura):

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

Dos partes importan para la reconstrucción: el getter perezoso de ResourceManager (una comprobación de nulo que construye el administrador una vez y lo almacena en caché) y la propiedad tipada (Greeting), que no es más que un GetString reenviado con la clave que coincide con su propio nombre.

Lo que emite el compilador

La propiedad tipada es la interesante, porque es la pieza que se repite una vez por clave y la que un lector más quiere colapsar. Aquí está get_Greeting tal como lo muestra 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
}

Léelo de principio a fin: llama a la propiedad ResourceManager, empuja la clave literal "Greeting", empuja el campo estático resourceCulture, llama a GetString(string, CultureInfo) y devuelve el resultado. La cadena de la clave en el ldstr es idéntica al nombre de la propiedad: esa igualdad es el corazón de la huella.

El getter perezoso se reduce a la conocida comprobación y caché:

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

El newobj lleva el nombre base del conjunto de recursos —"MyApp.Resources"— que te dice exactamente qué flujo .resources incrustado contiene los valores. Recuérdalo; es cómo Glass encuentra las claves.

La huella que Glass aprovecha

Glass no adivina. Una clase de recursos generada lleva una firma precisa aplicada por máquina, y Glass la detecta por la combinación más que por una sola pista:

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.

Expresada con precisión, la regla de reconocimiento es: un tipo que lleva GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", …), que tiene un campo estático ResourceManager con un getter perezoso de caché y un campo estático CultureInfo, y cuyas propiedades restantes sin instancia constan cada una de una sola llamada a GetString cuya clave literal es igual al propio nombre de la propiedad. Cuando eso se cumple, Glass etiqueta el tipo como un descriptor de acceso a recursos y representa los getters en su forma idiomática de una línea en lugar de como cuerpos GetString expandidos.

Lo que Glass reconstruye

Apunta el descompilador al ensamblado:

glass decompile MyApp.dll --type Resources

Glass produce la clase de diseñador esencialmente tal como la escribió el generador: los atributos intactos, el getter perezoso de ResourceManager restaurado a su forma canónica y cada clave como una pulcra propiedad de cuerpo de expresión:

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

Ese es el archivo de diseñador original, hasta el nombre base del recurso y los nombres de propiedad por clave. La llamada ReferenceEquals(resourceMan, null) que emite el generador se representa como el equivalente is null; ambas son la misma comprobación, y Glass elige la forma que un lector espera.

Recuperar los valores, no solo las claves

La clase te dice las claves; los valores viven en un flujo .resources incrustado llamado según el nombre base: MyApp.Resources.resources. Glass puede leer ese flujo directamente y mostrar la tabla de clave/valor, que es lo que de verdad quieres cuando intentas entender una compilación localizada o recuperar el texto de una aplicación cuyo fuente .resx se perdió:

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

Combina eso con la clase reconstruida y tienes el panorama completo: la superficie de API tipada y las cadenas que hay detrás. Si el ensamblado distribuye ensamblados satélite para otras culturas (fr/MyApp.resources.dll, de/MyApp.resources.dll), ejecuta el mismo comando contra cada uno para comparar las traducciones: una forma rápida de auditar qué claves rellenó realmente un traductor.

Cuando el patrón no se cumple

La coincidencia degrada con honestidad. Si una propiedad que parece un descriptor de acceso hace algo que un simple reenvío de GetString no puede expresar —devuelve un byte[] mediante GetObject para una imagen incrustada, aplica formato o lee una clave cuyo nombre difiere del de la propiedad— Glass no finge que es la forma simple de cadena. Los recursos de imagen y audio (que el constructor emite como conversiones GetObject/Bitmap) se reconstruyen exactamente como eso, y cualquier propiedad cuya clave literal diverja de su nombre se muestra con la clave real conservada. Nunca obtienes una reconstrucción que compilaría a un comportamiento distinto del que describen los metadatos.

Por qué esto importa para leer código real

Una clase de recursos descompilada, dejada sin reconocer, es una de las cosas más ruidosas de un ensamblado: docenas de getters casi idénticos, cada uno con su propio cuerpo GetString, que sepultan el puñado de hechos por los que viniste: qué claves existen y qué dicen. Colapsarlos de vuelta a la forma de diseñador convierte ese ruido en una tabla que puedes escanear en segundos, y sacar a la luz el flujo .resources incrustado te da los valores sin salir nunca de la herramienta.

Glass es un descompilador gratuito y estático construido exactamente para este tipo de comprensión: tus propios ensamblados, tus dependencias, una compilación localizada cuyo fuente se distanció del binario. Lee IL y metadatos incrustados a C#; no ejecuta, parchea ni modifica nada. Apúntalo a una DLL en la interfaz nativa de Visual Studio, en la CLI o a través de MCP, y la clase de diseñador —y las cadenas que envuelve— vuelven tal como recuerdas haberlas escrito.

Prueba Nebula.NET

Endurece tu código .NET en minutos — empieza con la edición gratuita.