Skip to content
← Todas las publicaciones
· Delta1 Labs DecompilationGlass

Cómo Glass reconstruye un bloque de extensión de C# 14

Un bloque de extensión de C# 14 se reduce a un tipo anidado esqueleto oculto más métodos estáticos ordinarios en la clase contenedora. Esto recorre los metadatos que Glass.NET lee para emparejar las dos mitades y reconstruir el bloque de extensión, incluidas sus propiedades de extensión y sus miembros estáticos, que la forma clásica con parámetro this nunca pudo expresar.

C# 14 por fin permitió escribir list.IsEmpty y Point.Origin, donde IsEmpty y Origin son adiciones tuyas a tipos que no te pertenecen. El truco clásico del parámetro this nunca pudo hacerlo: solo añadía métodos, porque un getter de propiedad no tiene un primer parámetro que marcar. El nuevo bloque de extensión cierra la brecha. Y como la brecha estaba en el lenguaje, no en el runtime, el compilador tuvo que inventar una forma de metadatos para transportarla. Descompilar esa forma de vuelta a un bloque legible es un rompecabezas de dos mitades, y este artículo lo recorre para Glass.NET.

El código fuente

Un único bloque de extensión que añade una propiedad de instancia, un método de instancia y una propiedad estática a IEnumerable<T>:

public static class EnumerableExtensions
{
    extension<T>(IEnumerable<T> source)
    {
        public bool IsEmpty => !source.Any();

        public IEnumerable<T> WhereNotNull()
            => source.Where(x => x is not null);

        public static IEnumerable<T> Empty => [];
    }
}

Tres miembros, un receptor llamado source. Nada de esto se corresponde con un método de extensión clásico salvo, de forma laxa, WhereNotNull. IsEmpty es una propiedad; Empty es un miembro estático al que se accede como EnumerableExtensions.Empty sin receptor alguno. No hay sintaxis de parámetro this que exprese nada de esto.

Lo que emite el compilador

El receptor y las firmas de los miembros no sobreviven como C#. Sobreviven como un tipo anidado que el compilador sintetiza dentro de EnumerableExtensions, uno por bloque de extensión, con un nombre impronunciable como <>E__0. Ese tipo anidado es el esqueleto. Su miembro más importante es un método marcador llamado <Extension>$ cuyo único parámetro es el receptor:

