Programmation asynchrone

using System;
using System.Diagnostics;
using System.Threading.Tasks;

static class Duree
{
    // Aucun thread ne porte cette attente : Task.Delay arme un minuteur et rend
    // la main. La methode ne reprendra qu'au declenchement.
    static async Task<int> LireAsync(string source, int millisecondes)
    {
        await Task.Delay(millisecondes);
        return source.Length;
    }

    public static async Task ExecuterAsync()
    {
        var chrono = Stopwatch.StartNew();

        // await suspend la methode sur place : le second appel n'est meme pas
        // parti quand la premiere attente commence.
        var clients = await LireAsync("clients", 400);
        var commandes = await LireAsync("commandes", 400);
        Console.WriteLine($"serie      {clients + commandes} en {chrono.ElapsedMilliseconds} ms");
        // serie      16 en 8xx ms : les deux attentes se suivent

        chrono.Restart();

        // Appeler une methode async la demarre. Les deux Task sont en vol avant
        // le premier await, donc les deux attentes se recouvrent.
        var tacheClients = LireAsync("clients", 400);
        var tacheCommandes = LireAsync("commandes", 400);
        var tailles = await Task.WhenAll(tacheClients, tacheCommandes);
        var total = tailles[0] + tailles[1];
        Console.WriteLine($"concurrent {total} en {chrono.ElapsedMilliseconds} ms");
        // concurrent 16 en 4xx ms : la duree est celle de la plus longue

        // Les millisecondes exactes varient : Task.Delay garantit un minimum,
        // pas une precision. Le rapport du simple au double, lui, tient.
    }
}

using System.Data;
using System.Threading.Tasks;

public sealed class DepotTarifs
{
    private readonly IDbConnection connexion;

    public DepotTarifs(IDbConnection connexion) => this.connexion = connexion;

    private int Lire(string reference)
    {
        using var commande = connexion.CreateCommand();
        commande.CommandText = "select tarif from tarifs where reference = @r";
        return (int)commande.ExecuteScalar()!;
    }

    // Task.Run ne rend rien asynchrone. Il deplace un appel bloquant sur un
    // thread du pool : le thread de la requete est libere, un autre thread du
    // pool est bloque exactement aussi longtemps. Sur un serveur, ou tous les
    // threads viennent du meme pool, le bilan est negatif : deux basculements
    // de contexte de plus, et pas une attente de moins.
    public Task<int> LireAsync(string reference) => Task.Run(() => Lire(reference));
}

using System.Data.Common;
using System.Threading;
using System.Threading.Tasks;

public sealed class DepotTarifs
{
    private readonly DbConnection connexion;

    public DepotTarifs(DbConnection connexion) => this.connexion = connexion;

    // Quand l'operation est une entree-sortie, l'API asynchrone existe deja :
    // elle rend la main pendant que la carte reseau travaille, et aucun thread
    // n'attend la reponse.
    public async Task<int> LireAsync(string reference, CancellationToken cancellationToken)
    {
        await using var commande = connexion.CreateCommand();
        commande.CommandText = "select tarif from tarifs where reference = @r";
        var valeur = await commande.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false);
        return (int)valeur!;
    }

    // Task.Run garde un usage : sortir un calcul d'un thread qu'il ne faut pas
    // bloquer, celui de l'interface. Sur un serveur, il n'y a rien a liberer.
    public static Task<long> CumulerAsync(int[] valeurs, CancellationToken cancellationToken) =>
        Task.Run(
            () =>
            {
                var total = 0L;
                foreach (var valeur in valeurs)
                {
                    cancellationToken.ThrowIfCancellationRequested();
                    total += (long)valeur * valeur;
                }

                return total;
            },
            cancellationToken);
}

using System.Net.Http;
using System.Threading.Tasks;

public static class Catalogue
{
    private static readonly HttpClient Client = new();

    public static async Task<int> TailleAsync(string url)
    {
        var contenu = await Client.GetStringAsync(url);
        return contenu.Length;
    }

