Cómo un decompilador lee una sobrescritura covariante
C# 9 permite que una sobrescritura devuelva un tipo más derivado, pero el CLR no tiene ninguna ranura para un método cuya firma difiere de la que sobrescribe. El compilador lo disimula con un .override explícito y un marcador PreserveBaseOverrides: esto es exactamente lo que lee Glass.NET para distinguir una sobrescritura covariante de una implementación explícita de interfaz.
C# 9 permitió escribir la sobrescritura que todo el mundo había deseado durante veinte años: un Clone() en Dog que devuelve Dog, no Animal. Se lee como una trivialidad. Por debajo es uno de los pocos lugares donde el compilador de C# tiene que emitir metadatos que las reglas normales de sobrescritura del CLR prohíben, y luego parchear el comportamiento del runtime con un atributo para hacerlo seguro. Para quien lee un ensamblado compilado, una sobrescritura covariante se parece alarmantemente a una implementación explícita de interfaz —la misma directiva .override, la misma forma inusual— y confundir las dos produce código decompilado que no compila. Distinguirlas es un problema puro de metadatos y una buena ventana a cómo razona un decompilador sobre la vtable.
La pregunta real
El CLR empareja una sobrescritura virtual con el método que sobrescribe haciendo coincidir nombre y firma completa, tipo de retorno incluido. Esa es toda la razón por la que la sobrescritura “simplemente funciona” sin ningún cableado explícito. Una sobrescritura covariante rompe la regla a propósito: Dog Clone() y Animal Clone() tienen tipos de retorno distintos, así que por la lógica predeterminada del runtime son dos métodos diferentes en dos ranuras diferentes de la vtable. Sin embargo, el lenguaje exige que llamar a Clone() a través de una referencia Animal aterrice en Dog.Clone(). Algo tiene que reclamar la ranura de la base para un método que el runtime consideraría, de otro modo, no relacionado.
Así que la pregunta que Glass responde no es “¿qué hace esta sobrescritura?” sino “¿esta fila .override está reclamando una ranura de vtable de una clase base para un tipo de retorno más derivado, o está implementando un método de interfaz?” Son la misma directiva apuntando a dos clases distintas de destino, y solo los metadatos del destino las distinguen.
Lo que el compilador emite realmente
Partamos del código que todos escriben:
public class Animal
{
public virtual Animal Clone() => new Animal();
}
public class Dog : Animal
{
public override Dog Clone() => new Dog();
}
Dog.Clone devuelve Dog. En IL, el método conserva el nombre y el carácter virtual de la base pero no puede reutilizar la ranura por firma, porque la firma difiere. El compilador emite tres cosas que una sobrescritura normal nunca necesita:
.method public hidebysig virtual instance class Dog
Clone() cil managed
{
.custom instance void [System.Runtime]System.Runtime.CompilerServices.PreserveBaseOverridesAttribute::.ctor() = ( 01 00 00 00 )
.override method instance class Animal Animal::Clone()
newobj instance void Dog::.ctor()
ret
}
Lee los tres marcadores en orden. Primero, el tipo de retorno en la línea .method es Dog, no Animal: esa es toda la característica, visible ahí mismo en la firma. Segundo, la directiva .override nombra Animal::Clone() explícitamente; es una fila en la tabla MethodImpl, la misma tabla que registra las implementaciones explícitas de interfaz. Dice “este cuerpo implementa esa ranura”, anulando a mano el emparejamiento por firma del runtime. Tercero, [PreserveBaseOverrides] queda estampado en el método para que el runtime siga resolviendo el cuerpo más derivado en esa ranura incluso después de que otra subclase vuelva a derivar.
El detalle crucial para un decompilador: no hay newslot. El método reutiliza deliberadamente la ranura base. Una implementación explícita de interfaz, en cambio, vive en su propia ranura y es private final newslot virtual. Esa única bandera, más aquello a lo que apunta el .override, es la mayor parte de la respuesta.
La heurística de recuperación
Glass trata cada fila MethodImpl como una bifurcación. Para que la fila se represente como un override covariante, cuatro hechos deben darse juntos —leídos directamente de los metadatos, sin adivinar:
- El método sobrescrito vive en una clase base, no en una interfaz. Resuelve el destino del
.override; si su tipo declarante es una interfaz, se trata de una implementación explícita de interfaz y el camino covariante termina de inmediato. - El método que implementa y el destino comparten nombre y lista de parámetros.
Clone()conClone(), parámetros idénticos. Una sobrescritura covariante no puede renombrar; una divergencia aquí significa que ocurre otra cosa. - El tipo de retorno del método que implementa es asignable al tipo de retorno del destino.
Dogderiva deAnimal, así queDoges un retorno covariante legal para una ranura tipadaAnimal. Glass recorre la cadena de tipos base (y, para interfaces devueltas covariantemente, el conjunto de interfaces implementadas) para confirmar la relación. Si los tipos de retorno son idénticos, no hay covarianza y el método no habría necesitado un.overrideexplícito en absoluto, lo cual es en sí mismo una señal de que la fila significa algo inusual. - El método reutiliza la ranura base (sin
newslot) y está marcado con[PreserveBaseOverrides]. Esta es la huella del propio runtime para la característica. Su presencia convierte una coincidencia plausible en una certera.
Cuando los cuatro se cumplen, Glass descarta la directiva .override y el atributo del código fuente impreso —son contabilidad del compilador y del runtime, no intención del autor— y emite la línea limpia que el desarrollador escribió de verdad:
public override Dog Clone() => new Dog();
El atributo y el MethodImpl siguen siendo visibles en la vista de IL para quien los quiera; simplemente no pertenecen al C# reconstruido, porque volver a emitirlos a mano sería redundante en el mejor de los casos y un error de compilación en el peor.
Cuando es, en cambio, una implementación de interfaz
La misma forma aparece cuando una clase implementa un método de interfaz con una accesibilidad distinta o para desambiguar dos interfaces:
public interface ICloneableAnimal { Animal Clone(); }
public class Cat : ICloneableAnimal
{
Animal ICloneableAnimal.Clone() => new Cat(); // implementación explícita
}
Aquí el MethodImpl apunta a ICloneableAnimal::Clone, el método es private final newslot virtual y no hay [PreserveBaseOverrides]. Los pasos 1 y 4 fallan ambos. Glass lo representa como Animal ICloneableAnimal.Clone(), completamente calificado, que es el único C# legal para un miembro de interfaz explícito. Confundir ambos es el error clásico del decompilador: imprimir una sobrescritura covariante como una implementación explícita nombra un miembro que no existe; imprimir una implementación explícita como una sobrescritura simple cambia su accesibilidad y rompe el tipo.
Salvedades y el límite honesto
Los retornos covariantes también funcionan cuando el tipo de retorno es una interfaz que el tipo de retorno del método derivado implementa, y a través de instanciaciones genéricas: Glass maneja ambos resolviendo la asignabilidad del paso 3 a través del conjunto de interfaces, no solo de la cadena de clase base. La característica también está condicionada por el runtime: requiere RuntimeFeature.CovariantReturnsOfClasses, lo que significa que solo aparece en ensamblados dirigidos a .NET 5+. En destinos más antiguos la misma intención se expresaba con un protected virtual Animal CloneCore() escrito a mano más una sombra new Dog Clone(), y Glass te mostrará fielmente ese patrón: no puede inventar una sobrescritura covariante que el compilador nunca emitió.
El único caso genuinamente indecidible es una sobrescritura explícita que renombra a la vez que estrecha el tipo de retorno mediante una fontanería MethodImpl no pública que emitió un lenguaje distinto de C#. No existe sintaxis de C# que a la vez renombre y sobrescriba covariantemente, así que Glass recurre a la forma explícita y completamente calificada. Eso mantiene la salida compilable, que es la regla que prevalece sobre la elegancia siempre.
Conclusión
Una sobrescritura covariante es la rara característica de C# que no puede expresarse en el modelo ordinario de sobrescritura del CLR, así que el compilador recurre a la misma maquinaria de sobrescritura explícita que usan las interfaces y luego la estabiliza con [PreserveBaseOverrides]. Un decompilador que lea solo la directiva .override la confundirá con una implementación de interfaz; Glass.NET lee aquello a lo que la directiva apunta —una clase base, un retorno supertipo, una ranura reutilizada— y recupera la única línea override limpia que el autor escribió, dejando la contabilidad del runtime donde pertenece, en la vista de IL. Saber cuál de esas dos lecturas estás mirando es la diferencia entre código decompilado que vuelve a compilar y código decompilado que solo parece plausible.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.