Await Task.Run vs Await : quand dois-je utiliser chaque approche dans la programmation asynchrone ?

Programmation asynchrone C# : différences et applications de await Task.Run et await

En programmation asynchrone C#, l'utilisation de await Task.Run et await prête souvent à confusion, surtout lorsque la différence entre les deux n'est pas évidente. Comprendre leurs différences est essentiel pour optimiser l’exécution du code et éviter les problèmes potentiels.

Bases de la programmation asynchrone

Avant de plonger dans des scénarios spécifiques, passons brièvement en revue les bases de la programmation asynchrone. Les méthodes asynchrones en C# permettent une exécution non bloquante, permettant d'effectuer des tâches en parallèle sans bloquer le thread de l'interface utilisateur.

Lorsqu'une méthode asynchrone est appelée, elle forme une machine à états pour contrôler son exécution. Lorsque le mot-clé await est rencontré dans une méthode, il confie le contrôle à l'appelant pendant que l'opération asynchrone se poursuit en arrière-plan. Une fois l'opération terminée, la machine d'état reprend l'exécution à partir de await.

await Task.Run contre await

Dans certains scénarios, await Task.Run(() => LongProcess()) et await LongProcess() peuvent ressembler à des expressions équivalentes, mais il existe des différences subtiles en dessous.

await Task.Run(() => LongProcess()) démarrera un thread en arrière-plan pour exécuter la méthode LongProcess, libérant ainsi le thread actuel pour effectuer d'autres tâches. Une fois la tâche en arrière-plan terminée, le thread revient à l'appelant et poursuit son exécution.

D'autre part, await LongProcess() signifie que la méthode LongProcess elle-même est une méthode asynchrone. Dans ce cas, le thread actuel ne donne pas le contrôle au thread d’arrière-plan. Au lieu de cela, une machine à états asynchrone est formée pour LongProcess, et le mot-clé await permet à la machine à états de continuer l'exécution une fois l'opération asynchrone dans LongProcess terminée.

Impact du comportement des threads

La différence entre

await Task.Run et await affecte le comportement du fil :

• await Task.Run : Créez un thread d'arrière-plan pour effectuer des opérations asynchrones. Pendant que la tâche en arrière-plan est en cours d'exécution, d'autres threads peuvent continuer à s'exécuter.
• await : Le thread actuel sera mis en pause et d'autres threads pourront s'exécuter pendant que l'opération asynchrone dans la méthode asynchrone est en cours.

Quand utiliser quelle méthode

Dans la plupart des cas, il est recommandé d'utiliser LongProcess au lieu de await LongProcess() si await Task.Run(() => LongProcess()) est déjà une méthode asynchrone. Cela permet au thread actuel de rester réactif pendant que l'opération asynchrone dans LongProcess est en cours d'exécution.

Cependant, si LongProcess n'est pas une méthode asynchrone, ou si elle effectue des calculs très lourds qui bloqueraient le thread de l'interface utilisateur, il est recommandé d'utiliser await Task.Run(() => LongProcess()) pour déléguer l'exécution à un thread d'arrière-plan.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!