    // Ce que le compilateur ecrit a la place, en substance. En Release la
    // machine a etats est une struct, en Debug une classe, car le debogueur a
    // besoin d'une reference stable.
    //
    // public static Task<int> TailleAsync(string url)
    // {
    //     var machine = new Machine
    //     {
    //         url = url,
    //         builder = AsyncTaskMethodBuilder<int>.Create(),
    //         etat = -1,
    //     };
    //
    //     // Start appelle MoveNext tout de suite, sur le thread appelant : le
    //     // corps s'execute de facon synchrone jusqu'au premier await qui
    //     // suspend vraiment.
    //     machine.builder.Start(ref machine);
    //     return machine.builder.Task;
    // }
    //
    // struct Machine : IAsyncStateMachine
    // {
    //     public int etat;
    //     public AsyncTaskMethodBuilder<int> builder;
    //     public string url;
    //     private TaskAwaiter<string> attente;
    //
    //     public void MoveNext()
    //     {
    //         string contenu;
    //         try
    //         {
    //             if (etat != 0)
    //             {
    //                 attente = Client.GetStringAsync(url).GetAwaiter();
    //
    //                 // Le raccourci qui fait tout l'interet du modele : si la
    //                 // tache est deja terminee, rien n'est suspendu, rien
    //                 // n'est alloue sur le tas, et on tombe directement sur
    //                 // GetResult.
    //                 if (!attente.IsCompleted)
    //                 {
    //                     etat = 0;
    //
    //                     // Copie la struct sur le tas, puis inscrit MoveNext
    //                     // comme continuation de l'attente. La methode rend
    //                     // la main ici : l'appelant recoit une Task en cours.
    //                     builder.AwaitUnsafeOnCompleted(ref attente, ref this);
    //                     return;
    //                 }
    //             }
    //
    //             // Reprise. GetResult rend la valeur, ou relance l'exception
    //             // de la tache telle quelle, sans AggregateException autour.
    //             contenu = attente.GetResult();
    //         }
    //         catch (Exception erreur)
    //         {
    //             // Une exception ne remonte pas a l'appelant : elle est
    //             // deposee dans la Task rendue.
    //             builder.SetException(erreur);
    //             return;
    //         }
    //
    //         builder.SetResult(contenu.Length);
    //     }
    // }
}

using System;
using System.Threading;
using System.Threading.Tasks;

static class Reprise
{
    public static async Task ExecuterAsync()
    {
        Console.WriteLine(SynchronizationContext.Current is null); // True : une console n'en a pas
        Console.WriteLine(Thread.CurrentThread.IsThreadPoolThread); // False : le thread principal

        // Sans SynchronizationContext et avec l'ordonnanceur par defaut, il n'y
        // a aucun contexte a restaurer : la continuation est planifiee sur le
        // pool de threads.
        await Task.Delay(50);

        Console.WriteLine(Thread.CurrentThread.IsThreadPoolThread); // True

        // Une tache deja terminee ne suspend rien : IsCompleted est vrai, la
        // suite s'execute dans la foulee, sur le meme thread. Un await n'est
        // donc pas un point de bascule, c'est un point de bascule possible.
        var avant = Environment.CurrentManagedThreadId;
        await Task.CompletedTask;
        Console.WriteLine(Environment.CurrentManagedThreadId == avant); // True

        // Task.Yield ne se termine jamais de facon synchrone : il reprend la
        // methode par le contexte courant, ou par le pool a defaut. Depuis
        // .NET 8, ConfigureAwait(ForceYielding) impose la meme chose.
        await Task.Yield();
        Console.WriteLine(Thread.CurrentThread.IsThreadPoolThread); // True
    }
}

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

sealed class CacheTarifs
{
    private readonly Dictionary<string, int> cache = [];

    private static async Task<int> ChargerAsync(string reference)
    {
        await Task.Delay(20);
        return reference.Length * 150;
    }

    // Le cas frequent rend une valeur deja connue. Une Task ici serait une
    // allocation par appel pour un resultat immediat ; ValueTask est une struct
    // qui porte soit le resultat, soit la Task du cas lent.
    public ValueTask<int> ObtenirAsync(string reference)
    {
        if (cache.TryGetValue(reference, out var tarif))
        {
            return new ValueTask<int>(tarif);
        }

        return new ValueTask<int>(ChargerPuisMemoriserAsync(reference));
    }

    private async Task<int> ChargerPuisMemoriserAsync(string reference)
    {
        var tarif = await ChargerAsync(reference);
        cache[reference] = tarif;
        return tarif;
    }
}

