Skip to content
← Tous les articles
· Delta1 Labs DecompilationGlass

Comment Glass reconstruit une machine à états d'itérateur asynchrone

Une méthode async IAsyncEnumerable<T> n'est ni un itérateur ni une méthode asynchrone dans l'IL : c'est une unique structure générée qui est les deux à la fois, implémentant IAsyncEnumerable, IAsyncEnumerator et IValueTaskSource sur un seul MoveNext. Cet article lit cette machine à états combinée champ par champ, montre comment <>1__state multiplexe les points de suspension à la fois pour await et pour yield, comment le ValueTask en attente provient de la structure elle-même, et comment Glass.NET fait correspondre les transitions d'état à await foreach et yield return plutôt qu'à la soupe brute de MoveNext.

Écrivez la plus petite méthode async IAsyncEnumerable<T> possible — une boucle qui attend quelque chose et produit une valeur — puis ouvrez l”assembly compilé. La méthode que vous avez écrite a disparu. À sa place se trouve une structure imbriquée portant un nom comme <Stream>d__0, une douzaine de champs dont les noms commencent par <>, et un unique MoveNext qui est un switch plat sur un entier. Cette seule structure est simultanément un énumérable, un énumérateur, une machine à états asynchrone et une source de tâches faite à la main. Reconstruire votre await foreach et votre yield return à partir d”elle est l”une des choses les plus difficiles que fait un décompilateur, car le compilateur a fusionné deux mécanismes de suspension distincts dans un seul corps.

La vraie question

Un itérateur ordinaire se suspend lorsque le consommateur cesse d”extraire. Une méthode async ordinaire se suspend lorsqu”une tâche attendue n”est pas terminée. Un itérateur asynchrone doit faire les deux — yield return et await — à l”intérieur de la même méthode réentrante, et doit reprendre exactement au bon endroit quel que soit le type de suspension dont il revient. Alors, où réside ce flux de contrôle unifié après compilation, et comment un lecteur passe-t-il d”un unique MoveNext plat aux deux constructions distinctes que le développeur a réellement écrites ?

La réponse est une unique structure générée qui implémente quatre interfaces à la fois, et un unique champ <>1__state qui multiplexe chaque point de suspension de la méthode. Lisez la forme de la structure et lisez l”aiguillage de ce champ, et la méthode d”origine en découle.

Une méthode, quatre interfaces

Voici le code source. Rien d”exotique — un await et un yield return dans une boucle, plus un jeton d”annulation pour que la tuyauterie intéressante apparaisse :

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);
    }
}

Le compilateur n”émet pas un itérateur et n”émet pas une méthode asynchrone ordinaire. Il émet une structure dont la liste d”interfaces déclarée est le signe révélateur par excellence :

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

Aucun champ pris seul ne prouve de quoi il s”agit, mais la combinaison est sans ambiguïté. IAsyncEnumerable<int> + IAsyncEnumerator<int> dit flux d”éléments. IAsyncStateMachine + <>t__builder de type AsyncIteratorMethodBuilder dit asynchrone. IValueTaskSource<bool> + le noyau <>v__promise dit le ValueTask par élément est adossé à cette structure, pas à une Task allouée. C”est cette empreinte complète que Glass fait correspondre. Un itérateur ordinaire a le <>2__current mais aucun builder ni promesse ; une méthode asynchrone ordinaire a le builder mais aucun Current ni interface d”énumérateur. Seul l”itérateur asynchrone est tout cela à la fois.

Les champs préfixés par <>3__ sont les emplacements de copie de paramètres que l”énumérable conserve afin que chaque appel à GetAsyncEnumerator puisse remettre un énumérateur neuf avec les arguments d”origine — c”est pourquoi le type est à la fois IAsyncEnumerable (la fabrique) et IAsyncEnumerator (le curseur). Les champs <reader>5__2 et <line>5__3 sont les variables locales hissées : tout ce dont la durée de vie doit survivre à une suspension ne peut pas résider sur la pile, le compilateur la hisse donc dans la structure.

<>1__state multiplexe les deux types de suspension

Le champ qui porte tout le flux de contrôle est <>1__state, un unique int. C”est l”étiquette de reprise, et le point crucial d”un itérateur asynchrone est qu”elle est partagée entre les suspensions d”await et les suspensions de yield return. Il n”y a pas de second compteur.

Trois plages de valeurs importent. -1 signifie que l”énumérateur est inactif — soit pas encore démarré, soit entièrement terminé. -2 est la sentinelle que le compilateur écrit dans le champ pendant que MoveNext s”exécute activement, afin qu”un appel réentrant puisse distinguer « en cours d”exécution » de « suspendu ». Chaque valeur non négative n est un point de reprise : le corps a stocké n juste avant de se suspendre, et l”entrée suivante dans MoveNext saute à l”instruction immédiatement après cette suspension. Un await qui ne s”est pas terminé et un yield return qui vient de produire un élément font la même chose — ranger un numéro de reprise dans <>1__state et retourner — et les deux sont décodés de la même façon au retour.

MoveNext : switch (<>1__state)switch (<>1__state)aiguillage unique, tête du corpsstate = -1première entrée → exécuterdepuis le débutstate = 0 (await)reprend aprèsl'awaiter <>u__1state = 1 (yield)reprend après laconsommation de l'élémentsuspendre : <>1__state = n; returnawait (awaiter non terminé) et yield return stockent n iciLe MoveNext suivant réentre dans le switch et atterrit sur le cas stocké.state = -2sentinelle en exécutionUn entier encode « quel await » et « quel yield » — il n'y a pas de second compteur.
Une unique valeur de <>1__state pilote l'aiguillage de MoveNext : −1 est l'entrée, −2 est la sentinelle en exécution, et chaque cas non négatif reprend après une suspension précise — que cette suspension ait été un await ou un yield return.

