Comment un décompilateur lit une surcharge covariante
C# 9 autorise une substitution à renvoyer un type plus dérivé, mais le CLR n'a aucun emplacement pour une méthode dont la signature diffère de celle qu'elle substitue. Le compilateur masque cela avec un .override explicite et un marqueur PreserveBaseOverrides : voici exactement ce que lit Glass.NET pour distinguer une substitution covariante d'une implémentation explicite d'interface.
C# 9 a permis d”écrire la substitution que tout le monde attendait depuis vingt ans : un Clone() sur Dog qui renvoie Dog, et non Animal. Cela se lit comme une banalité. En dessous, c”est l”un des rares endroits où le compilateur C# doit émettre des métadonnées que les règles normales de substitution du CLR interdisent, puis corriger le comportement du runtime avec un attribut pour le rendre sûr. Pour quiconque lit un assemblage compilé, une substitution covariante ressemble de façon alarmante à une implémentation explicite d”interface — la même directive .override, la même forme inhabituelle — et confondre les deux produit du code décompilé qui ne compile pas. Les distinguer est un problème purement de métadonnées, et une bonne fenêtre sur la manière dont un décompilateur raisonne sur la vtable.
La vraie question
Le CLR apparie une substitution virtuelle avec la méthode qu”elle substitue en faisant correspondre le nom et la signature complète, type de retour compris. C”est toute la raison pour laquelle la substitution « fonctionne simplement » sans aucun câblage explicite. Une substitution covariante enfreint la règle à dessein : Dog Clone() et Animal Clone() ont des types de retour différents, donc selon la logique par défaut du runtime ce sont deux méthodes différentes dans deux emplacements différents de la vtable. Pourtant, le langage exige qu”appeler Clone() via une référence Animal atterrisse sur Dog.Clone(). Quelque chose doit récupérer l”emplacement de la base pour une méthode que le runtime considérerait autrement comme sans rapport.
Ainsi, la question à laquelle Glass répond n”est pas « que fait cette substitution » mais « cette ligne .override récupère-t-elle un emplacement de vtable d”une classe de base pour un type de retour plus dérivé, ou implémente-t-elle une méthode d”interface ? » Il s”agit de la même directive pointant vers deux sortes de cibles différentes, et seules les métadonnées de la cible les distinguent.
Ce que le compilateur émet réellement
Partons du code que tout le monde écrit :
public class Animal
{
public virtual Animal Clone() => new Animal();
}
public class Dog : Animal
{
public override Dog Clone() => new Dog();
}
Dog.Clone renvoie Dog. En IL, la méthode conserve le nom et le caractère virtuel de la base mais ne peut pas réutiliser l”emplacement par signature, car la signature diffère. Le compilateur émet trois choses dont une substitution normale n”a jamais besoin :
.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
}
Lisez les trois marqueurs dans l”ordre. D”abord, le type de retour sur la ligne .method est Dog, pas Animal — c”est toute la fonctionnalité, visible juste là dans la signature. Ensuite, la directive .override nomme explicitement Animal::Clone() ; c”est une ligne dans la table MethodImpl, la même table qui enregistre les implémentations explicites d”interface. Elle dit « ce corps implémente cet emplacement », remplaçant à la main l”appariement par signature du runtime. Troisièmement, [PreserveBaseOverrides] est apposé sur la méthode afin que le runtime continue de résoudre le corps le plus dérivé dans cet emplacement même après qu”une autre sous-classe dérive à nouveau.
Le détail crucial pour un décompilateur : il n”y a pas de newslot. La méthode réutilise délibérément l”emplacement de la base. Une implémentation explicite d”interface, en revanche, vit dans son propre emplacement et est private final newslot virtual. Ce seul indicateur, plus ce vers quoi pointe le .override, constitue l”essentiel de la réponse.
L”heuristique de récupération
Glass traite chaque ligne MethodImpl comme une bifurcation. Pour que la ligne soit représentée comme un override covariant, quatre faits doivent se vérifier ensemble — lus directement dans les métadonnées, sans deviner :
- La méthode substituée vit sur une classe de base, pas sur une interface. Résolvez la cible du
.override; si son type déclarant est une interface, il s”agit d”une implémentation explicite d”interface et le chemin covariant s”arrête immédiatement. - La méthode d”implémentation et la cible partagent un nom et une liste de paramètres.
Clone()avecClone(), paramètres identiques. Une substitution covariante ne peut pas renommer ; une divergence ici signifie qu”il se passe autre chose. - Le type de retour de la méthode d”implémentation est assignable au type de retour de la cible.
Dogdérive d”Animal, doncDogest un retour covariant légal pour un emplacement typéAnimal. Glass parcourt la chaîne de types de base (et, pour les interfaces renvoyées de façon covariante, l”ensemble des interfaces implémentées) pour confirmer la relation. Si les types de retour sont identiques, aucune covariance n”est en jeu et la méthode n”aurait pas eu besoin d”un.overrideexplicite du tout — ce qui est en soi un signal que la ligne signifie quelque chose d”inhabituel. - La méthode réutilise l”emplacement de base (sans
newslot) et est marquée[PreserveBaseOverrides]. C”est l”empreinte du runtime lui-même pour cette fonctionnalité. Sa présence transforme une correspondance plausible en une correspondance certaine.
Lorsque les quatre se vérifient, Glass retire la directive .override et l”attribut du code source imprimé — ce sont de la comptabilité du compilateur et du runtime, pas l”intention de l”auteur — et émet la ligne propre que le développeur a réellement écrite :
public override Dog Clone() => new Dog();
L”attribut et le MethodImpl restent visibles dans la vue IL pour qui les veut ; ils n”ont simplement pas leur place dans le C# reconstruit, car les réémettre à la main serait au mieux redondant et au pire une erreur de compilation.
Quand il s”agit plutôt d”une implémentation d”interface
La même forme apparaît lorsqu”une classe implémente une méthode d”interface avec une accessibilité différente ou pour lever l”ambiguïté entre deux interfaces :
public interface ICloneableAnimal { Animal Clone(); }
public class Cat : ICloneableAnimal
{
Animal ICloneableAnimal.Clone() => new Cat(); // implémentation explicite
}
Ici le MethodImpl cible ICloneableAnimal::Clone, la méthode est private final newslot virtual, et il n”y a pas de [PreserveBaseOverrides]. Les étapes 1 et 4 échouent toutes deux. Glass la représente comme Animal ICloneableAnimal.Clone(), entièrement qualifiée, ce qui est le seul C# légal pour un membre d”interface explicite. Confondre les deux est le bug classique du décompilateur : imprimer une substitution covariante comme une implémentation explicite nomme un membre qui n”existe pas ; imprimer une implémentation explicite comme une simple substitution change son accessibilité et casse le type.
Réserves et la limite honnête
Les retours covariants fonctionnent aussi lorsque le type de retour est une interface que le type de retour de la méthode dérivée implémente, et à travers les instanciations génériques — Glass gère les deux en résolvant l”assignabilité de l”étape 3 à travers l”ensemble des interfaces, et pas seulement la chaîne de classe de base. La fonctionnalité est également conditionnée par le runtime : elle nécessite RuntimeFeature.CovariantReturnsOfClasses, ce qui signifie qu”elle n”apparaît que dans les assemblages ciblant .NET 5+. Sur des cibles plus anciennes, la même intention s”exprimait avec un protected virtual Animal CloneCore() écrit à la main plus une ombre new Dog Clone(), et Glass vous montrera fidèlement ce motif : il ne peut pas inventer une substitution covariante que le compilateur n”a jamais émise.
Le seul cas réellement indécidable est une substitution explicite qui renomme tout en rétrécissant le type de retour via une plomberie MethodImpl non publique émise par un langage autre que C#. Il n”existe aucune syntaxe C# qui à la fois renomme et substitue de façon covariante, donc Glass se rabat sur la forme explicite et entièrement qualifiée. Cela maintient la sortie compilable, règle qui l”emporte toujours sur l”élégance.
À retenir
Une substitution covariante est la rare fonctionnalité C# qui ne peut pas s”exprimer dans le modèle ordinaire de substitution du CLR ; le compilateur recourt donc à la même machinerie de substitution explicite que les interfaces, puis la stabilise avec [PreserveBaseOverrides]. Un décompilateur qui ne lit que la directive .override la confondra avec une implémentation d”interface ; Glass.NET lit ce que la directive cible — une classe de base, un retour supertype, un emplacement réutilisé — et récupère l”unique ligne override propre que l”auteur a écrite, laissant la comptabilité du runtime là où elle doit être, dans la vue IL. Savoir laquelle de ces deux lectures vous regardez, c”est la différence entre du code décompilé qui se reconstruit et du code décompilé qui semble seulement plausible.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.