Skip to content
← Todas las publicaciones
· Delta1 Labs FieldKeywordGlass

Cómo se decompila la palabra clave field de C# 14

La palabra clave field reutiliza el mismo <Name>k__BackingField que emite una propiedad automática, así que los metadatos son idénticos. La decisión de representar field vive por completo en el IL del descriptor de acceso. Así lo lee Glass.NET.

C# 14 añadió la palabra clave contextual field: dentro del descriptor de acceso de una propiedad ahora puedes escribir field para alcanzar el campo de respaldo sintetizado por el compilador sin declararlo tú mismo. Convierte el patrón común de “propiedad automática, pero con un poco de validación” —antes una tarea de dos miembros: un campo privado más una propiedad completa— en una sola propiedad cuyos descriptores hacen su trabajo y luego leen o escriben field. Es una característica pequeña con un efecto enorme en el código cotidiano, y ya se está extendiendo rápido.

También es un problema de decompilación genuinamente interesante, porque field es invisible en los metadatos. El campo de respaldo que reutiliza es el mismísimo <Name>k__BackingField que emite una propiedad automática normal, con la mismísima marca [CompilerGenerated]. No hay nuevo atributo, ni bandera, ni nada en la tabla Property que registre “esta propiedad usó field”. La diferencia entera entre { get; set; } y una propiedad con field vive en un solo lugar: los cuerpos de los métodos descriptores de acceso. Un decompilador que lee el campo y las filas de la propiedad no aprende nada; tiene que leer el IL de get_ y set_ y decidir, por cada descriptor, si lo que ve es un paso directo trivial o trabajo real.

Este artículo muestra los metadatos idénticos que comparten las dos construcciones, las tres formas de descriptor que fuerzan la decisión en un sentido o en otro, y cómo Glass.NET reconstruye cada una.

metadatos compartidos — idénticos para ambas construcciones.field private string '<Name>k__BackingField' .custom ... CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 )sin nuevo atributo,sin bandera "usé field"la única evidencia — los cuerpos de los descriptores¿paso directo trivial?get: ldarg.0; ldfld F; retset: ldarg.0; ldarg.1; stfld F; retambos coinciden → sin trabajo¿hace trabajo antes?set: ldarg.0; ldarg.1; dup; brtrue.s; pop; ldsfld Empty; stfld Flowering de ?? → no es paso directoGlass representapublic string Name { get; set; }set => field = value ?? string.Empty;field — el único nombre legal del almacén

Las dos construcciones que comparten una misma forma de metadatos

Aquí hay una propiedad automática normal y una propiedad con field cuyos descriptores resultan ser triviales:

// Propiedad automática normal
public string A { get; set; }

// palabra clave field, pero los descriptores no hacen nada extra
public string B { get => field; set => field = value; }

Ambas compilan a las mismas tres piezas de metadatos: un campo de respaldo privado, un descriptor get_ y un descriptor set_. El campo de A:

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

El campo de B es idéntico salvo por el nombre, '<B>k__BackingField'. La misma visibilidad, el mismo [CompilerGenerated], todo igual. Y los cuerpos de los descriptores también son idénticos: el getter de ambos es una carga simple, el setter un almacenamiento simple:

.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
}

Este es el hecho crucial: get => field; set => field = value; y { get; set; } son el mismo programa. El compilador emite IL idéntico byte a byte. No hay nada que recuperar para un decompilador, porque no hay nada que distinguir, y por eso la respuesta correcta es la más simple. Glass representa ambas como { get; set; }. Reproducir el código de B al pie de la letra sería ruido; las dos formas son intercambiables y la propiedad automática es lo que todo lector espera.

El decompilador reconoce el paso directo por su forma. El getter debe ser exactamente ldarg.0; ldfld <backing>; ret, el setter exactamente ldarg.0; ldarg.1; stfld <backing>; ret, y el campo debe ser el <Name>k__BackingField generado por el compilador, referenciado solo por estos dos descriptores. Si todo eso coincide, tienes una verdadera propiedad automática, sea cual sea la sintaxis que la produjo.

Un setter que hace trabajo: la palabra clave field es forzosa

Ahora rompamos el paso directo del lado set, la razón más común para recurrir a field:

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