static class Tarifs
{
    public static async Task ExecuterAsync()
    {
        var cache = new CacheTarifs();

        // Un ValueTask s'attend une fois, et une seule. Apres GetResult, la
        // structure ne promet plus rien : quand elle enveloppe un
        // IValueTaskSource, c'est le cas de Stream.ReadAsync ou d'un Channel,
        // la source recycle son jeton et repond a la question suivante.
        Console.WriteLine(await cache.ObtenirAsync("USB-64")); // 900
        Console.WriteLine(await cache.ObtenirAsync("USB-64")); // 900, servi par le cache

        // Pour le garder, le passer a plusieurs endroits ou l'attendre deux
        // fois, il faut d'abord le figer avec AsTask.
        var tache = cache.ObtenirAsync("CLE-USB-32").AsTask();
        Console.WriteLine(await tache); // 1500
        Console.WriteLine(await tache); // 1500 : une Task, elle, se rattend
    }
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

// WinForms, WPF, MAUI : le gestionnaire s'execute sur le thread d'interface,
// qui porte un SynchronizationContext a file unique : une seule chose a la
// fois, et toujours sur ce thread-la.
public sealed class FenetreCommandes
{
    private static readonly HttpClient Client = new();

    private static async Task<string> LireAsync()
    {
        // Cet await capture le contexte courant, donc celui de l'interface, et
        // s'engage a reprendre dessus.
        return await Client.GetStringAsync("https://exemple.fr/commandes");
    }

    public void Bouton_Click(object? expediteur, EventArgs e)
    {
        // .Result bloque le thread d'interface jusqu'a la fin de la tache. Mais
        // la tache ne peut finir que si la suite de LireAsync s'execute, et
        // cette suite est en file d'attente sur ce meme thread, qui ne depilera
        // plus rien tant qu'il est bloque ici. Les deux s'attendent, pour
        // toujours. Wait(), GetAwaiter().GetResult() et WaitAll produisent le
        // meme effet, pour la meme raison.
        var texte = LireAsync().Result;

        Console.WriteLine(texte.Length);
    }
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

public sealed class FenetreCommandes
{
    private static readonly HttpClient Client = new();

    private static Task<string> LireAsync() =>
        Client.GetStringAsync("https://exemple.fr/commandes");

    // async void est tolere ici, et seulement ici : un gestionnaire d'evenement
    // doit respecter la signature du delegue. Le thread d'interface est rendu
    // au premier await, la file continue de tourner, et la suite y revient
    // quand la reponse arrive.
    public async void Bouton_Click(object? expediteur, EventArgs e)
    {
        // Le corps entier est enveloppe : une exception qui sort d'un async
        // void n'a aucune Task ou se poser. Elle part au gestionnaire de
        // dernier recours de l'hote, que l'appelant ne voit jamais.
        try
        {
            var texte = await LireAsync();
            Console.WriteLine(texte.Length);
        }
        catch (HttpRequestException erreur)
        {
            Console.WriteLine(erreur.Message);
        }
    }
}

using System;
using System.Threading.Tasks;

static class Import
{
    // async void : le builder est AsyncVoidMethodBuilder. Il n'a pas de Task
    // ou deposer un resultat, ni une exception.
    static async void TraiterAsync(string fichier)
    {
        await Task.Delay(50);
        throw new InvalidOperationException($"Fichier illisible : {fichier}");
    }

    public static async Task ExecuterAsync()
    {
        try
        {
            // L'appel rend la main au premier await, donc avant l'exception.
            // Le try est referme depuis longtemps quand elle est levee.
            TraiterAsync("stock.csv");
        }
        catch (InvalidOperationException)
        {
            Console.WriteLine("rattrapee"); // jamais affiche
        }

        // Faute de Task, le builder relance l'exception sur le
        // SynchronizationContext capture au demarrage, ou sur le pool de
        // threads s'il n'y en avait pas. Elle devient une exception non geree :
        // le processus s'arrete.
        await Task.Delay(500);

        Console.WriteLine("jamais atteint");
    }
}

using System;
using System.Threading.Tasks;

static class Import
{
    // async Task : l'exception est deposee dans la tache rendue, et relancee
    // telle quelle par l'await de l'appelant.
    static async Task TraiterAsync(string fichier)
    {
        await Task.Delay(50);
        throw new InvalidOperationException($"Fichier illisible : {fichier}");
    }