Le protocole MoveNextAsync / ValueTask

Le consommateur n”appelle jamais MoveNext directement. Il appelle MoveNextAsync, qui renvoie un ValueTask<bool> — true si un élément est prêt dans Current, false à la fin. La partie élégante est l”origine de ce ValueTask. La structure est la source de la tâche :

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 est un ManualResetValueTaskSourceCore<bool>, et comme la structure implémente IValueTaskSource<bool>, le ValueTask<bool>(this, version) renvoyé est adossé à la machine à états elle-même — aucune allocation de Task par élément. Lorsque MoveNext s”exécute, l”une de trois choses se produit : il atteint un await non terminé et enregistre la continuation de l”awaiter pour qu”elle rappelle ; il atteint un yield return, écrit la valeur dans <>2__current, définit <>1__state au point de reprise du yield et appelle <>v__promise.SetResult(true) ; ou il sort par la fin et appelle SetResult(false). La continuation de l”awaiter, lorsque le travail attendu se termine, réentre dans MoveNext via le builder, et la boucle continue. Ce SetResult(true) avec une valeur garée dans <>2__current est la signature à l”exécution d”un unique yield return situé derrière un await.

Comment Glass le reconstruit

Glass n”essaie pas d”« exécuter » cette machine. Il la lit. La reconstruction est une séquence fixe :

  1. Identifier l”empreinte du type. Une structure imbriquée [CompilerGenerated] implémentant IAsyncEnumerable<T> + IAsyncEnumerator<T> + IAsyncStateMachine + IValueTaskSource<bool>, portant un AsyncIteratorMethodBuilder et un ManualResetValueTaskSourceCore — c”est un itérateur asynchrone et rien d”autre. La méthode d”origine est celle dont le corps a été remplacé par le stub de démarrage du builder qui construit cette structure.
  2. Récupérer les paramètres. Les champs préfixés par <>3__ se mappent sur les paramètres de la méthode ; un champ <>x__combinedTokens plus un appel à CreateLinkedTokenSource dans GetAsyncEnumerator signifie que le paramètre du jeton portait [EnumeratorCancellation], que Glass rattache.
  3. Lire l”aiguillage. Le switch (<>1__state) en tête de MoveNext donne tous les points de reprise. Glass classe chacun : un cas qui reprend juste après un GetResult sur un awaiter <>u__N est un await ; un cas qui reprend juste après un SetResult(true) qui a stocké dans <>2__current est un yield return.
  4. Reconstruire le flux de contrôle. Les variables locales hissées (<reader>5__2, <line>5__3) redeviennent des variables locales ordinaires ; le while que le compilateur a aplati en gotos entre états est replié en une boucle ; le using var reader est récupéré à partir du chemin de nettoyage DisposeAsync/<>w__disposeMode. Ce qui en ressort est le ReadBatchesAsync que vous avez écrit, pas la structure.

Depuis la CLI, tout tient en une seule commande :

$ glass export ./App.dll --member "M:App.Reader.ReadBatchesAsync(System.String,System.Threading.CancellationToken)"

Vous obtenez l”async IAsyncEnumerable<int> reconstruit avec son await et son yield return intacts et le [EnumeratorCancellation] de retour sur le jeton. Ajoutez --il et Glass montre l”autre côté honnête : la structure <ReadBatchesAsync>d__0, le switch (<>1__state) et les appels à SetResult que la vue C# masque.

Mises en garde et là où ça se corse

Deux limites honnêtes. Premièrement, la correspondance entre état et construction n”est nette que lorsque les motifs d”awaiter et de yield correspondent à ce qu”émet le Roslyn actuel ; de l”IL écrit à la main, ou une structure produite par un compilateur différent, peut se suspendre sous des formes que Glass n”a pas identifiées, et alors la vue IL est le recours véridique — vous voyez le vrai switch même si l”await foreach de haut niveau ne peut pas être nommé. Deuxièmement, un inlining ou une optimisation poussés peuvent fusionner des points de reprise et partager des variables locales hissées entre ce qui était logiquement des await distincts, de sorte que la boucle reconstruite est fidèle à l”IL mais peut ne pas correspondre caractère par caractère au code d”origine. Le chemin <>w__disposeMode en particulier encode l”interaction entre await using, un break anticipé et DisposeAsync, et reconstruire l”emplacement exact d”un finally là est la partie la plus subtile du travail.

À retenir

Un itérateur asynchrone est le seul endroit en C# où deux mécanismes de suspension distincts sont soudés en une unique méthode réentrante. Le compilateur l”exprime comme une seule structure générée qui est énumérable, énumérateur, machine à états asynchrone et IValueTaskSource tout à la fois, avec un unique champ <>1__state qui multiplexe chaque await et chaque yield return, un <>2__current contenant l”élément, et un ManualResetValueTaskSourceCore pour que l”extraction d”un flux n”alloue aucune Task par élément. Glass.NET lit cette empreinte, décode l”aiguillage switch (<>1__state), classe chaque point de reprise comme un await ou un yield return, et reconstruit le code d”origine await foreach/yield return — attribut d”annulation compris — en analyse statique pure, sans jamais exécuter une ligne. Récupérez la version gratuite sur la page de téléchargement de Glass.NET et ouvrez la vue IL sur le prochain async IAsyncEnumerable<T> que vous devez comprendre.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.