El getter sigue siendo un paso directo, pero el setter ahora ejecuta el operador de fusión de null antes de almacenar. Ese ?? string.Empty se reduce a la secuencia estándar 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
}

Lee la pila: ldarg.0 deja this para el stfld final; ldarg.1 carga value; dup lo copia; brtrue.s conserva la copia si no es null y salta al almacenamiento; en caso contrario pop descarta el null y ldsfld String::Empty sustituye la cadena vacía. De cualquier modo, el valor en la pila se almacena en el campo de respaldo. Esto no es en absoluto el paso directo de dos instrucciones, así que el colapso a propiedad automática queda descartado.

Eso le deja al decompilador un problema que solo C# 14 puede resolver con limpieza. El campo de respaldo se llama <Name>k__BackingField, y esos corchetes angulares lo convierten en un nombre impronunciable: un nombre que el compilador reserva para que ningún identificador de código fuente pueda colisionar con él. No puedes escribirlo. Antes de que existiera la palabra clave field, un decompilador aquí tenía que inventar un campo privado con un nombre legal y reescribir ambos descriptores para usarlo, convirtiendo una propiedad de una línea en un campo más una propiedad completa y cambiando la forma del tipo. Ahora la reconstrucción es exacta:

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

Glass representa el getter trivial como get => field; (podría igualmente omitirse, pero mantenerlo explícito refleja el descriptor real) y el setter real con field en lugar del almacén sintetizado. La salida vuelve a compilar al IL idéntico.

Un getter que hace trabajo: el caso asimétrico

La decisión es por cada descriptor, no por propiedad, así que la imagen espejo es igual de válida: un setter trivial y un getter que calcula:

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

Aquí el setter es un paso directo simple pero el getter ejecuta ?? "(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
}

El mismo patrón dup / brtrue / pop, esta vez sustituyendo un literal cuando el valor almacenado es null. Como un descriptor hace trabajo, la propiedad no puede colapsar a { get; set; }: representarla así descartaría silenciosamente el valor por defecto. Glass expone el getter con field y deja el setter trivial:

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

El mismo razonamiento se extiende a la inicialización perezosa —public Cache C => field ??= new();— donde el ??= compuesto del getter lee, prueba, construye y almacena a través de field, y la propiedad no tiene setter en absoluto. La forma del IL difiere, pero la regla que aplica Glass es la constante en cada caso: encontrar el campo de respaldo generado por el compilador, comparar cada descriptor con la plantilla de paso directo, y representar field para cualquier descriptor que no pase la prueba.

Leer una de vuelta con Glass

Como toda la decisión se apoya en el IL del descriptor, la vista de IL es la forma más rápida de confirmar qué hace realmente una propiedad. Apunta Glass al ensamblado y vuelca la propiedad:

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

Eso imprime el campo de respaldo, ambos cuerpos de descriptor y los vínculos MethodSemantics, para que veas por ti mismo si un descriptor es un paso directo o hace trabajo antes de tocar <Name>k__BackingField. Quita --il y Glass reconstruye el C#:

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

Obtienes el resultado idéntico en la vista lado a lado de la aplicación: selecciona la propiedad y el panel de IL muestra los cuerpos de los descriptores junto al código fuente reconstruido, así la prueba de paso directo que el decompilador acaba de hacer está ahí para verificarla a ojo. Glass usa el mismo motor ICSharpCode.Decompiler en la CLI y en la UI, y todo es estático: lee los metadatos y el IL y reconstruye el código fuente. Nunca ejecuta los descriptores, y por eso es seguro apuntarlo a una dependencia sobre la que aún estás decidiendo si confiar.

La palabra clave field va a estar por todas partes, porque elimina el único punto de fricción que mantenía a la gente escribiendo propiedades con campo de respaldo completo. Saber que no deja ninguna huella en los metadatos —que un decompilador la recupera puramente a partir de la forma del cuerpo del descriptor— vale la pena la próxima vez que estés leyendo cómo una biblioteca valida una propiedad a la que le pasas datos, o depurando por qué tu propio setter normalizó un valor que no esperabas. Consigue la última versión en la página de descarga de Glass.NET y lee el próximo field que encuentres.

Prueba Nebula.NET

Endurece tu código .NET en minutos — empieza con la edición gratuita.