    public static async Task ExecuterAsync()
    {
        try
        {
            await TraiterAsync("stock.csv");
        }
        catch (InvalidOperationException erreur)
        {
            Console.WriteLine(erreur.Message); // Fichier illisible : stock.csv
        }

        // Le type de retour ne suffit pas : c'est l'await qui lit la tache.
        // Sans lui, l'exception reste dedans, personne ne la regarde, et depuis
        // .NET Framework 4.5 elle ne termine plus le processus : elle disparait
        // en silence, ce qui est pire.
        _ = TraiterAsync("ventes.csv");

        await Task.Delay(500);
        Console.WriteLine("termine"); // termine
    }
}

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

// Une bibliotheque ignore qui l'appelle. Revenir sur le contexte de l'appelant
// ne lui sert a rien, et le lui imposer suffit a l'interbloquer quand cet
// appelant est une interface graphique qui bloque son propre thread.
public sealed class ClientTarifs
{
    private readonly HttpClient client;

    public ClientTarifs(HttpClient client) => this.client = client;

    public async Task<int> LireAsync(string reference, CancellationToken cancellationToken)
    {
        var url = $"https://exemple.fr/tarifs/{reference}";

        // ConfigureAwait(false) dit « la suite n'a pas besoin du contexte ». La
        // continuation part alors au pool de threads, ou s'execute en ligne sur
        // le thread qui termine la tache.
        var corps = await client.GetStringAsync(url, cancellationToken).ConfigureAwait(false);

        // A partir d'ici, aucun contexte n'est capture : on a quitte celui de
        // l'appelant, et rien ne le retablit avant le retour.
        return corps.Length;
    }

    // Il porte sur le seul await qui le suit, pas sur la methode. Un await
    // oublie remet les continuations suivantes dans le contexte de l'appelant.
    public async Task<int> LireDeuxAsync(string a, string b, CancellationToken cancellationToken)
    {
        var premier = await LireAsync(a, cancellationToken).ConfigureAwait(false);
        var second = await LireAsync(b, cancellationToken).ConfigureAwait(false);
        return premier + second;
    }

    // Et il ne fait rien du tout quand la tache est deja terminee : l'await ne
    // suspend pas, donc il n'y a aucune continuation a planifier, et rien a
    // configurer.
    public ValueTask<int> LireEnCacheAsync(int deja) => new(deja);

    // .NET 8 ajoute une surcharge a options, sur Task comme sur Task<T>.
    // ForceYielding impose la suspension meme sur une tache deja terminee : de
    // quoi garantir qu'une methode ne rend jamais la main de facon synchrone.
    // SuppressThrowing, lui, n'a de sens que sur le Task non generique ; sur un
    // Task<T> il leve ArgumentOutOfRangeException, et l'analyseur CA2261 le
    // signale des la compilation.
    public static async Task RendreLaMainAsync() =>
        await Task.CompletedTask.ConfigureAwait(ConfigureAwaitOptions.ForceYielding);
}

using System;
using System.Threading;
using System.Threading.Tasks;

static class Traitement
{
    // Le jeton est un parametre ordinaire : rien ne le transporte tout seul
    // d'un niveau d'appel au suivant. La convention le met en dernier, sous le
    // nom cancellationToken.
    static async Task<int> LireLotAsync(int numero, CancellationToken cancellationToken)
    {
        // Les API asynchrones de la BCL prennent le jeton et abandonnent
        // l'attente elles-memes, sans aller au bout du delai.
        await Task.Delay(100, cancellationToken);
        return numero * 10;
    }

    static async Task<int> TraiterAsync(int lots, CancellationToken cancellationToken)
    {
        var total = 0;

        for (var numero = 1; numero <= lots; numero++)
        {
            // Entre deux appels, c'est au code de regarder. Un jeton qu'on se
            // contente de faire suivre n'interrompt rien de ce qui se passe
            // entre les operations d'entree-sortie.
            cancellationToken.ThrowIfCancellationRequested();

            total += await LireLotAsync(numero, cancellationToken);
        }

        return total;
    }

