Decompilar la expresión `with`: cómo Glass.NET reconstruye los sitios de clonación de records
Una expresión `with` no deja ninguna palabra clave en el IL: es una llamada virtual a un método oculto `<Clone>$` seguida de una serie de setters init-only. Glass.NET vuelve a leer esa forma exacta como `record with { … }`. Aquí está el viaje completo source → IL → C# reconstruido para la mutación no destructiva.
Una expresión with es una de las piezas de aspecto más mágico del C# moderno: tomas un record inmutable, escribes original with { Price = 9.99m } y obtienes una copia nueva con un campo cambiado y todo lo demás intacto. Mutación no destructiva. Pero no existe ningún opcode with, ninguna instrucción «clona esto pero cambia aquello» en el CLR. Cuando el compilador termina, toda la expresión se ha convertido en una simple llamada a un método virtual seguida de unos pocos almacenamientos de campos. Reconstruir la palabra clave with a partir de esa forma es una coincidencia de patrón pequeña y precisa, y es una buena manera de ver cómo Glass.NET, el decompilador .NET gratuito, reconstruye características del lenguaje que solo existen como convenciones en los metadatos.
Este artículo recorre un sitio with hasta el IL y de vuelta a C#. Si quieres la mecánica de la declaración del record en sí (EqualityContract, igualdad por valor, PrintMembers), esa es una huella aparte; aquí solo nos interesa el sitio de la llamada de clonación.
El código fuente
Empecemos con un record diminuto y una única actualización no destructiva:
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 devuelve un nuevo Product que comparte Name, toma newPrice y decrementa Stock, sin mutar nunca p. Dos cosas tienen que ocurrir internamente: el objeto debe copiarse y luego los dos miembros nombrados deben sobrescribirse en la copia. Eso es exactamente lo que muestra el IL.
Lo que emite el compilador
El propio record gana dos miembros sintetizados que hacen posible with: un constructor de copia protegido que clona cada campo y un método de clonación virtual que el compilador de C# llama <Clone>$ (los corchetes angulares garantizan que nunca podrás colisionar con él en el código fuente). El método de clonación simplemente llama al constructor de copia:
// Sintetizado en el record — mostrado aquí con nombres legibles
protected Product(Product original)
{
Name = original.Name;
Price = original.Price;
Stock = original.Stock;
}
public virtual Product <Clone>$() => new Product(this);
La expresión with en Discount se compila a un callvirt de <Clone>$ y luego a un almacenamiento en cada propiedad nombrada dentro de las llaves. Aquí está el cuerpo del método tal como lo muestra ildasm/Glass:
.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
}
Léelo de arriba abajo y la forma es inconfundible: un callvirt a un método llamado <Clone>$, su resultado aparcado en un temporal, luego una secuencia de llamadas a setters de propiedades sobre ese mismo temporal y, finalmente, el temporal se devuelve. Los setters son set_Price y set_Stock, los setters init-only del record, invocables aquí porque el constructor de copia y la reducción del with se ejecutan en un contexto de inicialización.
El patrón que detecta Glass
Glass no busca una marca que diga «esto fue un with». No existe tal marca. Detecta la firma estructural de la expresión reducida:
La regla de reconocimiento, enunciada con precisión, es: una llamada a un método <Clone>$ sintetizado cuyo resultado se almacena en un temporal, donde ese temporal se muta a continuación únicamente mediante setters init-only (o almacenamientos de campo directos) antes de usarse como valor. Cuando eso se cumple, la llamada de clonación más la serie de setters se colapsan en una única expresión with; el receptor de <Clone>$ se convierte en el operando anterior a with, y cada setter se convierte en una entrada Member = value dentro de las llaves.
Lo que reconstruye Glass
Pásalo por el decompilador:
glass decompile Catalog.dll --type Catalog --member Discount
Glass produce:
public static Product Discount(Product p, decimal newPrice)
{
return p with
{
Price = newPrice,
Stock = p.Stock - 1
};
}
Ese es el código fuente original, hasta el orden de las entradas del inicializador (Glass preserva el orden de los setters del IL, que es el orden del código fuente). El temporal V_0, la llamada a <Clone>$ y las dos invocaciones set_ han desaparecido dentro de la palabra clave, lo cual es la reconstrucción honesta, porque eso es precisamente lo que el programador de C# escribió.
Cuando el patrón no se cumple
El valor de una coincidencia estructural es que se degrada con honestidad. Si Glass ve una llamada a <Clone>$ cuyo resultado se muta de alguna forma que un bloque with no puede expresar —por ejemplo un bucle que escribe elementos, una llamada a un método que no es un setter init, o una ramificación entre la clonación y los almacenamientos— no fuerza un with. Recurre a mostrar la llamada de clonación literal y las asignaciones individuales, porque inventar un with ahí sería mentir sobre el flujo de control. Puedes verlo tú mismo pasando --no-pattern with para comparar la forma reducida en bruto con la reconstruida:
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;
}
Ver ambas formas una al lado de la otra resulta útil cuando estás auditando un ensamblado desconocido —quizá tu propia compilación de release sin PDB, o una biblioteca de terceros con la que necesitas interoperar— y quieres confirmar que un método realmente hace una simple copia-y-asignación y no algo más sutil escondido tras una clonación.
Record structs: una forma distinta
Un matiz que vale la pena conocer. Un record struct no tiene método <Clone>$, porque los tipos por valor se copian por asignación: no hay nada que llamar. Para readonly record struct Point(int X, int Y), la expresión with se reduce a una copia del struct en la pila (un ldobj/stloc del valor completo, o simplemente un nuevo local inicializado desde el origen) seguida de la misma serie de setters init. Glass reconoce esa forma también: una copia por valor de un record struct seguida de setters init-only es la variante struct de with, y reconstruye la misma sintaxis source with { … }. La señal difiere —una copia de struct en lugar de un callvirt <Clone>$()— pero la regla de reconstrucción es la misma: copiar, luego sobrescribir los miembros nombrados, luego usar.
Por qué esto importa para leer código real
Las expresiones with están por todas partes en el C# moderno: objetos de configuración que recorren un pipeline, actualizaciones de estado en un reducer, DTOs copiados con un campo ajustado. Cuando decompilas ese código sin reconocimiento obtienes una maraña de temporales <Clone>$() y setters dispersos que oscurece la única intención detrás de cada uno: hacer una copia con estos cambios. Colapsar eso de vuelta a with es la diferencia entre leer el diseño de alguien y leer la contabilidad del compilador.
Glass es un decompilador gratuito y puramente estático creado exactamente para este tipo de comprensión: tus propios ensamblados, tus dependencias, tus compilaciones heredadas. Lee IL a C#; no ejecuta, parchea ni modifica nada. Apúntalo a una DLL en la interfaz nativa de Visual Studio, en la CLI o a través de MCP y la palabra clave with reaparece dondequiera que la forma clonar-luego-asignar indique que debe estar.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.