Décompiler l'expression `with` : comment Glass.NET reconstruit les sites de clonage de records
Une expression `with` ne laisse aucun mot-clé dans l'IL : c'est un appel virtuel à une méthode cachée `<Clone>$` suivie d'une série de setters init-only. Glass.NET relit cette forme exacte sous la forme `record with { … }`. Voici le parcours complet source → IL → C# reconstruit pour la mutation non destructive.
Une expression with est l’un des éléments les plus magiques en apparence du C# moderne : vous prenez un record immuable, écrivez original with { Price = 9.99m } et obtenez une copie neuve avec un champ modifié et tout le reste intact. Mutation non destructive. Mais il n’existe aucun opcode with, aucune instruction « clone ceci mais change cela » dans le CLR. Une fois que le compilateur a terminé, toute l’expression est devenue un simple appel de méthode virtuelle suivi de quelques stockages de champs. Reconstruire le mot-clé with à partir de cette forme est une correspondance de motif petite et précise, et c’est un bon moyen de voir comment Glass.NET, le décompilateur .NET gratuit, reconstruit des fonctionnalités du langage qui n’existent que sous forme de conventions dans les métadonnées.
Cet article suit un site with jusqu’à l’IL puis le remonte vers le C#. Si vous voulez la mécanique de la déclaration du record elle-même (EqualityContract, égalité par valeur, PrintMembers), c’est une empreinte distincte ; ici seul nous intéresse le site d’appel de clonage.
Le code source
Commençons avec un record minuscule et une unique mise à jour non destructive :
public record Product(string Name, decimal Price, int Stock);
public static class Catalog
{
public static Product Discount(Product p, decimal newPrice) =>
p with { Price = newPrice, Stock = p.Stock - 1 };
}
Discount renvoie un nouveau Product qui partage Name, prend newPrice et décrémente Stock, sans jamais muter p. Deux choses doivent se produire en coulisses : l’objet doit être copié, puis les deux membres nommés doivent être écrasés sur la copie. C’est exactement ce que montre l’IL.
Ce que le compilateur émet
Le record lui-même gagne deux membres synthétisés qui rendent with possible : un constructeur de copie protégé qui clone chaque champ et une méthode de clonage virtuelle que le compilateur C# nomme <Clone>$ (les chevrons garantissent que vous ne pourrez jamais entrer en collision avec elle dans le code source). La méthode de clonage appelle simplement le constructeur de copie :
// Synthétisé sur le record — montré ici avec des noms lisibles
protected Product(Product original)
{
Name = original.Name;
Price = original.Price;
Stock = original.Stock;
}
public virtual Product <Clone>$() => new Product(this);
L’expression with dans Discount se compile en un callvirt de <Clone>$, puis en un stockage dans chaque propriété nommée à l’intérieur des accolades. Voici le corps de la méthode tel que ildasm/Glass l’affiche :
.method public hidebysig static
class Product Discount (class Product p, valuetype [System.Runtime]System.Decimal newPrice) cil managed
{
.maxstack 3
.locals init (class Product V_0)
IL_0000: ldarg.0 // p
IL_0001: callvirt instance class Product Product::'<Clone>$'()
IL_0006: stloc.0 // V_0 = clone of p
IL_0007: ldloc.0
IL_0008: ldarg.1 // newPrice
IL_0009: callvirt instance void Product::set_Price(valuetype [System.Runtime]System.Decimal)
IL_000e: ldloc.0
IL_000f: ldarg.0 // p
IL_0010: callvirt instance int32 Product::get_Stock()
IL_0015: ldc.i4.1
IL_0016: sub
IL_0017: callvirt instance void Product::set_Stock(int32)
IL_001c: ldloc.0
IL_001d: ret
}
Lisez-le de haut en bas et la forme est indéniable : un callvirt vers une méthode nommée <Clone>$, son résultat garé dans un temporaire, puis une séquence d’appels de setters de propriétés sur ce même temporaire et, enfin, le temporaire est renvoyé. Les setters sont set_Price et set_Stock, les setters init-only du record, invocables ici parce que le constructeur de copie et l’abaissement du with s’exécutent dans un contexte d’initialisation.
Le motif que Glass détecte
Glass ne cherche pas un drapeau qui dirait « ceci était un with ». Un tel drapeau n’existe pas. Il détecte la signature structurelle de l’expression abaissée :
La règle de reconnaissance, énoncée avec précision, est : un appel à une méthode <Clone>$ synthétisée dont le résultat est stocké dans un temporaire, où ce temporaire est ensuite muté uniquement via des setters init-only (ou des stockages de champ directs) avant d’être utilisé comme valeur. Lorsque cela est vrai, l’appel de clonage plus la série de setters se réduisent en une unique expression with ; le récepteur de <Clone>$ devient l’opérande précédant with, et chaque setter devient une entrée Member = value à l’intérieur des accolades.
Ce que Glass reconstruit
Passez-le dans le décompilateur :
glass decompile Catalog.dll --type Catalog --member Discount
Glass produit :
public static Product Discount(Product p, decimal newPrice)
{
return p with
{
Price = newPrice,
Stock = p.Stock - 1
};
}
C’est le code source d’origine, jusqu’à l’ordre des entrées de l’initialiseur (Glass préserve l’ordre des setters de l’IL, qui est l’ordre du code source). Le temporaire V_0, l’appel à <Clone>$ et les deux invocations set_ ont tous disparu dans le mot-clé, ce qui est la reconstruction honnête, car c’est précisément ce que le programmeur C# a écrit.
Quand le motif n’est pas vérifié
L’intérêt d’une correspondance structurelle est qu’elle se dégrade honnêtement. Si Glass voit un appel à <Clone>$ dont le résultat est muté d’une manière qu’un bloc with ne peut pas exprimer — par exemple une boucle qui écrit des éléments, un appel de méthode qui n’est pas un setter init, ou un branchement entre le clonage et les stockages — il ne force pas un with. Il se rabat sur l’affichage de l’appel de clonage littéral et des affectations individuelles, car inventer un with là serait mentir sur le flux de contrôle. Vous pouvez le constater vous-même en passant --no-pattern with pour comparer la forme abaissée brute à la forme reconstruite :
glass decompile Catalog.dll --member Discount --no-pattern with
public static Product Discount(Product p, decimal newPrice)
{
Product product = p.<Clone>$(); // raw: the clone call is explicit
product.Price = newPrice;
product.Stock = p.Stock - 1;
return product;
}
Voir les deux formes côte à côte est utile lorsque vous auditez un assembly inconnu — peut-être votre propre build de release sans PDB, ou une bibliothèque tierce avec laquelle vous devez interopérer — et que vous voulez confirmer qu’une méthode fait réellement une simple copie-puis-affectation et non quelque chose de plus subtil caché derrière un clonage.
Les record structs : une forme différente
Une subtilité qui mérite d’être connue. Un record struct n’a pas de méthode <Clone>$, car les types valeur sont copiés par affectation : il n’y a rien à appeler. Pour readonly record struct Point(int X, int Y), l’expression with s’abaisse en une copie du struct sur la pile (un ldobj/stloc de la valeur complète, ou simplement une nouvelle variable locale initialisée depuis la source) suivie de la même série de setters init. Glass reconnaît cette forme aussi : une copie par valeur d’un record struct suivie de setters init-only est la variante struct de with, et il reconstruit la même syntaxe source with { … }. Le signal diffère — une copie de struct au lieu d’un callvirt <Clone>$() — mais la règle de reconstruction est la même : copier, puis écraser les membres nommés, puis utiliser.
Pourquoi cela compte pour lire du vrai code
Les expressions with sont partout dans le C# moderne : objets de configuration traversant un pipeline, mises à jour d’état dans un reducer, DTO copiés avec un champ ajusté. Lorsque vous décompilez ce code sans reconnaissance, vous obtenez un fouillis de temporaires <Clone>$() et de setters éparpillés qui masque l’unique intention derrière chacun : faire une copie avec ces changements. Réduire cela de nouveau à with, c’est la différence entre lire la conception de quelqu’un et lire la comptabilité du compilateur.
Glass est un décompilateur gratuit et purement statique conçu exactement pour ce type de compréhension : vos propres assemblies, vos dépendances, vos builds hérités. Il lit l’IL vers le C# ; il n’exécute, ne patche ni ne modifie rien. Pointez-le vers une DLL dans l’interface native de Visual Studio, dans la CLI ou via MCP et le mot-clé with réapparaît partout où la forme cloner-puis-affecter indique qu’il devrait être.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.