Skip to content
← Tous les articles
· Delta1 Labs FieldKeywordGlass

Comment le mot-clé field de C# 14 se décompile

Le mot-clé field réutilise le même <Name>k__BackingField qu'émet une propriété automatique, donc les métadonnées sont identiques. La décision de restituer field vit entièrement dans l'IL de l'accesseur. Voici comment Glass.NET le relit.

C# 14 a ajouté le mot-clé contextuel field : à l’intérieur d’un accesseur de propriété, vous pouvez désormais écrire field pour atteindre le champ de stockage synthétisé par le compilateur sans le déclarer vous-même. Il transforme le schéma courant « propriété automatique, mais avec un peu de validation » — auparavant une corvée à deux membres : un champ privé plus une propriété complète — en une seule propriété dont les accesseurs font leur travail puis lisent ou écrivent field. C’est une petite fonctionnalité au effet démesuré sur le code quotidien, et elle se répand déjà vite.

C’est aussi un problème de décompilation vraiment intéressant, car field est invisible dans les métadonnées. Le champ de stockage qu’il réutilise est le <Name>k__BackingField exact qu’émet une propriété automatique ordinaire, portant le marqueur [CompilerGenerated] exact. Pas de nouvel attribut, pas d’indicateur, rien dans la table Property qui enregistre « cette propriété a utilisé field ». Toute la différence entre { get; set; } et une propriété avec field vit à un seul endroit : les corps des méthodes accesseurs. Un décompilateur qui lit le champ et les lignes de la propriété n’apprend rien ; il doit lire l’IL de get_ et set_ et décider, pour chaque accesseur, si ce qu’il voit est un passage direct trivial ou un vrai travail.

Cet article montre les métadonnées identiques que partagent les deux constructions, les trois formes d’accesseur qui forcent la décision dans un sens ou dans l’autre, et comment Glass.NET reconstruit chacune.

métadonnées partagées — identiques pour les deux constructions.field private string '<Name>k__BackingField' .custom ... CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 )pas de nouvel attribut,pas d'indicateur « j'ai utilisé field »la seule preuve — les corps des accesseurspassage direct trivial ?get: ldarg.0; ldfld F; retset: ldarg.0; ldarg.1; stfld F; retles deux correspondent → aucun travailfait du travail avant ?set: ldarg.0; ldarg.1; dup; brtrue.s; pop; ldsfld Empty; stfld Flowering de ?? → pas un passage directGlass restituepublic string Name { get; set; }set => field = value ?? string.Empty;field — le seul nom légal du stockage

Les deux constructions qui partagent une même forme de métadonnées

Voici une propriété automatique ordinaire et une propriété avec field dont les accesseurs se trouvent être triviaux :

// Propriété automatique ordinaire
public string A { get; set; }

// mot-clé field, mais les accesseurs ne font rien de plus
public string B { get => field; set => field = value; }

Les deux compilent vers les trois mêmes éléments de métadonnées : un champ de stockage privé, un accesseur get_ et un accesseur set_. Le champ de A :

.field private string '<A>k__BackingField'
  .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor()
    = ( 01 00 00 00 )

Le champ de B est identique au nom près, '<B>k__BackingField'. Même visibilité, même [CompilerGenerated], tout pareil. Et les corps des accesseurs sont identiques eux aussi : le getter des deux est un simple chargement, le setter un simple stockage :

.method public hidebysig specialname instance string get_A () cil managed
{
  .custom instance void [...]CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 )
  ldarg.0
  ldfld string C::'<A>k__BackingField'
  ret
}
.method public hidebysig specialname instance void set_A (string 'value') cil managed
{
  .custom instance void [...]CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 )
  ldarg.0
  ldarg.1
  stfld string C::'<A>k__BackingField'
  ret
}

C’est le fait crucial : get => field; set => field = value; et { get; set; } sont le même programme. Le compilateur émet un IL identique octet pour octet. Il n’y a rien à récupérer pour un décompilateur, car il n’y a rien à distinguer — et donc la bonne réponse est la plus simple. Glass restitue les deux comme { get; set; }. Reproduire le code source de B à la lettre serait du bruit ; les deux formes sont interchangeables et la propriété automatique est ce que tout lecteur attend.

Le décompilateur reconnaît le passage direct par sa forme. Le getter doit être exactement ldarg.0; ldfld <backing>; ret, le setter exactement ldarg.0; ldarg.1; stfld <backing>; ret, et le champ doit être le <Name>k__BackingField généré par le compilateur, référencé par rien d’autre que ces deux accesseurs. Si tout cela correspond, vous avez une vraie propriété automatique, quelle que soit la syntaxe qui l’a produite.

Un setter qui fait du travail : le mot-clé field est forcé

Cassons maintenant le passage direct du côté set — la raison la plus courante de recourir à field :

public string Name
{
    get => field;
    set => field = value ?? string.Empty;
}

Le getter reste un passage direct, mais le setter exécute désormais l’opérateur de coalescence des null avant de stocker. Ce ?? string.Empty se réduit à la séquence standard dup / brtrue / pop :

