Decompilar allows ref struct: toda la característica es un bit de metadatos, y descartarlo estrecha tu contrato en silencio
La anti-restricción allows ref struct de C# 13 no produce IL en el cuerpo del método. Vive por completo en un bit de GenericParameterAttributes (AllowByRefLike, 0x20) sobre un parámetro genérico — mira cómo lo lee de vuelta Glass.NET.
La mayoría de las características del lenguaje C# dejan un rastro en el flujo de instrucciones. Un método async se convierte en una máquina de estados que puedes recorrer paso a paso; un yield return se convierte en un MoveNext con una etiqueta a la que se salta; incluso un using no es más que un try/finally alrededor de un Dispose. Un decompilador se gana el sustento leyendo esas instrucciones y plegándolas de vuelta a la sintaxis que las produjo.
La anti-restricción allows ref struct de C# 13 es el tipo de característica opuesto. No produce ningún IL en el cuerpo del método. La característica entera es un bit en una tabla de metadatos, activado en un parámetro genérico. Eso la convierte en uno de los casos de estudio más limpios que existen sobre por qué un decompilador tiene que leer los metadatos con tanto cuidado como lee el código — porque aquí el código no dice nada, y una herramienta que solo lea código te entregará un fuente que compila, se ejecuta de forma idéntica y es silenciosamente incorrecto. Esta entrada recorre la construcción para Glass.NET, el decompilador .NET gratuito.
Una anti-restricción, no una restricción
Una restricción genérica normal añade un requisito. where T : IDisposable dice que un argumento de tipo debe implementar IDisposable; el compilador lo impone, y los metadatos lo registran como una fila en la tabla GenericParamConstraints que apunta al tipo IDisposable.
allows ref struct hace lo contrario. Todo parámetro genérico en .NET lleva un requisito invisible y de larga data: que su argumento de tipo no debe ser una ref struct (Span<T>, ReadOnlySpan<T>, o cualquier ref struct que declares). Esa regla existía porque las ref struct tienen garantías de vida solo en la pila que el sistema de genéricos históricamente no podía respetar. C# 13 y .NET 9 te permiten levantar esa regla, por parámetro, escribiendo allows ref struct. No estás añadiendo un requisito — estás eliminando una prohibición. Por eso se llama anti-restricción, y por eso se almacena como un bit de permiso en lugar de una fila de restricción.
El C# y el IL al que compila
Aquí va un uso pequeño y realista: una canalización que acepta cualquier parser — incluido un parser ref struct que envuelve un Span<char> — siempre que implemente una interfaz.
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 lista de restricciones es ILineParser, allows ref struct: una restricción de interfaz real, y luego la anti-restricción. La restricción de interfaz permite que el cuerpo llame a parser.Parse(...); la anti-restricción es lo que permite que más tarde un llamador escriba Run<MySpanParser>(...) donde MySpanParser es una ref struct que implementa ILineParser — en sí misma una característica complementaria de C# 13.
Ahora el IL de Run. El cuerpo es una llamada de interfaz restringida ordinaria:
.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
}
Lee el cuerpo y nada resulta inusual: carga la dirección del receptor, carga el argumento, constrained. callvirt al método de la interfaz. Esa es la misma secuencia de instrucciones que obtendrías para where TParser : ILineParser sin anti-restricción alguna. El único rastro de la característica está en la línea de firma del método — la palabra clave byreflike sobre el parámetro genérico TParser — y byreflike no es una instrucción. Es la representación en ILAsm de un indicador.
Un bit en GenericParameterAttributes
Todo parámetro genérico tiene un valor GenericParameterAttributes — un pequeño campo de bits que ya codificaba la varianza (out/in) y las restricciones especiales class, struct y new(). .NET 9 añadió un indicador más:
// 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 (nuevo en .NET 9)
Para el ejemplo de Run, el GenericParameterAttributes de TParser es exactamente 0x0020: AllowByRefLike activado, todo lo demás a cero. El requisito de ILineParser no está en este valor — es una fila GenericParamConstraints aparte. Puedes confirmar la separación con reflexión:
var tp = typeof(Pipeline).GetMethod("Run")!.GetGenericArguments()[0];
tp.GenericParameterAttributes.HasFlag(GenericParameterAttributes.AllowByRefLike); // True
tp.GetGenericParameterConstraints(); // [ ILineParser ] — la interfaz, nada sobre ref struct
La anti-restricción es una cosa, la interfaz es la otra, y proceden de dos tablas distintas. Un decompilador tiene que leer ambas y recombinarlas en el orden que exige C#: restricciones de tipo reales primero, luego allows ref struct al final.
Por qué el cuerpo idéntico es una trampa
Esta es la parte que hace que la construcción merezca una entrada entera. Como el IL del cuerpo no lleva rastro de la característica, un decompilador construido solo para reconstruir instrucciones producirá un método Run que compila y se ejecuta a la perfección — y cuya firma prohíbe precisamente los argumentos ref struct que el original permitía. Nada lanza excepciones. Nada parece mal. El método simplemente perdió una capacidad que vivía por completo en los metadatos.
En concreto: dado el ensamblado original, Run<MySpanParser>(parser, text) — con MySpanParser una ref struct que implementa ILineParser — es legal. Decompila con la anti-restricción descartada, recompila, y ese mismo punto de llamada deja de compilar con “MySpanParser must be a non-ref-struct type to be used as parameter TParser”. Para quien decompila para entender su propia biblioteca, comparar dos builds o re-destinar código al que tiene derecho, eso es un estrechamiento silencioso del contrato — el tipo de regresión que resulta caro notar porque el código que cambió es el código que no cambió.
Lo que reconstruye Glass.NET
Glass.NET lee los indicadores del parámetro genérico, no solo su cuerpo, de modo que la anti-restricción sobrevive al viaje de ida y vuelta. Apúntalo al tipo:
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 restricción de interfaz y la anti-restricción vuelven en el orden correcto, y el cuerpo pliega el constrained. callvirt de vuelta a parser.Parse(input). Para ver los metadatos que Glass leyó para llegar ahí, pídele que muestre su trabajo:
glass decompile Pipeline.dll --type Pipeline --member Run --constraint-check
TParser
GenericParameterAttributes = 0x0020 (AllowByRefLike)
GenericParamConstraints:
[0] ILineParser (interface)
=> where TParser : ILineParser, allows ref struct
Esa salida coloca el 0x0020 crudo junto a la cláusula generada, para que puedas verificar que el bit es la anti-restricción y no, pongamos, un indicador de tipo valor mal leído. Añade --il para confirmar la otra mitad de la historia — que el cuerpo bajo la firma es una llamada de interfaz restringida ordinaria sin nada específico de la característica:
glass decompile Pipeline.dll --type Pipeline --member Run --il
El panel de IL muestra byreflike sobre el parámetro en la línea de firma .method y la secuencia simple constrained. callvirt debajo. En la interfaz de Avalonia la misma separación se ve de un vistazo: el nodo del parámetro genérico bajo Run lista sus indicadores decodificados, y la vista de IL sincronizada resalta la palabra clave de la firma mientras que el cuerpo no lleva rastro de la característica. Si estás inspeccionando una dependencia desde un asistente de IA, el servidor MCP expone la misma reconstrucción — glass mcp permite que el asistente llame a glass_decompile y lea la cláusula allows ref struct por sí mismo, todo inspección estática y de solo lectura, sin ejecutar nada.
La conclusión
allows ref struct es la rara característica con cero huella ejecutable. El compilador la expresa como un solo bit — AllowByRefLike, 0x20 — sobre un parámetro genérico, y deja el cuerpo del método exactamente como sería sin ella. Precisamente por eso leer cuerpos no basta: el fuente fiel vive en los metadatos, y una herramienta que ignore el indicador te entregará código que compila, se ejecuta igual y rechaza en silencio los argumentos ref struct que el autor permitió deliberadamente. Leer ese único bit de vuelta, y colocar la cláusula en el lugar correcto de la lista de restricciones, es todo el trabajo — y es la diferencia entre un fuente que parece correcto y uno que lo es.
Glass.NET es un decompilador .NET gratuito con una interfaz Avalonia nativa de Visual Studio, una CLI y un servidor MCP. Descárgalo y lee los metadatos que tu compilador dejó atrás.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.