Cómo Glass reconstruye una máquina de estados de iterador asíncrono
Un método async IAsyncEnumerable<T> no es un iterador ni un método asíncrono en el IL: es una única estructura generada que es ambos a la vez, implementando IAsyncEnumerable, IAsyncEnumerator e IValueTaskSource sobre un solo MoveNext. Este artículo lee esa máquina de estados combinada campo por campo, muestra cómo <>1__state multiplexa los puntos de suspensión tanto para await como para yield, cómo el ValueTask pendiente se origina en la propia estructura, y cómo Glass.NET asigna las transiciones de estado de vuelta a await foreach y yield return en lugar de la sopa cruda de MoveNext.
Escribe el método async IAsyncEnumerable<T> más pequeño que puedas — un bucle que espere algo y produzca un valor — y luego abre el ensamblado compilado. El método que escribiste ha desaparecido. En su lugar hay una estructura anidada con un nombre como <Stream>d__0, una docena de campos cuyos nombres empiezan por <>, y un solo MoveNext que es un switch plano sobre un entero. Esa única estructura es simultáneamente un enumerable, un enumerador, una máquina de estados asíncrona y un origen de tareas hecho a mano. Reconstruir tu await foreach y tu yield return a partir de ella es una de las cosas más difíciles que hace un descompilador, porque el compilador ha fusionado dos mecanismos de suspensión distintos en un solo cuerpo.
La verdadera pregunta
Un iterador normal se suspende cuando el consumidor deja de extraer. Un método async normal se suspende cuando una tarea esperada no ha terminado. Un iterador asíncrono tiene que hacer ambas cosas — yield return y await — dentro del mismo método reanudable, y tiene que reanudar exactamente en el lugar correcto independientemente del tipo de suspensión de la que volvió. Entonces, ¿dónde vive ese flujo de control unificado tras la compilación, y cómo pasa un lector de un único MoveNext plano de vuelta a las dos construcciones distintas que el desarrollador escribió realmente?
La respuesta es una única estructura generada que implementa cuatro interfaces a la vez, y un único campo <>1__state que multiplexa cada punto de suspensión del método. Lee la forma de la estructura y lee el despacho de ese campo, y el método original cae por su propio peso.
Un método, cuatro interfaces
Aquí está el código fuente. Nada exótico — un await y un yield return en un bucle, más un token de cancelación para que aparezca la infraestructura interesante:
public static async IAsyncEnumerable<int> ReadBatchesAsync(
string path,
[EnumeratorCancellation] CancellationToken token = default)
{
using var reader = new StreamReader(path);
string? line;
while ((line = await reader.ReadLineAsync(token)) is not null)
{
yield return int.Parse(line);
}
}
El compilador no emite un iterador y no emite un método asíncrono ordinario. Emite una estructura cuya lista de interfaces declarada es la señal definitiva:
[CompilerGenerated]
private struct <ReadBatchesAsync>d__0 :
IAsyncEnumerable<int>,
IAsyncEnumerator<int>,
IAsyncStateMachine,
IValueTaskSource<bool>,
IValueTaskSource,
IAsyncDisposable
{
public int <>1__state;
public AsyncIteratorMethodBuilder <>t__builder;
public ManualResetValueTaskSourceCore<bool> <>v__promise;
private bool <>w__disposeMode;
private int <>l__initialThreadId;
private int <>2__current;
private string path;
public string <>3__path;
private CancellationToken token;
public CancellationToken <>3__token;
private CancellationTokenSource <>x__combinedTokens;
private StreamReader <reader>5__2;
private string? <line>5__3;
private ValueTaskAwaiter<string?> <>u__1;
// ... MoveNext, MoveNextAsync, GetAsyncEnumerator, DisposeAsync, etc.
}
Ningún campo por sí solo demuestra qué es esto, pero la combinación es inequívoca. IAsyncEnumerable<int> + IAsyncEnumerator<int> dice flujo de elementos. IAsyncStateMachine + <>t__builder de tipo AsyncIteratorMethodBuilder dice asíncrono. IValueTaskSource<bool> + el núcleo <>v__promise dice el ValueTask por elemento está respaldado por esta estructura, no por una Task asignada. Esa huella completa es lo que Glass hace coincidir. Un iterador normal tiene el <>2__current pero ningún builder ni promesa; un método asíncrono normal tiene el builder pero ningún Current ni interfaz de enumerador. Solo el iterador asíncrono es todas ellas a la vez.
Los campos con prefijo <>3__ son las ranuras de copia de parámetros que el enumerable conserva para que cada llamada a GetAsyncEnumerator pueda entregar un enumerador nuevo con los argumentos originales — por eso el tipo es a la vez IAsyncEnumerable (la fábrica) e IAsyncEnumerator (el cursor). Los campos <reader>5__2 y <line>5__3 son las variables locales elevadas: cualquier cosa cuyo tiempo de vida deba sobrevivir a una suspensión no puede vivir en la pila, por lo que el compilador la eleva a la estructura.
<>1__state multiplexa ambos tipos de suspensión
El campo que lleva todo el flujo de control es <>1__state, un único int. Es la etiqueta de reanudación, y lo crucial de un iterador asíncrono es que se comparte entre las suspensiones de await y las suspensiones de yield return. No hay un segundo contador.
Importan tres rangos de valores. -1 significa que el enumerador está inactivo — o aún no iniciado o completamente terminado. -2 es el centinela que el compilador escribe en el campo mientras MoveNext se está ejecutando activamente, para que una llamada reentrante pueda distinguir “en ejecución” de “suspendido”. Cada valor no negativo n es un punto de reanudación: el cuerpo almacenó n justo antes de suspenderse, y la siguiente entrada en MoveNext salta a la instrucción inmediatamente posterior a esa suspensión. Un await que no se ha completado y un yield return que acaba de producir un elemento hacen lo mismo — guardar un número de reanudación en <>1__state y retornar — y ambos se decodifican igual al volver a entrar.
<>1__state dirige el despacho de MoveNext: −1 es la entrada, −2 es el centinela en ejecución, y cada caso no negativo reanuda tras una suspensión concreta — sea esa suspensión un await o un yield return.El protocolo MoveNextAsync / ValueTask
El consumidor nunca llama a MoveNext directamente. Llama a MoveNextAsync, que devuelve un ValueTask<bool> — true si hay un elemento listo en Current, false al final. La parte elegante es de dónde procede ese ValueTask. La estructura es el origen de la tarea:
public ValueTask<bool> MoveNextAsync()
{
if (<>1__state == -2) // already disposed
return default;
<>v__promise.Reset();
var self = this;
<>t__builder.MoveNext(ref self); // runs synchronously until first suspension
short version = <>v__promise.Version;
// If MoveNext already finished synchronously, hand back the result;
// otherwise back the ValueTask with this struct as the IValueTaskSource.
return new ValueTask<bool>(this, version);
}
<>v__promise es un ManualResetValueTaskSourceCore<bool>, y como la estructura implementa IValueTaskSource<bool>, el ValueTask<bool>(this, version) devuelto está respaldado por la propia máquina de estados — sin asignación de Task por elemento. Cuando MoveNext se ejecuta, ocurre una de tres cosas: alcanza un await incompleto y registra la continuación del awaiter para que vuelva a llamar; llega a un yield return, escribe el valor en <>2__current, establece <>1__state en el punto de reanudación del yield y llama a <>v__promise.SetResult(true); o se sale por el final y llama a SetResult(false). La continuación del awaiter, cuando el trabajo esperado termina, vuelve a entrar en MoveNext a través del builder, y el bucle continúa. Ese SetResult(true) con un valor aparcado en <>2__current es la firma en tiempo de ejecución de un único yield return situado detrás de un await.
Cómo lo reconstruye Glass
Glass no intenta “ejecutar” esta máquina. La lee. La reconstrucción es una secuencia fija:
- Identificar la huella del tipo. Una estructura anidada
[CompilerGenerated]que implementaIAsyncEnumerable<T>+IAsyncEnumerator<T>+IAsyncStateMachine+IValueTaskSource<bool>, que lleva unAsyncIteratorMethodBuildery unManualResetValueTaskSourceCore— eso es un iterador asíncrono y nada más. El método original es aquel cuyo cuerpo fue reemplazado por el stub de inicio del builder que construye esta estructura. - Recuperar los parámetros. Los campos con prefijo
<>3__se asignan de vuelta a los parámetros del método; un campo<>x__combinedTokensmás una llamada aCreateLinkedTokenSourceenGetAsyncEnumeratorsignifica que el parámetro del token llevaba[EnumeratorCancellation], que Glass vuelve a adjuntar. - Leer el despacho. El
switch (<>1__state)al principio deMoveNextda todos los puntos de reanudación. Glass clasifica cada uno: un caso que reanuda justo después de unGetResultsobre un awaiter<>u__Nes unawait; un caso que reanuda justo después de unSetResult(true)que almacenó en<>2__currentes unyield return. - Reconstruir el flujo de control. Las variables locales elevadas (
<reader>5__2,<line>5__3) se convierten en variables locales ordinarias; elwhileque el compilador aplanó en gotos entre estados se repliega en un bucle; elusing var readerse recupera a partir de la ruta de limpiezaDisposeAsync/<>w__disposeMode. Lo que sale es elReadBatchesAsyncque escribiste, no la estructura.
Desde la CLI todo es un solo comando:
$ glass export ./App.dll --member "M:App.Reader.ReadBatchesAsync(System.String,System.Threading.CancellationToken)"
Obtienes el async IAsyncEnumerable<int> reconstruido con su await y su yield return intactos y el [EnumeratorCancellation] de vuelta en el token. Añade --il y Glass muestra el otro lado honesto: la estructura <ReadBatchesAsync>d__0, el switch (<>1__state) y las llamadas a SetResult que la vista de C# oculta.
Advertencias y dónde se complica
Dos límites honestos. Primero, la asignación de estado a construcción solo es limpia cuando los patrones de awaiter y yield coinciden con lo que emite el Roslyn actual; el IL escrito a mano, o una estructura producida por un compilador diferente, pueden suspenderse con formas que Glass no ha identificado, y entonces la vista de IL es el recurso veraz — ves el switch real aunque no se pueda nombrar el await foreach de alto nivel. Segundo, un inlining u optimización intensos pueden fusionar puntos de reanudación y compartir variables locales elevadas entre lo que lógicamente eran awaits separados, de modo que el bucle reconstruido es fiel al IL pero puede no ser una coincidencia carácter por carácter con el código original. La ruta <>w__disposeMode en particular codifica la interacción entre await using, un break temprano y DisposeAsync, y reconstruir la colocación exacta de un finally ahí es la parte más sutil del trabajo.
Conclusión
Un iterador asíncrono es el único lugar de C# donde dos mecanismos de suspensión distintos se sueldan en un único método reanudable. El compilador lo expresa como una sola estructura generada que es enumerable, enumerador, máquina de estados asíncrona e IValueTaskSource a la vez, con un único campo <>1__state que multiplexa cada await y cada yield return, un <>2__current que contiene el elemento, y un ManualResetValueTaskSourceCore para que extraer un flujo no asigne ninguna Task por elemento. Glass.NET lee esa huella, decodifica el despacho switch (<>1__state), clasifica cada punto de reanudación como un await o un yield return, y reconstruye el código original await foreach/yield return — con atributo de cancelación incluido — como análisis estático puro, sin ejecutar nunca una línea. Consigue la versión gratuita en la página de descarga de Glass.NET y abre la vista de IL en el próximo async IAsyncEnumerable<T> que necesites entender.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.