.class nested public abstract sealed auto ansi beforefieldinit '<>E__0'<T>
{
    .method public hidebysig specialname static
        void '<Extension>$'(class [System.Runtime]System.Collections.Generic.IEnumerable`1<!T> source) { }

    .property instance bool IsEmpty() { .get instance bool get_IsEmpty() }
    .method public hidebysig specialname instance bool get_IsEmpty() { ldnull throw }
    .method public hidebysig instance class IEnumerable`1<!T> WhereNotNull() { ldnull throw }
    .property class IEnumerable`1<!T> Empty() { .get static class IEnumerable`1<!T> get_Empty() }
    .method public hidebysig specialname static class IEnumerable`1<!T> get_Empty() { ldnull throw }
}

Dos cosas a notar. El nombre del receptor —source— se conserva, como nombre del parámetro de <Extension>$. Y todos los cuerpos del esqueleto son ldnull; throw. Estos métodos nunca se ejecutan; existen solo para que la forma pública de cada miembro (nombre, firma, atributos, estático-o-instancia) viva en los metadatos con independencia del código que lo implementa.

El código que sí se ejecuta reside en la clase estática contenedora, bajo nombres mangled basados en contenido, con el receptor insertado como primer parámetro real en los miembros de instancia:

.class public abstract sealed auto ansi beforefieldinit EnumerableExtensions
{
    .method public hidebysig static bool
        get_IsEmpty<T>(class IEnumerable`1<!T> source)
    {
        ldarg.0  call bool [System.Linq]System.Linq.Enumerable::Any<!!T>(...)
        ldc.i4.0  ceq  ret
    }
    .method public hidebysig static class IEnumerable`1<!T>
        WhereNotNull<T>(class IEnumerable`1<!T> source) { /* real body */ }
    .method public hidebysig static class IEnumerable`1<!T>
        get_Empty<T>() { /* real body, no receiver */ }
}

Los miembros de instancia (get_IsEmpty, WhereNotNull) toman source como primer parámetro. El miembro estático (get_Empty) no: un miembro de extensión estático no tiene receptor, así que su implementación es un método estático genérico corriente. Esta asimetría es la señal más útil de todo el esquema: es como un descompilador decide si un miembro entra en el bloque como static o como miembro de instancia.

El emparejamiento

La reconstrucción es un join. Por cada miembro esqueleto de <>E__0, Glass encuentra la implementación coincidente en la clase contenedora y lee el cuerpo de ahí; lee la forma —nombre, tipo de retorno, estático-o-instancia, atributos— del esqueleto; y lee el receptor una sola vez, de <Extension>$, para poner source en el ámbito de cada cuerpo de instancia.

tipo anidado <>E__0<Extension>$(source)receptor: nombre + tipoesqueleto: IsEmpty getesqueleto: WhereNotNullesqueleto: Empty (static)forma + atributoscuerpos lanzanclase estática contenedoraget_IsEmpty(source)WhereNotNull(source)get_Empty() sin recvcuerpos IL realesextension<T>(IEnumerable<T>source)bool IsEmptyWhereNotNull()static Emptyforma + cuerpo unidos
El esqueleto lleva la forma de cada miembro y el receptor; la clase contenedora lleva los cuerpos. Glass los empareja por firma e imprime el bloque.

La decisión estático-frente-a-instancia sale directamente de la lista de parámetros de la implementación. get_IsEmpty<T>(IEnumerable<T> source) tiene el receptor como primer parámetro, así que IsEmpty es un miembro de instancia y su cuerpo se imprime con source en el ámbito. get_Empty<T>() no tiene receptor, así que Empty es static y en su ámbito solo está el parámetro de tipo. Glass no tiene que fiarse solo del flag static del esqueleto: la forma de la implementación lo confirma.

El resultado es el bloque, reensamblado literalmente:

public static class EnumerableExtensions
{
    extension<T>(IEnumerable<T> source)
    {
        public bool IsEmpty => !source.Any();
        public IEnumerable<T> WhereNotNull() => source.Where(x => x is not null);
        public static IEnumerable<T> Empty => [];
    }
}

Cómo usas esto

Apunta Glass a cualquier ensamblado que apunte a .NET 10 o posterior y use bloques de extensión —tus propias bibliotecas, una dependencia licenciada cuyo código fuente has perdido, un paquete contra el que depuras un problema de interoperabilidad—. En el árbol, la clase contenedora muestra sus miembros; expande el tipo sintetizado <>E__0 y Glass representa el bloque extension recuperado en lugar de un simple tipo anidado lleno de stubs que lanzan. Las superficies de CLI y MCP te dan la misma reconstrucción para revisión con scripts:

glass decompile EnumerableExtensions.dll --type EnumerableExtensions

Si solo quieres confirmar el receptor y la lista de miembros sin los cuerpos, la vista de IL muestra el método marcador <Extension>$ y los esqueletos directamente, que es la verdad base sobre la que se construye la vista de C#.

Cuándo falla

El emparejamiento es por firma, y las colisiones de firma son donde se deshilacha. Si dos bloques de extensión en la misma clase declaran miembros cuyas implementaciones reducidas hacen mangle a formas que una herramienta no puede distinguir, un descompilador puede adjuntar un cuerpo al esqueleto equivocado; Glass basa el join en la firma genérica completa y en el tipo del receptor para evitarlo, pero los ensamblados mangled de forma adversaria aún pueden confundir a cualquier lector. Un segundo límite es la mezcla: una clase puede contener a la vez métodos de extensión clásicos con parámetro this y nuevos bloques de extensión, y los dos usan metadatos distintos —el atributo [Extension] para los antiguos, el esqueleto <>E__N para los nuevos—, de modo que una descompilación fiel muestra cada uno en su propia forma en vez de forzar uno dentro del otro. Por último, los nombres impronunciables (<>E__0, <Extension>$) son internos del compilador y han cambiado entre previsualizaciones; Glass reconoce la forma, no un nombre codificado a mano, pero una reducción futura podría cambiar la codificación y requerir una actualización del lector.

Conclusión

Un bloque de extensión es una agrupación en tiempo de compilación sin existencia en runtime, dividida en tiempo de compilación en un esqueleto que recuerda la forma y una implementación que lleva el código. Reconstruirlo es un join: lee el receptor una vez de <Extension>$, empareja cada miembro esqueleto con su implementación y deja que el primer parámetro de la implementación decida instancia de estático. Haz bien ese join y una propiedad de extensión —algo que la sintaxis antigua nunca pudo escribir— vuelve exactamente como se escribió.

Prueba Nebula.NET

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