Skip to content
← Todas las publicaciones
· Delta1 Labs MetadataGlass

Cómo Glass reconstruye nombres de tipos genéricos anidados

El nombre que un tipo genérico lleva en los metadatos va codificado con una comilla invertida y un número, y ese número cuenta solo los parámetros que el tipo añade por sí mismo: un tipo anidado hereda los parámetros de su tipo contenedor pero no los cuenta en su nombre. Este artículo lee la codificación real, muestra por qué el vector plano de argumentos genéricos hay que repartirlo entre los niveles de anidamiento y explica cómo Glass.NET convierte Outer`2/Inner`1 de vuelta en Outer<int, string>.Inner<bool>.

Descompila un tipo anidado dentro de un tipo genérico y el nombre que recuperas —Outer<int, string>.Inner<bool>— no se parece en nada al nombre guardado en disco. Los metadatos contienen Inner1`, con una comilla invertida y un número, y ese número no es tres, aunque dentro del tipo haya tres parámetros de tipo en el ámbito. La distancia entre esas dos formas de escribirlo es una de las pequeñas cosas precisas que un descompilador debe acertar exactamente, porque equivocarse produce C# que no compila.

La pregunta real

El nombre de un tipo genérico en los metadatos de .NET lleva mangling: List1, Dictionary2, Func4`. La comilla invertida y el número codifican la aridad genérica del tipo. Esa regla es simple hasta que los tipos se anidan. Un tipo anidado dentro de un tipo genérico puede usar los parámetros del contenedor como si fueran propios, pero su nombre no los cuenta. Entonces, ¿dónde vive la imagen completa y cómo pasa un lector de un nombre con mangling más una lista plana de argumentos de tipo de vuelta al nombre genérico totalmente cualificado que un desarrollador reconocería?

La aridad cuenta lo que el tipo añade, no lo que tiene

Toma un tipo genérico con un tipo genérico anidado dentro:

public class Outer<TKey, TValue>
{
    public class Inner<TState>
    {
        public TValue Get(TKey key, TState state) => default;
    }
}

Inner usa tres parámetros de tipo —TKey y TValue de Outer, más su propio TState—. Pero su nombre de metadatos no lo refleja. Así se almacenan los dos tipos, renderizados como Glass los muestra en la vista de IL:

.class public auto ansi beforefieldinit Outer`2<TKey, TValue>
       extends [System.Runtime]System.Object
{
  .class auto ansi nested public beforefieldinit Inner`1<TState>
         extends [System.Runtime]System.Object
  {
    // inside Inner the parameter index space is [TKey=!0, TValue=!1, TState=!2]
    .method public hidebysig instance !1 Get(!0 key, !2 state) cil managed
    {
      // returns TValue (!1), takes TKey (!0) and TState (!2)
    }
  }
}

Outer es Outer2: añade dos parámetros. InneresInner1: añade uno. El 1 es TState solo. TKey y TValue se heredan, y el nombre no cuenta los parámetros heredados.

Y sin embargo, mira la firma del método. Get devuelve TValue y eso se codifica como !1: índice de parámetro genérico 1. Sus argumentos son !0 (TKey) y !2 (TState). El espacio de índices dentro de Inner va 0, 1, 2 a través de los tres parámetros, contenedor primero. Así que Inner tiene una aridad de tres a efectos de firmas, pero un nombre que dice uno. No es una contradicción: son dos números distintos para dos trabajos distintos.

Los dos números, en las tablas

El nombre vive en el heap #Strings como el texto literal Inner1. Es solo una cadena; no lleva información sobre dentro de qué está anidado Inner. El anidamiento es un hecho aparte, almacenado en la tabla **NestedClass**: una fila que enlaza el TypeDef de Innercon el TypeDef deOuter`. Recorre esa tabla y aprendes la cadena de contenedores; lee el nombre y aprendes la aridad propia. Ninguno sabe del otro.

El tercer número está en la tabla GenericParam. Cada parámetro genérico en el ámbito de un tipo obtiene una fila propiedad de ese tipo, numerada desde cero. Para Inner, la tabla contiene tres filas —TKey (0), TValue (1), TState (2)—: los parámetros del contenedor vueltos a listar primero, luego los propios del tipo. Por eso !0 resuelve a TKey dentro de los cuerpos de los métodos de Inner. Así que el mismo tipo anidado lleva una aridad propia de uno en su nombre y un recuento total de parámetros de tres en GenericParam. Un descompilador tiene que tener ambos presentes a la vez.

Repartir el vector plano de argumentos

Ahora construye el tipo y aparece el trabajo de verdad:

Outer<int, string>.Inner<bool> x = new();

El CLR codifica Outer<int, string>.Inner<bool> como una única firma GenericInst: la referencia al tipo más interno, un recuento de argumentos genéricos de 3 y un vector plano de tres argumentos —int, string, bool—. No hay agrupación en los bytes. Nada dice que int y string pertenecen a Outer y bool a Inner. La firma es plana precisamente porque el espacio de índices de parámetros es plano.

