Wie Glass eine asynchrone Iterator-Zustandsmaschine rekonstruiert
Eine async IAsyncEnumerable<T>-Methode ist im IL weder ein Iterator noch eine asynchrone Methode — sie ist eine einzige generierte Struktur, die beides zugleich ist und IAsyncEnumerable, IAsyncEnumerator und IValueTaskSource über ein einziges MoveNext implementiert. Dieser Beitrag liest diese kombinierte Zustandsmaschine Feld für Feld, zeigt, wie <>1__state die Unterbrechungspunkte sowohl für await als auch für yield multiplext, wie der ausstehende ValueTask aus der Struktur selbst stammt, und wie Glass.NET die Zustandsübergänge auf await foreach und yield return zurückabbildet statt auf die rohe MoveNext-Suppe.
Schreibe die kleinste async IAsyncEnumerable<T>-Methode, die du kannst — eine Schleife, die etwas erwartet und einen Wert liefert — und öffne dann die kompilierte Assembly. Die Methode, die du geschrieben hast, ist verschwunden. An ihrer Stelle steht eine verschachtelte Struktur mit einem Namen wie <Stream>d__0, einem Dutzend Felder, deren Namen mit <> beginnen, und einem einzigen MoveNext, das ein flaches switch über eine Ganzzahl ist. Diese eine Struktur ist zugleich ein Enumerable, ein Enumerator, eine async-Zustandsmaschine und eine selbstgebaute Task-Quelle. Dein await foreach und dein yield return daraus zu rekonstruieren, ist eines der schwierigeren Dinge, die ein Dekompiler tut, denn der Compiler hat zwei verschiedene Unterbrechungsmechanismen in einen einzigen Rumpf verschmolzen.
Die eigentliche Frage
Ein gewöhnlicher Iterator suspendiert, wenn der Konsument aufhört abzurufen. Eine gewöhnliche async-Methode suspendiert, wenn eine erwartete Task nicht abgeschlossen ist. Ein asynchroner Iterator muss beides tun — yield return und await — innerhalb derselben fortsetzbaren Methode, und er muss unabhängig davon, aus welcher Art von Unterbrechung er zurückkam, genau an der richtigen Stelle fortsetzen. Wo lebt also dieser vereinheitlichte Kontrollfluss nach der Kompilierung, und wie gelangt ein Leser von einem einzigen flachen MoveNext zurück zu den zwei verschiedenen Konstrukten, die der Entwickler tatsächlich geschrieben hat?
Die Antwort ist eine einzige generierte Struktur, die vier Schnittstellen zugleich implementiert, und ein einziges <>1__state-Feld, das jeden Unterbrechungspunkt der Methode multiplext. Lies die Form der Struktur und lies die Verteilung dieses Feldes, und die ursprüngliche Methode fällt heraus.
Eine Methode, vier Schnittstellen
Hier ist der Quellcode. Nichts Exotisches — ein await und ein yield return in einer Schleife, dazu ein Abbruch-Token, damit die interessante Verdrahtung sichtbar wird:
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);
}
}
Der Compiler gibt weder einen Iterator noch eine gewöhnliche async-Methode aus. Er gibt eine Struktur aus, deren deklarierte Schnittstellenliste der entscheidende Hinweis ist:
[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.
}
Kein einzelnes Feld allein beweist, worum es sich handelt, aber die Kombination ist eindeutig. IAsyncEnumerable<int> + IAsyncEnumerator<int> sagt Strom von Elementen. IAsyncStateMachine + <>t__builder vom Typ AsyncIteratorMethodBuilder sagt async. IValueTaskSource<bool> + der <>v__promise-Kern sagt der ValueTask pro Element wird durch diese Struktur gestützt, nicht durch eine zugewiesene Task. Diesen vollständigen Fingerabdruck gleicht Glass ab. Ein gewöhnlicher Iterator hat das <>2__current, aber keinen Builder und kein Promise; eine gewöhnliche async-Methode hat den Builder, aber kein Current und keine Enumerator-Schnittstelle. Nur der asynchrone Iterator ist all das zugleich.
Die mit <>3__ präfixierten Felder sind die Parameter-Kopie-Slots, die das Enumerable behält, damit jeder Aufruf von GetAsyncEnumerator einen frischen Enumerator mit den ursprünglichen Argumenten ausgeben kann — deshalb ist der Typ sowohl IAsyncEnumerable (die Fabrik) als auch IAsyncEnumerator (der Cursor). Die Felder <reader>5__2 und <line>5__3 sind die hochgezogenen lokalen Variablen: Alles, dessen Lebensdauer eine Unterbrechung überdauern muss, kann nicht auf dem Stack leben, also hebt der Compiler es in die Struktur.
<>1__state multiplext beide Arten der Unterbrechung
Das Feld, das den gesamten Kontrollfluss trägt, ist <>1__state, ein einziges int. Es ist die Fortsetzungsmarke, und das Entscheidende an einem asynchronen Iterator ist, dass sie zwischen await-Unterbrechungen und yield return-Unterbrechungen geteilt wird. Es gibt keinen zweiten Zähler.
Drei Wertebereiche sind von Bedeutung. -1 bedeutet, dass der Enumerator untätig ist — entweder noch nicht gestartet oder vollständig beendet. -2 ist der Wächterwert, den der Compiler in das Feld schreibt, während MoveNext aktiv läuft, damit ein wiedereintretender Aufruf „in Ausführung“ von „suspendiert“ unterscheiden kann. Jeder nichtnegative Wert n ist ein Fortsetzungspunkt: Der Rumpf hat n unmittelbar vor der Unterbrechung gespeichert, und der nächste Eintritt in MoveNext springt zur Anweisung unmittelbar nach dieser Unterbrechung. Ein await, das nicht abgeschlossen ist, und ein yield return, das gerade ein Element erzeugt hat, tun dasselbe — eine Fortsetzungsnummer in <>1__state ablegen und zurückkehren — und beide werden beim Wiedereintritt gleich dekodiert.
<>1__state-Wert steuert die MoveNext-Verteilung: −1 ist der Eintritt, −2 ist der Wächter in Ausführung, und jeder nichtnegative Fall setzt nach einer bestimmten Unterbrechung fort — gleich ob diese Unterbrechung ein await oder ein yield return war.Das MoveNextAsync/ValueTask-Zusammenspiel
Der Konsument ruft MoveNext nie direkt auf. Er ruft MoveNextAsync auf, das einen ValueTask<bool> zurückgibt — true, wenn ein Element in Current bereitsteht, false am Ende. Das Elegante ist, woher dieser ValueTask kommt. Die Struktur ist die Task-Quelle:
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 ist ein ManualResetValueTaskSourceCore<bool>, und da die Struktur IValueTaskSource<bool> implementiert, wird der zurückgegebene ValueTask<bool>(this, version) durch die Zustandsmaschine selbst gestützt — keine Task-Zuweisung pro Element. Wenn MoveNext läuft, geschieht eines von drei Dingen: Es trifft auf ein unvollständiges await und registriert die Fortsetzung des Awaiters für den Rückruf; es erreicht ein yield return, schreibt den Wert in <>2__current, setzt <>1__state auf den yield-Fortsetzungspunkt und ruft <>v__promise.SetResult(true) auf; oder es fällt am Ende heraus und ruft SetResult(false) auf. Die Fortsetzung des Awaiters tritt, wenn die erwartete Arbeit abgeschlossen ist, über den Builder erneut in MoveNext ein, und die Schleife setzt sich fort. Dieses SetResult(true) mit einem in <>2__current geparkten Wert ist die Laufzeitsignatur eines einzelnen yield return, das hinter einem await sitzt.
Wie Glass es zurückabbildet
Glass versucht nicht, diese Maschine „auszuführen“. Es liest sie. Die Rekonstruktion ist eine feste Abfolge:
- Den Typ-Fingerabdruck erkennen. Eine
[CompilerGenerated]verschachtelte Struktur, dieIAsyncEnumerable<T>+IAsyncEnumerator<T>+IAsyncStateMachine+IValueTaskSource<bool>implementiert und einenAsyncIteratorMethodBuildersowie einenManualResetValueTaskSourceCoreträgt — das ist ein asynchroner Iterator und nichts anderes. Die ursprüngliche Methode ist diejenige, deren Rumpf durch den Builder-Start-Stub ersetzt wurde, der diese Struktur konstruiert. - Die Parameter wiederherstellen. Die mit
<>3__präfixierten Felder bilden auf die Parameter der Methode zurück; ein Feld<>x__combinedTokensplus ein Aufruf vonCreateLinkedTokenSourceinGetAsyncEnumeratorbedeutet, dass der Token-Parameter[EnumeratorCancellation]trug, was Glass wieder anfügt. - Die Verteilung lesen. Das
switch (<>1__state)am Anfang vonMoveNextliefert jeden Fortsetzungspunkt. Glass klassifiziert jeden: Ein Fall, der unmittelbar nach einemGetResultauf einem<>u__N-Awaiter fortsetzt, ist einawait; ein Fall, der unmittelbar nach einemSetResult(true)fortsetzt, das in<>2__currentgespeichert hat, ist einyield return. - Den Kontrollfluss rekonstruieren. Die hochgezogenen lokalen Variablen (
<reader>5__2,<line>5__3) werden zu gewöhnlichen lokalen Variablen; daswhile, das der Compiler in gotos zwischen Zuständen abgeflacht hat, wird zu einer Schleife zusammengefaltet; dasusing var readerwird aus demDisposeAsync/<>w__disposeMode-Aufräumpfad wiederhergestellt. Heraus kommt dasReadBatchesAsync, das du geschrieben hast, nicht die Struktur.
Über die CLI ist das Ganze ein einziger Befehl:
$ glass export ./App.dll --member "M:App.Reader.ReadBatchesAsync(System.String,System.Threading.CancellationToken)"
Du erhältst das rekonstruierte async IAsyncEnumerable<int> mit seinem intakten await und yield return und dem [EnumeratorCancellation] zurück am Token. Füge --il hinzu, und Glass zeigt die ehrliche andere Seite: die Struktur <ReadBatchesAsync>d__0, das switch (<>1__state) und die SetResult-Aufrufe, die die C#-Ansicht verbirgt.
Vorbehalte und wo es schwierig wird
Zwei ehrliche Grenzen. Erstens ist die Zuordnung von Zustand zu Konstrukt nur dann sauber, wenn die Awaiter- und Yield-Muster dem entsprechen, was das aktuelle Roslyn ausgibt; handgeschriebenes IL oder eine von einem anderen Compiler erzeugte Struktur kann in Formen suspendieren, die Glass nicht als Fingerabdruck kennt, und dann ist die IL-Ansicht der wahrheitsgetreue Rückfall — du siehst das echte switch, selbst wenn das übergeordnete await foreach nicht benannt werden kann. Zweitens können starkes Inlining oder Optimierung Fortsetzungspunkte verschmelzen und hochgezogene lokale Variablen über das teilen, was logisch getrennte awaits waren, sodass die rekonstruierte Schleife dem IL treu ist, aber möglicherweise keine zeichengenaue Entsprechung des ursprünglichen Codes ist. Der <>w__disposeMode-Pfad kodiert insbesondere das Zusammenspiel zwischen await using, einem frühen break und DisposeAsync, und die genaue Platzierung eines finally dort zu rekonstruieren, ist der subtilste Teil der Arbeit.
Fazit
Ein asynchroner Iterator ist die einzige Stelle in C#, an der zwei verschiedene Unterbrechungsmechanismen zu einer einzigen fortsetzbaren Methode verschweißt werden. Der Compiler drückt es als eine einzige generierte Struktur aus, die zugleich Enumerable, Enumerator, async-Zustandsmaschine und IValueTaskSource ist, mit einem einzigen <>1__state-Feld, das jedes await und jedes yield return multiplext, einem <>2__current, das das Element enthält, und einem ManualResetValueTaskSourceCore, damit das Abrufen eines Stroms keine Task pro Element zuweist. Glass.NET liest diesen Fingerabdruck, dekodiert die switch (<>1__state)-Verteilung, klassifiziert jeden Fortsetzungspunkt als ein await oder ein yield return und rekonstruiert den ursprünglichen await foreach/yield return-Code — Abbruch-Attribut inklusive — als reine statische Analyse, ohne jemals eine Zeile auszuführen. Hol dir die kostenlose Version von der Glass.NET-Downloadseite und öffne die IL-Ansicht beim nächsten async IAsyncEnumerable<T>, das du verstehen musst.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.