    public static async Task ExecuterAsync()
    {
        // Le CancellationTokenSource detient un minuteur : il se libere.
        using var source = new CancellationTokenSource(TimeSpan.FromMilliseconds(250));

        try
        {
            // Dix lots de 100 ms : l'arret tombe a coup sur avant la fin, mais
            // le lot sur lequel il tombe depend de la machine.
            await TraiterAsync(10, source.Token);
            Console.WriteLine("termine");
        }
        catch (OperationCanceledException)
        {
            // TaskCanceledException en derive : un seul catch couvre les deux.
            // Qui a demande l'arret se lit sur la source de l'appelant : le jeton
            // porte par l'exception n'est le sien que si personne ne l'a lie plus bas.
            Console.WriteLine("annule");                       // annule
            Console.WriteLine(source.IsCancellationRequested); // True
        }
    }
}

using System;
using System.Threading.Tasks;

static class Agregat
{
    static async Task<int> LireAsync(string source, int valeur)
    {
        await Task.Delay(30);

        if (valeur < 0)
        {
            throw new InvalidOperationException($"{source} indisponible");
        }

        return valeur;
    }

    public static async Task ExecuterAsync()
    {
        // WhenAll ne demarre rien : les taches tournent deja. Il ne fait
        // qu'observer, et rend une tache qui s'acheve quand toutes sont finies.
        var clients = LireAsync("clients", -1);
        var stocks = LireAsync("stocks", -1);
        var tarifs = LireAsync("tarifs", 12);

        var toutes = Task.WhenAll(clients, stocks, tarifs);

        try
        {
            await toutes;
        }
        catch (InvalidOperationException premiere)
        {
            // await ne relance que la premiere exception du lot. C'est ce qui
            // permet d'ecrire un catch sur le type reel, mais cela masque les
            // autres echecs.
            Console.WriteLine(premiere.Message); // clients indisponible

            // Elles sont dans la tache, pas dans l'exception attrapee.
            var agregat = toutes.Exception!;
            Console.WriteLine(agregat.InnerExceptions.Count); // 2

            foreach (var erreur in agregat.InnerExceptions)
            {
                Console.WriteLine($"  {erreur.Message}");
            }
            //   clients indisponible
            //   stocks indisponible
        }

        // Un echec n'annule pas les autres : elles vont au bout, et restent
        // lisibles une a une.
        Console.WriteLine(await tarifs); // 12
    }
}

using System;
using System.Threading;
using System.Threading.Tasks;

static class PremierArrive
{
    static async Task<string> InterrogerAsync(
        string miroir,
        int millisecondes,
        CancellationToken cancellationToken)
    {
        await Task.Delay(millisecondes, cancellationToken);
        return miroir;
    }

    public static async Task ExecuterAsync()
    {
        using var source = new CancellationTokenSource();

        var rapide = InterrogerAsync("miroir-A", 50, source.Token);
        var lent = InterrogerAsync("miroir-B", 5000, source.Token);

        // WhenAny rend la tache gagnante, pas son resultat, et elle peut avoir
        // echoue : c'est le second await qui la deballe et relance son
        // exception s'il y en a une.
        var gagnante = await Task.WhenAny(rapide, lent);
        Console.WriteLine(await gagnante); // miroir-A

        // La perdante n'est pas arretee. Sans annulation, elle tient sa
        // connexion jusqu'au bout et son echec eventuel ne sera jamais observe.
        await source.CancelAsync();

        try
        {
            await lent;
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine(lent.IsCanceled); // True
        }

        // Depuis .NET 6, un delai d'attente ne s'ecrit plus a la main :
        // WaitAsync fait le WhenAny, la source liee et le menage, et leve
        // TimeoutException — sans arreter pour autant l'operation sous-jacente,
        // qui continue jusqu'au bout.
        try
        {
            await InterrogerAsync("miroir-C", 5000, CancellationToken.None)
                .WaitAsync(TimeSpan.FromMilliseconds(50));
        }
        catch (TimeoutException)
        {
            Console.WriteLine("delai depasse"); // delai depasse
        }

        // Et depuis .NET 9, Task.WhenEach rend les taches au fil de leur
        // achevement, sans retirer la gagnante d'une liste a chaque tour.
        var lots = new[]
        {
            InterrogerAsync("lot-1", 10, CancellationToken.None),
            InterrogerAsync("lot-2", 200, CancellationToken.None),
        };

        await foreach (var finie in Task.WhenEach(lots))
        {
            Console.WriteLine(await finie); // lot-1, puis lot-2
        }
    }
}