Para imprimir un nombre de C# legal, Glass tiene que reagrupar ese vector plano entre los niveles de anidamiento, y lo único que le dice dónde van los cortes es la aridad propia de cada nivel —el número de comilla invertida que quitó del nombre—. Outer2toma los dos primeros argumentos;Inner1 toma el siguiente. Consúmelos en orden de contenedor a anidado y el vector queda particionado exactamente.

Lo que almacenan los metadatosOuter`2 / Inner`1nombre + fila NestedClassGenericInst argc=3vector plano, sin agruparVector plano de argumentos de tipoint [0]string [1]bool [2]Reparto según la aridad propia de cada comillaOuter`2 → toma [0], [1]aridad propia 2Inner`1 → toma [2]aridad propia 1Outer<int, string>.Inner<bool>SeparadoresC# . (fuente)reflexión +ILAsm /
El vector de argumentos es plano; lo único que dice dónde cortarlo es la aridad propia de cada nivel, leída de la comilla invertida. Glass divide de contenedor a anidado y rellena los corchetes angulares de cada nivel.

La agrupación tiene que ser correcta o la salida es basura. Si Glass diera ingenuamente los tres argumentos al nombre más interno, renderizaría Inner<int, string, bool>: un tipo que no existe. Si diera el primer argumento a Outer y el resto a Inner, renderizaría Outer<int>.Inner<string> y descartaría bool en silencio. Las aridades de comilla invertida son las claves de partición, y son la razón misma por la que el mangling de nombres lleva el recuento propio en vez del total: el recuento propio es exactamente lo que necesitas para recorrer el vector plano nivel a nivel.

Los separadores son todo presentación

Una cosa más que los bytes no almacenan: el separador entre niveles. El Type.FullName de la reflexión une los tipos anidados con + (App.Outer2+Inner1), ILAsm usa / (Outer2/Inner1) y el código fuente de C# usa . (Outer.Inner). Los tres se renderizan sobre la misma fila NestedClass. Glass emite . en su salida de C# y preserva + o / en las vistas de token e IL, así que el nombre que lees siempre coincide con la superficie en la que lo estás leyendo.

Leerlo desde la CLI

No necesitas la interfaz para ver el reparto en acción. Los ID de miembro de los comentarios de documentación conservan la forma con mangling y comilla invertida, así que así es como se direcciona un tipo genérico anidado:

$ glass export ./App.dll --member "T:App.Outer`2.Inner`1" --il

La vista de IL muestra Outer2y el anidadoInner1 con los índices de parámetro !0/!1/!2 intactos. Quita --il y el C# reconstruido imprime Outer<TKey, TValue>.Inner<TState> para la definición abierta, con las comillas invertidas eliminadas y los corchetes angulares de cada nivel rellenados desde su porción de la lista de parámetros. Apunta Glass a un sitio de llamada que construye el tipo cerrado y la misma maquinaria renderiza Outer<int, string>.Inner<bool>.

Advertencias y dónde se complica

Un par de límites honestos. La aridad de la comilla invertida es una convención de C#, no una regla del CLR: un lenguaje que no sea C#, o IL escrito a mano, puede emitir un tipo genérico cuyo nombre no lleve ninguna comilla invertida, o un recuento de comilla invertida que no concuerde con sus filas GenericParam. Cuando eso ocurre, Glass confía en la tabla GenericParam y en la cadena NestedClass, no en la cadena de texto, porque las tablas son lo que el tiempo de ejecución enlaza en realidad. Y las cadenas profundamente anidadas —un genérico anidado en un genérico anidado en un genérico— solo extienden el mismo reparto: lee la aridad propia de cada nivel, consume esa cantidad de argumentos, recurre. La aritmética es simple; la disciplina consiste en no confundir nunca la aridad propia con la aridad total, porque los metadatos te entregan ambas y las usan para cosas distintas.

Conclusión

Un tipo genérico anidado se almacena como tres hechos separados que nunca se tocan: un nombre con mangling en el heap #Strings que cuenta solo los parámetros que el tipo añade, una fila NestedClass que registra dentro de qué está anidado, y una lista GenericParam que contiene cada parámetro en el ámbito. Construirlo produce un cuarto: un vector plano y sin agrupar de argumentos de tipo. Glass.NET lee los cuatro, recorre la cadena de contenedores, divide el vector plano según la aridad propia de cada nivel y une el resultado con el separador adecuado para la vista en la que estás. Es un pequeño rincón de los metadatos, y es por lo que descompilar bien un nombre genérico anidado significa leer las tablas, no confiar en la cadena de texto. Consigue la versión gratuita en la página de descarga de Glass.NET y abre la vista de IL en el próximo Outer<...>.Inner<...> que necesites leer.

Prueba Nebula.NET

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