Apprivoiser les fonctions asynchrones

Il est possible en C# d'exécuter certaines fonctions de manière asynchrone, au sens où la fonction appelée retournera avant d'avoir complété son traitement, et retournera un objet qui permettra de valider la complétion du traitement (ou, dans le cas de fonctions non-void, de consommer la valeur de retour) à un moment ultérieur.

Exemple simple

Pour un exemple simple, voici une fonction qui appelle une fonction asynchrone CalculerTruc(), puis lit une touche, affiche la touche lue, et affiche enfin le résultat du calcul fait par CalculerTruc(). Essayez le programme; si vous entrez une touche dans les deux premières secondes, la touche entrée s'affichera tout de suite, puis il y aura un délai avant que la valeur retournée par CalculerTruc() ne s'affiche :

using System;
using System.Threading.Tasks;

var c = CalculerTruc();
Console.WriteLine(Console.ReadKey(true).KeyChar);
Console.WriteLine(c.Result);

static async Task<char> CalculerTruc()
{
   await Task.Delay(2000);
   return 'X';
}

Qu'est-ce qui explique ce comportement? Voici :

• La fonction CalculerTruc est marquée async. Cela signifie qu'elle retournera non pas un T (ici, un char) mais bien un Task<T> (ici, un Task<char>). Ce type est dit Awaitable, au sens où il représente une tâche potentiellement encore en cours, pas le résultat d'un calcul
• Remarquez que CalculerTruc se suspend de manière asynchrone en appelant await Task.Delay. Cela signifie que l'attente de 2000 millisecondes démarre, mais ne bloque pas l'exécution. La fonction poursuit donc son exécution jusqu'au return, mais retourne un Task<char>, pas un char. Cela signifie que l'objet retourné contiendra un char quand toutes les tâches asynchrones qui précédaient sa construction seront complétées
• Dans Main, il est donc possible de lire une touche et de l'afficher, même si l'appel à Task.Delay ne s'est pas encore complété
• Pour obtenir le résultat (le char) retourné par CalculerTruc, il faut utiliser la propriété Result du Task<char>. Consulter Result bloquera jusqu'à ce que la fonction asynchrone CalculerTruc soit complétée, donc jusqu'à ce que Task.Delay soit complété

Avec des fonctions asynchrones, on parvient donc, en quelque sorte, à faire de la multiprogrammation sans avoir besoin de plusieurs fils d'exécution.

Calcul parallèle asynchrone

Référez-vous à ../../../Sujets/Divers--cdiese/async_await.html pour ceci. Vous remarquerez que le calcul, s'il est fait de manière asynchrone, permet au code client de gagner beaucoup de temps en ne bloquant pas pendant que l'un ou l'autre des calculs se complète. Le moment où il y a lieu de bloquer est celui où le résultat du calcul devient nécessaire; moins un programme bloquera, règle générale, et plus il sera efficace.

Transformer une tâche synchrone en tâche asynchrone

Que faire si nous réalisons un calcul synchrone que nous voulons transformer en calcul asynchrone, pour quelque raison que ce soit? Une solution simple est d'utiliser Task.Run, qui accepte une tâche synchrone, l'exécute de manière asynchrone et retourne le Task<T> correspondant. Pour un exemple archi-simpliste :

static int Somme(int x, int y) => x + y;
static void Afficher()
{
   Console.Write(Somme(2,3));
}

static async Task<int> SommeAsync(int x, int y) => await Task.Run(() => x + y);
static void Afficher()
{
   var res = SommeAsync(2,3);
   Console.Write(res.Result);
}

Évidemment, une somme d'entiers n'est probablement pas un calcul qui mérite un tel traitement, mais cela permet au moins d'illustrer la syntaxe.

On peut aussi enchaîner les calculs asynchrones et n'attendre qu'après le résultat de l'ensemble de ceux-ci. Par exemple :

Console.WriteLine(Calculer(2, 3).Result);

static async Task<int> SommeAsync(int x, int y) =τ
   await Task.Run(() => x + y);
static async Task<int> Calculer(int x, int y)
{
   var res = await SommeAsync(2, 3);
   return await Task.Run(() => res * 10);
}