.method public hidebysig specialname instance void set_Name (string 'value') cil managed
{
  ldarg.0
  ldarg.1
  dup
  brtrue.s   IL_000a
  pop
  ldsfld     string [System.Runtime]System.String::Empty
  IL_000a:
  stfld      string Person::'<Name>k__BackingField'
  ret
}

Lisez la pile : ldarg.0 dépose this pour le stfld final ; ldarg.1 charge value ; dup le copie ; brtrue.s garde la copie si elle est non nulle et saute au stockage ; sinon pop écarte le null et ldsfld String::Empty substitue la chaîne vide. Dans les deux cas, la valeur sur la pile est stockée dans le champ de stockage. Ce n’est absolument pas le passage direct à deux instructions, donc la réduction en propriété automatique est hors de question.

Il reste alors au décompilateur un problème que seul C# 14 peut résoudre proprement. Le champ de stockage est nommé <Name>k__BackingField, et ces chevrons en font un nom imprononçable — un nom que le compilateur réserve pour qu’aucun identifiant de code source ne puisse entrer en collision avec lui. Vous ne pouvez pas le taper. Avant que le mot-clé field existe, un décompilateur ici devait inventer un champ privé avec un nom légal et réécrire les deux accesseurs pour l’utiliser, transformant une propriété d’une ligne en un champ plus une propriété complète et changeant la forme du type. Désormais la reconstruction est exacte :

public string Name
{
    get => field;
    set => field = value ?? string.Empty;
}

Glass restitue le getter trivial comme get => field; (il pourrait tout aussi bien être omis, mais le garder explicite reflète l’accesseur réel) et le vrai setter avec field à la place du stockage synthétisé. La sortie recompile vers l’IL identique.

Un getter qui fait du travail : le cas asymétrique

La décision est par accesseur, pas par propriété, donc l’image miroir est tout aussi valide — un setter trivial et un getter qui calcule :

public string Display
{
    get => field ?? "(unset)";
    set => field = value;
}

Ici le setter est un simple passage direct mais le getter exécute ?? "(unset)" :

.method public hidebysig specialname instance string get_Display () cil managed
{
  ldarg.0
  ldfld      string Person::'<Display>k__BackingField'
  dup
  brtrue.s   IL_000b
  pop
  ldstr      "(unset)"
  IL_000b:
  ret
}

Le même schéma dup / brtrue / pop, cette fois en substituant un littéral quand la valeur stockée est null. Comme un accesseur fait du travail, la propriété ne peut pas se réduire à { get; set; } : la restituer ainsi abandonnerait silencieusement la valeur par défaut. Glass expose le getter avec field et laisse le setter trivial :

public string Display
{
    get => field ?? "(unset)";
    set => field = value;
}

Le même raisonnement s’étend à l’initialisation paresseuse — public Cache C => field ??= new(); — où le ??= composé du getter lit, teste, construit et stocke à travers field, et où la propriété n’a aucun setter. La forme de l’IL diffère, mais la règle qu’applique Glass est la constante dans chaque cas : trouver le champ de stockage généré par le compilateur, comparer chaque accesseur au modèle de passage direct, et restituer field pour tout accesseur qui échoue au test.

Relire une propriété avec Glass

Comme toute la décision repose sur l’IL de l’accesseur, la vue IL est le moyen le plus rapide de confirmer ce que fait réellement une propriété. Pointez Glass vers l’assembly et extrayez la propriété :

$ glass export ./People.dll --member "P:Person.Name" --il

Cela imprime le champ de stockage, les deux corps d’accesseurs et les liens MethodSemantics, pour que vous voyiez vous-même si un accesseur est un passage direct ou fait du travail avant de toucher <Name>k__BackingField. Retirez --il et Glass reconstruit le C# :

$ glass export ./People.dll --member "P:Person.Name"
public string Name
{
    get => field;
    set => field = value ?? string.Empty;
}

Vous obtenez le résultat identique dans la vue côte à côte de l’application : sélectionnez la propriété et le volet IL affiche les corps des accesseurs à côté du code source reconstruit, de sorte que le test de passage direct que le décompilateur vient de faire est là, vérifiable à l’œil. Glass utilise le même moteur ICSharpCode.Decompiler dans la CLI et dans l’interface, et tout est statique : il lit les métadonnées et l’IL et reconstruit le code source. Il n’exécute jamais les accesseurs, et c’est exactement pourquoi il est sûr de le pointer vers une dépendance sur laquelle vous hésitez encore à faire confiance.

Le mot-clé field va être partout, car il supprime le seul point de friction qui faisait que les gens écrivaient des propriétés à champ de stockage complet. Savoir qu’il ne laisse aucune empreinte dans les métadonnées — qu’un décompilateur le récupère purement à partir de la forme du corps de l’accesseur — vaut la peine la prochaine fois que vous lirez comment une bibliothèque valide une propriété à laquelle vous passez des données, ou que vous déboguerez pourquoi votre propre setter a normalisé une valeur inattendue. Récupérez la dernière version sur la page de téléchargement de Glass.NET et lisez le prochain field que vous rencontrez.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.