Commencez avec la programmation asynchrone

  • 10 minutes

Les développeurs utilisent des techniques de programmation asynchrones pour éviter les goulots d’étranglement des performances et améliorer la réactivité globale de leurs applications. Toutefois, les techniques traditionnelles d’écriture d’applications asynchrones peuvent être compliquées, ce qui les rend difficiles à écrire, déboguer et gérer.

C# prend en charge une approche de programmation asynchrone simplifiée qui tire parti de la prise en charge asynchrone dans le runtime .NET. Le compilateur effectue le travail difficile que le développeur a utilisé pour effectuer, et votre application conserve une structure logique qui ressemble à du code synchrone. Par conséquent, vous bénéficiez de tous les avantages de la programmation asynchrone avec une fraction de l’effort.

Comprendre le fonctionnement des processus asynchrones dans le monde réel peut vous aider à comprendre comment utiliser la programmation asynchrone dans vos applications.

Examiner un processus asynchrone dans le monde réel

Faire un petit déjeuner est un bon exemple d’un processus qui bénéficie d’effectuer des tâches de manière asynchrone. Vous pouvez penser à faire du petit déjeuner comme une série de tâches qui peuvent être effectuées de manière synchrone ou asynchrone.

  1. Prenez les ingrédients du petit-déjeuner dans le garde-manger.
  2. Versez une tasse de café.
  3. Faites chauffer une poêle, puis faites frire trois tranches de bacon.
  4. Frire deux œufs.
  5. Faites griller deux tranches de pain.
  6. Étalez le beurre et la confiture sur le toast.
  7. Verser un verre de jus d’orange.

Si vous avez une expérience de cuisson, vous pouvez suivre ces instructions de manière asynchrone. Faites chauffer la poêle pour le lard et les œufs, puis allez chercher les ingrédients dans le garde-manger. Vous mettez le pain dans le grille-pain, puis commencez à cuire le bacon. À chaque étape du processus, vous démarrez une tâche, puis passez à d’autres tâches prêtes pour votre attention.

La cuisson du petit déjeuner est un bon exemple de travail asynchrone qui n’est pas parallèle. Une personne (ou thread) peut gérer toutes les tâches. Une personne peut faire du petit déjeuner de manière asynchrone en démarrant la tâche suivante avant la fin de la tâche précédente. Chaque tâche de cuisson progresse, qu'une personne surveille activement le processus ou non. Dès que vous commencez à réchauffer la casserole, vous pouvez obtenir des ingrédients du garde-manger. Une fois que le bacon commence à cuire, vous pouvez placer le pain dans le grille-pain.

Pour un algorithme parallèle, vous avez besoin de plusieurs personnes qui cuisinent (ou plusieurs threads). Une personne cuisine les œufs, une autre friture le bacon, et ainsi de suite. Chaque personne se concentre sur sa tâche spécifique. Chaque personne qui cuisine (ou chaque thread) est bloquée de manière synchrone en attendant que la tâche en cours se termine : Le lard est prêt à être retourné, le pain est prêt à être mis dans le grille-pain, et ainsi de suite.

En utilisant des techniques de programmation asynchrones, vous pouvez améliorer l’efficacité et la réactivité de votre application, tout comme la façon dont vous pouvez rendre le petit déjeuner plus efficace en effectuant plusieurs tâches à la fois.

Async améliore la réactivité

La synchronisation est essentielle pour les activités potentiellement bloquantes, telles que l’accès web. L’accès à une ressource web est parfois lent ou retardé. Si une telle activité est bloquée dans un processus synchrone, l’application entière doit attendre. Dans un processus asynchrone, l’application peut continuer avec d’autres travaux qui ne dépendent pas de la ressource web tant que la tâche potentiellement bloquante n’est pas terminée.

Le tableau suivant présente les zones typiques où la programmation asynchrone améliore la réactivité. Les API répertoriées à partir de .NET et windows Runtime contiennent des méthodes qui prennent en charge la programmation asynchrone.

Domaine d’application Types .NET avec méthodes asynchrones Types Windows Runtime avec des méthodes asynchrones
Accès web HttpClient Windows.Web.Http.HttpClient, SyndicationClient
Utilisation de fichiers JsonSerializer, StreamReader, StreamWriter, etc. Fichier de stockage
Utilisation d’images MediaCapture, BitmapEncoder, BitmapDecoder
Programmation WCF Opérations synchrones et asynchrones

Comment créer et appeler des méthodes asynchrones

En C#, les opérations asynchrones sont implémentées à l’aide des mots clés async et await. Le async mot clé est utilisé pour définir une méthode asynchrone, tandis que le await mot clé est utilisé pour appeler une méthode asynchrone et attendre son résultat sans bloquer le thread appelant. Les opérations asynchrones sont généralement implémentées à l’aide des types Task ou Task<T>, qui représentent une opération en cours pouvant être mise en attente.

Voici un exemple de création et d’appel d’une tâche asynchrone en C# :


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

public class Program
{
    public static async Task Main()
    {
        string filePath = "example.txt";
        string content = await ReadFileAsync(filePath);
        Console.WriteLine(content);
    }

    public static async Task<string> ReadFileAsync(string filePath)
    {
        using (StreamReader reader = new StreamReader(filePath))
        {
            string content = await reader.ReadToEndAsync();
            return content;
        }
    }
}

Dans cet exemple, la méthode ReadFileAsync est définie à l’aide du mot clé async et a un type de retour Task<string>. Le async mot clé indique que la méthode contient des opérations asynchrones et que le type de retour indique Task<string> que la méthode retourne une tâche qui représente l’opération asynchrone. Le Task<string> type est une tâche générique qui représente une opération asynchrone qui retourne une valeur de chaîne. La ReadFileAsync méthode prend un chemin d’accès de fichier en tant que paramètre et lit le contenu du fichier de façon asynchrone.

La méthode Main est également définie comme asynchrone, ce qui lui permet d'appeler la méthode ReadFileAsync à l'aide du mot clé await. Le await mot clé est utilisé pour indiquer que le programme doit attendre le résultat de l’opération asynchrone avant de continuer. Dans ce cas, le programme attend que le fichier soit lu avant d’imprimer son contenu dans la console.

Résumé

Dans cette unité, vous avez découvert les avantages de la programmation asynchrone et comment elle peut améliorer la réactivité de vos applications. Vous avez également appris à créer et appeler des méthodes asynchrones à l’aide des mots clés async et await en C#. En utilisant ces techniques, vous pouvez écrire des applications plus efficaces et réactives qui peuvent gérer des opérations potentiellement bloquantes sans figer l’interface utilisateur ou bloquer d’autres tâches.

Points clés

  • La programmation asynchrone améliore les performances et la réactivité des applications.
  • C# offre une approche simplifiée de la programmation asynchrone.
  • La programmation asynchrone est bénéfique dans les activités potentiellement bloquantes telles que l’accès web.
  • En C#, les méthodes asynchrones sont créées à l’aide du async mot clé et appelées à l’aide du await mot clé.
  • Les types Task ou Task<T> représentent des opérations en cours qui peuvent être attendues en C#.