Décompiler allows ref struct : toute la fonctionnalité tient dans un bit de métadonnées, et le perdre restreint votre contrat en silence
L'anti-contrainte allows ref struct de C# 13 ne produit aucun IL dans le corps de la méthode. Elle vit entièrement dans un bit de GenericParameterAttributes (AllowByRefLike, 0x20) sur un paramètre générique — voyez comment Glass.NET le relit.
La plupart des fonctionnalités du langage C# laissent une trace dans le flux d’instructions. Une méthode async devient une machine à états que vous pouvez parcourir pas à pas ; un yield return devient un MoveNext avec une étiquette vers laquelle on saute ; même un using n’est qu’un try/finally autour d’un Dispose. Un décompilateur gagne sa vie en lisant ces instructions et en les repliant dans la syntaxe qui les a produites.
L’anti-contrainte allows ref struct de C# 13 est le genre de fonctionnalité opposé. Elle ne produit aucun IL dans le corps de la méthode. La fonctionnalité entière est un bit dans une table de métadonnées, activé sur un paramètre générique. Cela en fait l’un des cas d’étude les plus nets qui soient sur la raison pour laquelle un décompilateur doit lire les métadonnées avec autant de soin qu’il lit le code — car ici le code ne dit rien, et un outil qui ne lit que le code vous remettra une source qui compile, s’exécute de façon identique et est silencieusement fausse. Ce billet parcourt la construction pour Glass.NET, le décompilateur .NET gratuit.
Une anti-contrainte, pas une contrainte
Une contrainte générique normale ajoute une exigence. where T : IDisposable dit qu’un argument de type doit implémenter IDisposable ; le compilateur l’impose, et les métadonnées l’enregistrent sous la forme d’une ligne dans la table GenericParamConstraints pointant vers le type IDisposable.
allows ref struct fait l’inverse. Chaque paramètre générique en .NET porte une exigence invisible et ancienne : son argument de type ne doit pas être une ref struct (Span<T>, ReadOnlySpan<T>, ou toute ref struct que vous déclarez). Cette règle existait parce que les ref structs ont des garanties de durée de vie uniquement sur la pile que le système de génériques ne pouvait historiquement pas honorer. C# 13 et .NET 9 vous permettent de lever cette règle, paramètre par paramètre, en écrivant allows ref struct. Vous n’ajoutez pas une exigence — vous retirez une interdiction. C’est pourquoi on parle d’anti-contrainte, et c’est pourquoi elle est stockée comme un bit de permission plutôt qu’une ligne de contrainte.
Le C# et l’IL vers lequel il compile
Voici un usage petit et réaliste : un pipeline qui accepte n’importe quel parseur — y compris un parseur ref struct qui enveloppe un Span<char> — du moment qu’il implémente une interface.
using System;
public interface ILineParser
{
int Parse(ReadOnlySpan<char> line);
}
public static class Pipeline
{
public static int Run<TParser>(TParser parser, ReadOnlySpan<char> input)
where TParser : ILineParser, allows ref struct
{
return parser.Parse(input);
}
}
La liste de contraintes est ILineParser, allows ref struct : une vraie contrainte d’interface, puis l’anti-contrainte. La contrainte d’interface permet au corps d’appeler parser.Parse(...) ; l’anti-contrainte est ce qui permet à un appelant d’écrire plus tard Run<MySpanParser>(...) où MySpanParser est une ref struct qui implémente ILineParser — elle-même une fonctionnalité complémentaire de C# 13.
Maintenant l’IL de Run. Le corps est un appel d’interface contraint ordinaire :
.method public hidebysig static int32
Run<byreflike (class ILineParser) TParser>(
!!TParser parser,
valuetype [System.Runtime]System.ReadOnlySpan`1<char> input) cil managed
{
.maxstack 2
ldarga.s parser
ldarg.1
constrained. !!TParser
callvirt instance int32 ILineParser::Parse(
valuetype [System.Runtime]System.ReadOnlySpan`1<char>)
ret
}
Lisez le corps et rien n’est inhabituel : charger l’adresse du récepteur, charger l’argument, constrained. callvirt vers la méthode d’interface. C’est la séquence d’instructions identique à celle que vous obtiendriez pour where TParser : ILineParser sans aucune anti-contrainte. La seule trace de la fonctionnalité est dans la ligne de signature de la méthode — le mot-clé byreflike sur le paramètre générique TParser — et byreflike n’est pas une instruction. C’est la représentation en ILAsm d’un indicateur.
Un bit dans GenericParameterAttributes
Chaque paramètre générique a une valeur GenericParameterAttributes — un petit champ de bits qui encodait déjà la variance (out/in) et les contraintes spéciales class, struct et new(). .NET 9 y a ajouté un indicateur de plus :
// System.Reflection.GenericParameterAttributes
None = 0x0000,
Covariant = 0x0001,
Contravariant = 0x0002,
ReferenceTypeConstraint = 0x0004, // where T : class
NotNullableValueTypeConstraint = 0x0008, // where T : struct
DefaultConstructorConstraint = 0x0010, // where T : new()
AllowByRefLike = 0x0020, // where T : allows ref struct (nouveau dans .NET 9)
Pour l’exemple de Run, le GenericParameterAttributes de TParser est exactement 0x0020 : AllowByRefLike activé, tout le reste à zéro. L’exigence ILineParser n’est pas dans cette valeur — c’est une ligne GenericParamConstraints distincte. Vous pouvez confirmer la séparation par réflexion :
var tp = typeof(Pipeline).GetMethod("Run")!.GetGenericArguments()[0];
tp.GenericParameterAttributes.HasFlag(GenericParameterAttributes.AllowByRefLike); // True
tp.GetGenericParameterConstraints(); // [ ILineParser ] — l'interface, rien sur ref struct
L’anti-contrainte est une chose, l’interface en est une autre, et elles proviennent de deux tables distinctes. Un décompilateur doit lire les deux et les recombiner dans l’ordre qu’exige C# : les vraies contraintes de type d’abord, puis allows ref struct en dernier.
Pourquoi le corps identique est un piège
C’est la partie qui fait que la construction mérite un billet entier. Parce que l’IL du corps ne porte aucune trace de la fonctionnalité, un décompilateur conçu uniquement pour reconstruire des instructions produira une méthode Run qui compile et s’exécute parfaitement — et dont la signature interdit précisément les arguments ref struct que l’original autorisait. Rien ne lève d’exception. Rien ne paraît faux. La méthode a simplement perdu une capacité qui vivait entièrement dans les métadonnées.
Concrètement : étant donné l’assembly original, Run<MySpanParser>(parser, text) — avec MySpanParser une ref struct qui implémente ILineParser — est légal. Décompilez avec l’anti-contrainte abandonnée, recompilez, et ce même point d’appel cesse de compiler avec « MySpanParser must be a non-ref-struct type to be used as parameter TParser ». Pour quiconque décompile afin de comprendre sa propre bibliothèque, comparer deux builds ou reciblé du code auquel il a droit, c’est un rétrécissement silencieux du contrat — le genre de régression coûteuse à remarquer parce que le code qui a changé est le code qui n’a pas changé.
Ce que Glass.NET reconstruit
Glass.NET lit les indicateurs du paramètre générique, pas seulement son corps, de sorte que l’anti-contrainte survit à l’aller-retour. Pointez-le vers le type :
glass decompile Pipeline.dll --type Pipeline --member Run
public static int Run<TParser>(TParser parser, ReadOnlySpan<char> input)
where TParser : ILineParser, allows ref struct
{
return parser.Parse(input);
}
La contrainte d’interface et l’anti-contrainte reviennent dans le bon ordre, et le corps replie le constrained. callvirt en parser.Parse(input). Pour voir les métadonnées que Glass a lues pour y arriver, demandez-lui de montrer son travail :
glass decompile Pipeline.dll --type Pipeline --member Run --constraint-check
TParser
GenericParameterAttributes = 0x0020 (AllowByRefLike)
GenericParamConstraints:
[0] ILineParser (interface)
=> where TParser : ILineParser, allows ref struct
Cette sortie place le 0x0020 brut à côté de la clause générée, afin que vous puissiez vérifier que le bit est l’anti-contrainte et non, disons, un indicateur de type valeur mal lu. Ajoutez --il pour confirmer l’autre moitié de l’histoire — que le corps sous la signature est un appel d’interface contraint ordinaire sans rien de spécifique à la fonctionnalité :
glass decompile Pipeline.dll --type Pipeline --member Run --il
Le panneau IL affiche byreflike sur le paramètre dans la ligne de signature .method et la simple séquence constrained. callvirt en dessous. Dans l’interface Avalonia, la même séparation se voit d’un coup d’œil : le nœud du paramètre générique sous Run liste ses indicateurs décodés, et la vue IL synchronisée met en évidence le mot-clé de la signature tandis que le corps ne porte aucune trace de la fonctionnalité. Si vous inspectez une dépendance depuis un assistant IA, le serveur MCP expose la même reconstruction — glass mcp permet à l’assistant d’appeler glass_decompile et de lire la clause allows ref struct lui-même, le tout en inspection statique et en lecture seule, sans rien exécuter.
À retenir
allows ref struct est la rare fonctionnalité à empreinte exécutable nulle. Le compilateur l’exprime comme un seul bit — AllowByRefLike, 0x20 — sur un paramètre générique, et laisse le corps de la méthode exactement tel qu’il serait sans elle. C’est précisément pourquoi lire les corps ne suffit pas : la source fidèle vit dans les métadonnées, et un outil qui ignore l’indicateur vous remettra du code qui compile, s’exécute pareil et refuse en silence les arguments ref struct que l’auteur a délibérément autorisés. Relire ce bit unique, et placer la clause au bon endroit dans la liste de contraintes, c’est tout le travail — et c’est la différence entre une source qui paraît correcte et une source qui l’est.
Glass.NET est un décompilateur .NET gratuit doté d’une interface Avalonia native de Visual Studio, d’une CLI et d’un serveur MCP. Téléchargez-le et lisez les métadonnées que votre compilateur a laissées derrière lui.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.