Si vous souhaitez effectuer des requêtes Web en C # ou simplement effectuer un traitement en arrière-plan, vous devrez utiliser des tâches d'arrière-plan asynchrones pour ne pas bloquer le thread principal. Nous allons discuter de ce qu'ils sont et comment les utiliser.

Qu'est-ce que Async / Await?

Pour utiliser les tâches, vous devez d'abord comprendre le concept de asynchrone/attendre. Les tâches C # ne doivent pas être exécutées de manière asynchrone, mais étant donné que leur seul objectif est de représenter une opération asynchrone, elles s'exécuteront presque toujours de manière asynchrone. Vous ne souhaitez pas exécuter des opérations telles que la récupération de requêtes Web et l'écriture sur des disques durs sur le thread principal, car cela retarderait le reste de l'application (y compris l'interface utilisateur) en attendant le résultat.

asynchrone/attendre est une syntaxe spéciale utilisée pour traiter les opérations asynchrones. Si une fonction est marquée asynchrone, il renverra généralement une tâche, sauf en cas de gestionnaires d'événements qui retournent void.

Dans la fonction asynchrone, vous pouvez utiliser le attendre mot-clé pour attendre la fin des opérations asynchrones sans bloquer tout le thread. Tout ce qui vient après le attendre Le mot clé ne s'exécutera qu'après le attendu l'opération se termine.

Tâche publique async FetchWebResponse (chaîne url)
{
   var réponse = attendre SendRequest (url)
}

La valeur attendue doit être une tâche, car les deux vont de pair. Lorsque vous appelez le Envoyer une demande() fonction, elle renvoie une Tâcheet le programme attend la fin de cette tâche. Vous pouvez penser à attendre comme mot clé utilisé pour renvoyer ou attendre la fin de la valeur d'une tâche.

Que sont les tâches?

Tâches sont des wrappers utilisés pour traiter les fonctions asynchrones. Ils représentent essentiellement une valeur qui volonté être retourné dans le futur. Vous pouvez utiliser le attendre mot-clé pour attendre le résultat, ou y accéder directement en vérifiant si Tâche.IsCompleted puis lire la valeur de Tâche Résultat.

Vous pouvez les créer en écrivant un asynchrone fonction avec un type de retour de Tâche. Ensuite, tout ce que vous avez à faire est de renvoyer une valeur de type T, et .NET interprétera cela comme renvoyant une tâche. Vous pouvez utiliser attendre à l'intérieur de cette tâche pour attendre les opérations asynchrones, qui à leur tour retournent une tâche elles-mêmes.

<img class = "imgchk9 alignnone wp-image-6268 size-full" data-pagespeed-lazy-src = "https://www.cloudsavvyit.com/thumbcache/0/0/f91922419de7a62b51268c9907e9ecd6/p/uploads/2020/08 /cdfe5ca9.png "alt =" Créer une tâche en écrivant une fonction asynchrone avec un type de retour Task. "width =" 663 "height =" 220 "src =" / pagespeed_static / 1.JiBnMqyl6S.gif "onload =" pagespeed.lazyLoadImages.loadIfVisibleAndMaybeBeacon (this); "onerror =" this.onerror = null; pagespeed.lazyLoadbeImages.loadIfVisibleAndMaybeBeacon (this); "onerror =" this.onerror = null; pagespeed.lazyLoadbeBeacon (this); "/>

Vous pouvez commencer à exécuter une tâche en utilisant Task.Run (action d'action). Cela mettra la tâche en file d'attente sur le pool de threads, qui s'exécutera en arrière-plan sur un autre thread. Le pool de threads prend une file d'attente de tâches et les affecte aux threads du processeur pour traitement. Une fois de retour, ils sont placés dans la liste des tâches terminées où leurs valeurs sont accessibles.

Cependant, même s'il s'agit d'un fil de discussion en arrière-plan, il est toujours très important d'utiliser asynchroniser / attendre. Si vous effectuez un appel de blocage à une API sur un fil d'arrière-plan et que vous ne attendre il, .NET gardera ce thread bloqué jusqu'à ce qu'il se termine, remplissant le pool de threads avec des threads inutiles ne faisant rien d'autre que nuire aux performances.

Si vous devez attendre une tâche du thread de l'interface utilisateur, démarrez-la avec Tâche.Exécuter, puis vérifiez régulièrement si la tâche est terminée. Si c'est le cas, vous pouvez gérer la valeur.

Vous pouvez également exécuter et attendre des tâches dans d'autres tâches. Par exemple, disons que vous avez une fonction dans une tâche, DoExpensiveCalculation (), cela prend un certain temps à exécuter. Plutôt que de le traiter de manière synchrone, vous pouvez l'écrire en tant que tâche et mettre en file d'attente un thread d'arrière-plan au début de la tâche principale. Ensuite, lorsque vous avez besoin de la valeur de ce calcul, vous pouvez simplement attendre la tâche, et il cédera jusqu'à ce que la tâche soit terminée et que la valeur de retour soit renvoyée.