Comprendre C # Async et attendre les pièges

Les problèmes communs avec asynchronisation et attendre en C # incluent: 1. Utilisation incorrecte de .Result ou .Wait () provoque une impasse; 2. Ignorer ConfigureAwait (False) provoque des dépendances contextuelles; 3. L'abus d'Async Vide provoque un contrôle manquant; 4. L'attente en série affecte les performances de la concurrence. L'approche correcte est: 1. La méthode asynchrone doit être asynchrone tout le chemin pour éviter le blocage de la synchronisation; 2. L'utilisation de ConfigureAwait (false) dans la bibliothèque de classe est utilisée pour s'écarter du contexte; 3. Utiliser uniquement le vide asynchrone dans le traitement des événements; 4. Les tâches simultanées doivent d'abord être démarrées, puis attendre pour améliorer l'efficacité. Comprendre le mécanisme et normaliser l'utilisation du code asynchrone qui évite d'écrire un blocage substantiel.

L'asynchronisation et l'attente de C # facilitent la programmation asynchrone, mais il est facile de rester coincé si vous ne l'utilisez pas bien. Beaucoup de gens pensent qu'il est facile d'écrire au début, mais le programme est coincé, dans l'impasse ou n'est pas exécuté de manière asynchrone. En fait, le problème n'est pas la grammaire, mais la compréhension inadéquate et la mauvaise posture d'utilisation.

N'utilisez pas de résultat ou attendez () à volonté

Il s'agit de l'écueil le plus courant: afin d'appeler une méthode asynchrone dans une méthode synchrone, certaines personnes utilisent directement .Result ou .Wait() , qui provoquera un blocage des threads ou même une impasse s'ils sont accidentellement.

Par exemple, vous le faites dans le contexte d'un thread d'interface utilisateur ou d'une demande ASP.NET:

 Var Result = SomeaSyncMethod (). Résultat;

Ce code peut provoquer une impasse. Parce await essaiera de revenir dans le contexte d'origine pour continuer l'exécution, mais si ce contexte a été occupé par .Result , il ne peut qu'attendre, en attendant que les deux côtés soient libérés, donc il a gelé.

suggestion:

• Si vous écrivez une méthode asynchrone, essayez d'être asynchrone jusqu'à la fin.
• Évitez de «transformer» de force en appels synchrones à l'extérieur de la méthode asynchrone.
• Si cela ne fonctionne vraiment pas, vous pouvez utiliser ConfigureAwait(false) pour éviter de capturer le contexte (j'en parlerai plus tard).

ConfigurationAwait oublié (false)

Par défaut, await se souvient du contexte actuel de synchronisation et essaie de revenir à ce contexte lors de la reprise de l'exécution. Ceci est utile dans les applications d'interface utilisateur ou les demandes Web, mais peut poser des charges inutiles ou même des risques de blocage dans le code de la bibliothèque de classe.

Si vous écrivez une logique générale qui ne dépend pas d'un contexte spécifique, il est préférable d'ajouter:

 attendre someaSyncMethod (). ConfigureAwait (false);

Cela permet d'exécuter le code ultérieur sur n'importe quel thread, réduisant la pression de la commutation de contexte.

Quand ne puis-je pas l'utiliser?

• Lors de la mise à jour des contrôles sur la couche d'interface utilisateur, le contexte d'origine est effectivement requis et il ne peut pas être ajouté pour le moment.
• Il est recommandé d'ajouter des services internes et de fond dans la bibliothèque de classe.

Utilisation incorrecte de vide asynchrone

En plus de la tâche asynchrone, il existe également une méthode asynchrone Void, mais elle a un objectif spécial - il est principalement utilisé pour gérer les fonctions de gestion des événements, telles que les points de déclenchement tels que les clics de bouton.

Mais si vous écrivez une méthode aléatoire Async Void et l'appelez, vous perdez le contrôle dessus. Une exception ne sera pas prise correctement et l'appelant ne peut pas attendre qu'il se termine.

suggestion:

• Essayez d'éviter de définir vous-même la méthode vide asynchrone.
• Utilisez-le uniquement lorsque les événements doivent être répondus, comme dans l'abonnement à l'événement de la méthode.
• La tâche asynchrone est utilisée dans d'autres endroits.

L'ordre de concurrence et d'attente affecte les performances

Parfois, vous pensez que plusieurs opérations asynchrones sont exécutées en parallèle, mais en fait, elles sont exécutées en série uniquement parce que vous avez écrit du code comme ceci:

 var result1 = attendre getFirstasync ();
var result2 = attendre getSecondasync ();

Ce code commence en fait le second une fois le premier terminé. Si vous souhaitez initier plusieurs demandes en même temps, vous devez d'abord démarrer les tâches, puis les attendre:

 var task1 = getFirstasync ();
var tâche2 = getSecondasync ();

var result1 = attendre la tâche1;
var result2 = attendre la tâche2;

De cette façon, les deux tâches peuvent être exécutées simultanément, ce qui les rend plus efficaces.

Avis:

• Si vous utilisez Task.WhenAll . Lorsque vous êtes en train de vous assurer que toutes les tâches ont été lancées avant d'être transmises.
• Les attentes multiples sont écrits simultanément ≠ simultanément.

Fondamentalement, c'est tout. L'async et l'attente sont faciles à utiliser, mais le mécanisme derrière n'est pas clair, il est donc facile d'écrire du code qui semble asynchrone mais qui est en fait bloqué. Surtout dans les environnements où les pools de threads sont serrés ou restreints par le contexte, ces problèmes sont plus susceptibles d'être exposés.

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!