C# en attente

Le mot-clé wait dans le langage de programmation C# est utilisé pour suspendre toutes les méthodes asynchrones incluses jusqu'au point où les opérations présentées par la méthode asynchrone sont terminées. Pour qu'un développeur puisse appeler plusieurs fonctions de manière asynchrone, async et wait sont fortement utilisés et recommandés. Il est possible d'hériter de presque toutes les fonctionnalités de la programmation asynchrone avec une simple implémentation de la fonction wait avec async. Passons maintenant à la compréhension de la syntaxe standard pour implémenter le mot-clé wait.

Syntaxe :

La syntaxe standard du mot-clé wait est simple, elle comprend le mot-clé suivi de la fonction ou de la méthode. La syntaxe est la suivante :

await anyFunction();

Ici, nous avons la syntaxe commençant par le mot-clé wait, suivi d'une fonction, qui peut être n'importe quelle fonction du programme. La liberté est d'appeler et de transmettre le mot-clé wait à n'importe quelle classe de méthode ou fonction dans la syntaxe.

Comment fonctionne le mot-clé wait en C# ?

Ensuite, nous comprendrons comment les mots-clés wait fonctionnent réellement en C#, et fondamentalement, le mot-clé wait arrête les opérations de la méthode async jusqu'à ce que les opérandes terminent les opérations. Ensuite, une fois l'opération asynchrone terminée, le mot clé wait renvoie au résultat de l'opération s'il y en a. Ce même mot-clé wait ne bloque aucune menace de la méthode async et après avoir suspendu la méthode async englobante, le contrôle du programme est rendu à l'appelant du programme. Voici donc comment fonctionne le mot-clé wait et comment programmer les flux tout en devant implémenter le mot-clé wait. Ensuite, nous allons maintenant implémenter le mot-clé wait et voir comment il fonctionne dans des exemples réels.

Des exemples de C# attendent

Maintenant que nous avons compris ce qu'est le mot-clé wait et comment il fonctionne, passons à la démonstration du mot-clé wait avec des exemples. Ici pour notre premier exemple, nous utiliserons simplement une seule méthode, avec une instruction print et un mot-clé wait.

Exemple n°1

Code :

using System;
using System.Threading.Tasks;
class Program {
static void Main(string[] args) {
first_meth();
Console.ReadKey();
}
public static async Task first_meth() {
await Task.Run(() =>  {
for (int a = 0 ; a < 2; a++ )  {
Console.WriteLine(" Simple demonstration of await keyword.");
}
});
}
}

Sortie :

Explication du code : Il s'agit d'une démonstration très simple du mot-clé wait, où nous avons une seule méthode et la méthode main. La méthode main appelle la première méthode et est vouée à être exécutée. La méthode a une implémentation du mot-clé wait. Le résultat sera une déclaration d'impression imprimée deux fois.

Exemple n°2

Comme prévu, le résultat est la déclaration imprimée deux fois. Pour notre prochain exemple, nous aurons deux méthodes différentes qui ne sont en aucun cas dépendantes et nous les appellerons via la méthode main. Le code du programme est le suivant :

Code :

using System;
using System.Threading.Tasks;
class Program {
static void Main(string[] args) {
exam1();
exam2();
Console.ReadKey();
}
public static async Task exam1()  {
await Task.Run(() =>  {
for (int a = 0 ; a < 5 ; a++ )  {
Console.WriteLine(" This will be printed 5 times.");
}
});
}
public static void exam2() {
for (int a = 0 ; a < 2 ; a++ ) {
Console.WriteLine(" This statement will be printed 2 times. ");
}
}
}

Sortie :

Explication du code : Pour notre premier exemple, nous avons deux méthodes différentes qui sont totalement indépendantes et nous avons appelée ces méthodes à partir de la méthode principale du programme. En commençant par les fichiers système requis, nous avons notre programme de classe avec la méthode main, la méthode main dans laquelle nous appelons les deux méthodes à déclarer. Notre première méthode exam1 est lancée, avec le mot-clé wait suivi d'une fonction lambda et d'une instruction pour imprimer une instruction de sortie. Ensuite, nous avons notre deuxième méthode exam2, qui a une instruction for, qui imprimera l'instruction de sortie plusieurs fois.

Exemple #3

Comme prévu, les instructions de sortie sont telles que mentionnées dans le code. Ensuite, nous implémenterons le mot-clé wait avec un autre exemple où nous aurons trois méthodes et quelques instructions d'impression.

Code :

using System;
using System.Threading.Tasks;
class Program {
static void Main(string[] args) {
Console.WriteLine("\n");
callMethod();
Console.ReadKey();
}
public static async void callMethod() {
Task<int> task = exam1();
exam2();
int total = await task;
exam3(total);
}
public static async Task<int> exam1() {
int total = 0;
await Task.Run(() =>
{
for (int a = 0 ; a < 10 ; a++ )  {
Console.WriteLine(" This is a simple statement. ");
total += 1;
}
});
return total;
}
public static void exam2()  {
for (int a = 0 ; a < 2 ; a++ )  {
Console.WriteLine(" This is a second output statement.");
}
}
public static void exam3(int total) {
Console.WriteLine(" Total number of statements from first method are   " + total);
}
}

Sortie :

Explication du code : pour notre troisième exemple, nous avons trois méthodes différentes et nous appelons ces méthodes à partir de la méthode principale. Avec notre méthode principale, nous appelons la méthode callMethod, qui a pour tâche d'appeler la méthode exam1 et donc l'examen1 est exécuté. Selon le programme, ici la méthode exam1 ne sera pas exécutée en premier car elle a le mot-clé wait, elle passera donc à la méthode suivante qui est exam1 et la méthode exam2 sera exécutée, qui est une instruction imprimée deux fois comme mentionné dans le pour une boucle. Ensuite, notre méthode exam1 sera imprimée suivie de la méthode exam3, la méthode exam3 est une instruction unique. Au total, une déclaration de 13 sorties sera imprimée. La dernière déclaration imprimera le nombre de fois que nous imprimons la déclaration à partir de la méthode exam1. Comme expliqué, le nombre total de 13 instructions d'impression, exécution simple du mot-clé wait avec plusieurs méthodes.

Conclusion

Pour conclure, le mot clé wait est utilisé pour suspendre les événements et redonner le contrôle du programme à l'appelant. Cette fonctionnalité est largement utilisée lorsque nous disposons de plusieurs méthodes et fonctions. Le mot-clé wait est utilisé pour renvoyer le contrôle à l'appelant et il ne peut être appliqué que dans la méthode async.

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!