Ici, Calculer exécutera SommeAsync de manière asynchrone, puis utilisera (grâce à await) la forme « développée » de res (un Task<int> traité comme s'il s'agissait d'un int) dans ses propres calculs. Le code de Calculer semble opérer sur des int (c'est simple!), et le code client (l'affichage, qui utilise la propriété Result) est le seul point où un blocage en attente d'un résultat surviendra.

Réaliser une tâche bloquante de manière asynchrone

Si nous souhaitons faire une tâche comme celle décrite dans ../../../Sujets/Client-Serveur/TiPointsCDiese.html, soit afficher un petit point à l'écran jusqu'à ce que l'usager appuie sur une touche, l'approche asynchrone devient un peu délicate.

En effet, le réflexe serait d'appeler de manière asynchrone deux fonctions, appelons-les LireTouche et Attendre, où LireTouche lirait une touche de manière bloquante, et où Attendre se suspendrait pour une seconde, puis de faire un Task.WhenAny sur cette paire de fonctions pour savoir laquelle s'est complétée d'abord : si nous avons lu une touche, alors le programme se termine, alors que si l'attente d'une seconde a expiré en premier lieu, nous affichons un '.' à l'écran.

Naïvement, nous obtiendrions :

// ...
bool fini = false;
do
{
   var tâches = new List<Task<ConsoleKey>>() { Attendre(), LireTouche() };
   var résultat = Task.WhenAny(tâches);
   fini = résultat.Result.Result != default;
   if (!fini)
   {
      Console.Write('.');
   }
}
while (!fini);

static async Task<ConsoleKey> Attendre()
{
   await Task.Delay(1000);
   return default; // voir plus bas
}
static async Task<ConsoleKey> LireTouche()
{
   return await Task.Run(() => Console.ReadKey(true).Key);
}
// ...

... ce qui n'est pas la plus jolie structure de boucle (deux tests sur fini), mais soit. Cela dit, vous pouvez l'essayer, ça ne fonctionne pas tout à fait.

Qu'advient-il des tâches asynchrones non terminées?

Le problème ici est que si une touche n'a pas été lue, LireTouche s'exécute encore, et que si nous exécutons un autre LireTouche comme c'est le cas avec ce programme un peu trop naïf, nous aurons deux fonctions qui chercheront à lire du clavier, ce qui bloquera la bonne exécution du programme. En effet, avec une fonction comme WhenAny, les tâches asynchrones autres que la première s'exécuteront jusqu'à la fin et le résultat de leur traitement sera simplement « oublié ». Exprimé simplement, ça ne fonctionnera pas.

Il nous faudra donc ajuster un peu le code pour être en mesure d'annuler la fonction LireTouche si l'exécution de celle-ci ne s'est pas encore complétée.

Gérer l'annulation des tâches asynchrones

La bibliothèque de tâches asynchrones de C# comprend quelques outils pour faciliter la gestion collaborative de l'annulation de tâches asynchrones. Parmi ceux-ci, on trouve le type CancellationTokenSource et le type CancellationToken.

L'idée va comme suit :

• La fonction d'origine, qui lancera des tâches asynchrones créera un CancellationTokenSource
• De cette CancellationTokenSource, elle obtiendra un jeton de type CancellationToken
• Ce jeton sera passé en paramètre aux tâches asynchrones, et permettra à la fonction d'origine (qui possède le CancellationTokenSource) de demander l'annulation des tâches non-complétées
• Les tâches asynchrones auront quant à elles deux options :
  • S'assurer de vérifier régulièrement si une demande d'annulation est signalée (ce sera le cas de LireTouche, qui utilise la fonction ReadKey qui n'est pas asycnhrone en soi), ou
  • Passer le jeton d'annulation en paramètre à d'autres fonctions asynchrones (ce sera le cas de Attendre, qui utilise Task.Delay qui est asynchrone et tient compte des instances de CancellationToken)
• Si une tâche asynchrone constate le signalement d'une demande d'annulation, son exécution se terminera et elle lèvera une exception de type OperationCanceledException, qu'il nous faudra gérer (quitte à ne rien faire, car ce n'est pas tant une erreur pour nous qu'une situation normale)

Voyons voir comment nous pourrons appliquer ce mécanisme à notre programme pour le rendre un peu moins naïf.

Une solution plus complète

Une solution plus complète pourrait être la suivante :

// ...
static async Task<ConsoleKey> LireTouche(CancellationToken jeton)
{
   ConsoleKey touche = default;
   await Task.Run(() =>
   {
      while (!Console.KeyAvailable)
         if (jeton.IsCancellationRequested)
            return;
      touche = Console.ReadKey(true).Key;
   });
   return touche;
}

static async Task<ConsoleKey> Attendre(CancellationToken jeton)
{
   await Task.Delay(1000, jeton);
   return default;
}

static bool ChoisirParmiActions<T>(Func<T, bool> terminer,
                                   params Func<CancellationToken, Task<T>> [] fcts)
{
   var ctSrc = new CancellationTokenSource();
   var jeton = ctSrc.Token;
   var résultats = new List<Task<T>>();
   foreach (var f in fcts)
      résultats.Add(f(jeton));
   bool fini = false;
   try
   {
      var laquelle = Task.WhenAny(résultats).Result;
      fini = terminer(laquelle.Result);
      ctSrc.Cancel();
   }
   catch (OperationCanceledException)
   {
   }
   return fini;
}

// ...
while (!ChoisirParmiActions(k => k != default,
                            Attendre, LireTouche))
{
   Console.Write(".");
}
// ...

static U ChoisirParmiActions<T,U>(Func<T, U> ensuite, params Func<CancellationToken, Task<T>> [] fcts)
{
   var ctSrc = new CancellationTokenSource();
   var jeton = ctSrc.Token;
   var résultats = new List<Task<T>>();
   foreach (var f in fcts)
      résultats.Add(f(jeton));
   U conclusion = default;
   try
   {
      var laquelle = Task.WhenAny(résultats).Result;
      conclusion = ensuite(laquelle.Result);
      ctSrc.Cancel();
   }
   catch (OperationCanceledException)
   {
   }
   return conclusion;
}

Quelques règles

Une fonction qui fait un await doit être qualifiée async et retourner une sorte de Task. Cela signifie qu'il est possible de l'appeler sans bloquer. Quand la valeur retournée sera consommée (au point où await se trouve, conceptuellement), elle sera « développée » implicitement, transformant le Task<T> en T.

Une fonction peut consommer la valeur de retour d'une fonction async de manière synchrone, en l'appelant sans faire await. Ceci permet à la fonction appelante d'être synchrone si elle le souhaite. Pour extraire le résultat de la Task<T> retournée, la fonction bloquera sur la propriété Result de cet objet.

Petite course entre fonctions asynchrones

Soit les deux fonctions asynchrones FA et FB ci-dessous. Nous souhaitons que les deux s'exécutent, et que le programme ne consomme le résultat de la première ayant terminé (la gagnante de la course). Une implémentation possible serait :

// ...
var r = new Random();
var tâches = new Task<string>[] { FA(r), FB(r) };
var rés = Task.WaitAny(tâches);
Console.WriteLine($"La gagnante est {tâches[rés].Result}");

static async Task<string> FA(Random r)
{
   await Task.Delay(r.Next(100, 150));
   return "A";
}
static async Task<string> FB(Random r)
{
   await Task.Delay(r.Next(100, 150));
   return "B";
}

... où parfois A gagnera, et parfois B gagnera.

Visiblement, il serait possible de simplifier ce programme, les tâches asynchrones étant toutes identiques au message retourné près :

// ...
var r = new Random();
var tâches = new Task<string>[] { Coureur(r, "A"), Coureur(r, "B") };
var rés = Task.WaitAny(tâches);
Console.WriteLine($"La gagnante est {tâches[rés].Result}");

static async Task<string> Coureur(Random r, string s)
{
   await Task.Delay(r.Next(100, 150));
   return s;
}
// ...

... ce qui donne envie d'exprimer le même code avec des expressions λ, qui peuvent d'ailleurs être asynchrones elles aussi :

// ...
const int N = 10;
var r = new Random();
var tâches = new Func<Task<string>>[N];
for (int i = 0; i != tâches.Length; ++i)
{
   string s = new string((char)('A' + i), 1);
   tâches[i] = async () =>
   {
      await Task.Delay(r.Next(100, 150));
      return s;
   };
}
var résultats = new Task<string>[N];
for (int i = 0; i != tâches.Length; ++i)
   résultats[i] = tâches[i]();

var laquelle = Task.WaitAny(résultats);
Console.WriteLine($"La gagnante est {résultats[laquelle].Result}");
// ...

Une λ asynchrone retourne une Task<T> (ici, une Task<string>). Notre exemple crée toutes les fonctions asynchrones, puis les exécute, puis bloque jusqu'à ce que l'une de ces fonctions se termine et affiche la valeur retournée par cette dernière.

Notez que j'ai utilisé WaitAny, qui retourne l'indice de la tâche ayant terminé son exécution en premier. D'autres services existent :

// ...
var laquelle = Task.WhenAny(résultats);
Console.WriteLine($"La gagnante est {laquelle.Result.Result}");
// ...

// ...
Task.WaitAll(résultats);
Console.WriteLine("La course est terminée");
// ...

// ...
var jeton = Task.WhenAll(résultats);
// ... faire des trucs
jeton.Wait(); // supposant qu'on doive maintenant
              // attendre la fin des travaux
Console.WriteLine("La course est terminée");
// ...

Quelques exercices

Voici quelques exercices que je vous recommande de faire.

EX00 – Le programme suivant lit une URL de manière synchrone et dépose le résultat dans un fichier :

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

using (var client = new HttpClient())
{
   var s = client.GetStringAsync("https://h-deb.ca").Result; // URL prise au hasard
   using (var sw = new StreamWriter("h-deb-racine.txt"))
      sw.Write(s);
}

Transformez ce programme pour qu'il consomme une série d'URL de manière asynchrone et place le texte consommé de chacune dans un fichier distinct. Pour ce faire, écrivez une fonction asynchrone LireUrl() qui lira une URL et retournera un Task<string>, puis appelez cette fonction pour chaque URL à consommer. Prenez soin de vous assurer que toutes les URL aient été lues avant que le processus ne termine son exécution!

EX01 – Examinez le pipeline proposé à EX02 de exercice-apprivoiser-multiprog.html. Écrivez un programme équivalent, mais où plutôt que d'avoir un fil d'exécution par tâche, vous avez une fonction asychrone par tâche.

EX02 – Examinez le pipeline proposé à EX03 de exercice-apprivoiser-multiprog.html. Écrivez un programme équivalent, mais où plutôt que d'avoir un fil d'exécution par tâche, vous avez une fonction asychrone par tâche.