Lorsque nous appelons la méthode Async, tant que nous n'attendons pas le résultat, nous pouvons faire autre chose avant d'attendre le résultat. Quelque chose comme: Je me demande si je saute pour attendre le résultat, cela causera un effet secondaire? P> var resultTask = GetResultAsync();
if(GetSomeOtherBooleanValueMethod()){
var result = await resultTask;
}else{
//Some other logic here.
//await resultTask will never happen in this block.
return;
}
4 Réponses :
Le seul effet secondaire est qu'il n'attendra pas l'appel de getresultsasysync () code> à tout moment. Même si vous souhaitez utiliser résultat code> dans l'instruction IF et, après, vous pouvez attendre la même tâche plusieurs fois. var resultTask = GetResultAsync();
ResultType result;
if(GetSomeOtherBooleanValueMethod()){
result = await resultTask;
}else{
//Some other logic here.
//await resultTask will never happen in this block.
}
result = await resultTask;
Je veux dire, je n'appelle jamais d'attendre si getotherboolvalueMethod () retourne faux.
"Cela n'attendra pas" Eh bien, cela n'attendra pas même si vous avez fait attendre , car attendre n'attends pas. Il effectue une action après que l'opération asynchrone ait fini, ce qui est notamment différent.
Je pense qu'une conclusion peut être faite comme suit: Il n'y a pas d'effet secondaire évident ici car le code peut construire, aucune erreur ne se produira. Nous pouvons certainement appeler la méthode Async mais n'attend jamais d'obtenir le résultat. Cependant, il s'agit d'une gaspillage de ressources, le seul avantage est qu'il pourrait épargner du temps de traitement pour la création de la demande. Mais cela devrait être évité car ce n'est pas une meilleure pratique.
Si vous êtes d'accord, s'il vous plaît, veuillez voter cette réponse, je déciderai de marquer cela comme la réponse basée sur le nombre de vote UP.
Pourquoi ne penseriez-vous pas d'effectuer une action lorsqu'une tâche donnée complète les "ressources des déchets"? Cela pourrait certainement être vrai dans certaines situations, où l'opération en question n'a aucun effet secondaire, seuls les résultats pour être utiles à une personne, mais si une opération entraîne des effets secondaires, il peut avoir un but même si rien ne vale quand Il finit .
@Servy, imo, si vous exécutez une méthode Async sans attendre le résultat exprès, vous devriez rechercher une autre technique. La méthode Async n'est pas construite pour "feu et oublie". Le hangfire est plus apte à ce type de but.
Feu et oublier ASYNC est utilisé dans les gestionnaires d'événements Winforms (et je crois que WPF), alors oui, il est construit pour le feu-et-oublie, mais (comme tout outil), il doit être utilisé le cas échéant.
@Kennethk. à votre avis. Si vous ne tenez pas compte de l'effet secondaire, pensez-vous que la pratique est appropriée pour exécuter une méthode asynchratante mais n'attend jamais en résultat?
@Stevenzack Async Méthodes est Absolument Construit pour soutenir les opérations d'incendie et d'oublier. Certains pièges que vous pouvez rencontrer, vous devez donc être conscient de la manière dont vous les manipulez (principalement en ce qui concerne la manipulation des erreurs), mais ce n'est pas seulement possible dans le système que cela se produira. Personnellement, vous n'avez personnellement pas envie que la pratique ne signifie pas que cela n'a pas été conçu dans la fonctionnalité, ni que cela "gaspille des ressources", ce qui ne le fait pas.
Ceci dépend totalement de ce que alors il n'y a pas de problème.
Le troisième point vaut la peine de commenter, car si c'est le cas, cela pourrait causer une condition de course. De manière générale, une "ressource partagée" pourrait être quelque chose d'un geste de fichier à une limite de taux d'API.
Le point plus large est que, si vous faites quelque chose comme ça, vous devez réfléchir à tout scénario qui pourrait éventuellement causer une condition de course. getResultasync (); fait. Je suppose que sur la base de son nom que tout ce qu'il fait est de récupérer une valeur d'un service Web ou d'une base de données ou quelque chose. Cela étant dit, en supposant que
getResultasync () n'a pas d'effets secondaires
sinon
getResultasync () La méthode ne saisit pas une sorte de ressource partagée ou rare ou quelque chose
getResultasync () pourrait causer une condition de course si quelque chose d'autre dépend de ce fait avant son exécution. Par exemple, si vous terminiez le processus précoce (par exemple via une application de console qui quitte ou quelque chose) pourrait causer getResultasync () pour laisser quelque chose d'un état corrompu, ce serait un problème.
qui causera un effet secondaire?
L'effet Il provoque que votre application ne peut jamais savoir quand
getResultasync est terminé.en particulier:
- Votre code ne saura pas si
getResultasync échoue.- Votre code peut se considérer "fait" lorsque
getResultasync est toujours en cours d'exécution. Si votre application quitte,getResultasync sera abandonné. Encore une fois, sans aucune notification.Le deuxième point est particulièrement problématique sur les cadres de serveur tels que ASP.NET, qui peut décharger votre processus s'il est "fait", ainsi terminant
getResultasync s'il est en cours d'exécution.
Testez-le, avez-vous vu des effets secondaires?
Comment tester les effets secondaires? Il court.
Qu'entendez-vous par "Effets secondaires?" Je ne dirais pas cela en règle générale, mais je doute qu'il soit bénéfique de commencer une tâche avant de déterminer si vous aurez besoin de son résultat. Ne pensez pas à l'avantage de
async comme faisant de cette méthode plus rapidement. Pensez-y comme si vous avez besoin d'obtenir un certain résultat et que cela va prendre un certain temps, le fil ne sera pas attaché à attendre. Mais dans l'ensemble, l'application bénéficiera de tâches de ne pas avoir besoin.Omettre le
attendre incendiera la méthode sur un autre fil en arrière-plan. Si vous devez attendre une réponse, utilisezattendre . Sinon, vous n'avez pas "besoin" d'utiliser l'appel attendu. Vous pouvez affecter votre méthode appel à un "délégué" comme si vous faites et effectuez d'autres tâches pendant que l'autre thread exécute avant d'utiliser attendre.@Ksigwyatt um, non, cela ne créera pas de nouveau fil?
task.run files d'attente sur le bassin de fil;attendre dit simplement ", reprend ici lorsque la tâche est terminée."@Scotthannen, a du sens. J'ai littéralement essayé de presser toutes les puissances de calcul du code, mais de commencer une tâche inutile est un gaspillage de ressources.
@Kennethk. Je le fais tout le temps. Appeler une méthode async ASYNC sans attendre une réponse exécutera toujours la méthode. Vous instructrez simplement le fil principal de continuer et de ne pas tenir l'exécution pour l'achèvement du fil de l'enfant.
@Ksigwyatt qui ne signifie pas que cela commence un nouveau fil.
@Ksigwyatt, vous ne pensez pas que ce soit un gaspillage de votre ressource?
@Ksigwyatt il ne démarre pas d'un nouveau fil. Cela signifie simplement que le fil qui a initié le processus ASYNC reprend avec la prochaine déclaration sans attendre la tâche à compléter. C'est la même chose qui se produirait si vous avez fait Démarrer un nouveau fil, il semble donc semblable similaire.
Votre question est fondamentalement la même chose que de demander: "Si un arbre tombe dans une forêt et personne n'est là pour l'entendre, fait-il un son?" Si quelqu'un arrive à observer lorsqu'une tâche se termine ne change pas ce que cette tâche fait. Cela ne change que ce que l'observation de celui-ci choisit de faire en réponse à ce qu'ils observent.
@Kennethk. Cet exemple suivant l'étape 4 voici l'effet sur lequel je me réfère. Lors de l'exécution de cela, il peut ne pas être techniquement démarrer un nouveau fil. Je ne suis pas certian de la mise en œuvre de cet espace de noms. Mais cela crée un nouvel objet
System.Thread.Task pour fonctionner de manière asynchrone. Donc, cela peut simplement sembler être la même chose. Semblable à ce que Scott a fait allusion. docs.microsoft.com/en-us/dotnet/cshaarp/programming-Guide/...@Ksigwyatt et dans cet exemple, cela ne fait pas le travail dans un autre fil. Cela fait le travail de manière asynchrone sans utiliser de threads supplémentaires . De plus, une opération donnée ou non ou n'utilise pas de threads supplémentaires pour atteindre son asynchrone n'a rien à voir avec ou non, il est attendu. Soit la mise en œuvre de cette méthode asynchrone utilise des threads supplémentaires, que ce soit attendu ou non, car c'est comme ça que c'était écrit, ou ce n'est pas le cas, et non si cela est attendu ou non.
C'est un excellent article: Il n'y a pas de fil . Une bizarrerie d'Async / attendre est qu'il est possible de l'utiliser dans de nombreux scénarios de «sentiers heureux» et de ne jamais avoir aucune idée de ce que cela fait. J'ai réalisé à un moment donné que si vous m'avez demandé de décrire le comportement réel dans une phrase que je ne pouvais pas ou cela ne serait pas complètement faux. Un point clé est que lors d'une opération ASYNC, comme lorsqu'une requête est exécutée, il n'y a pas de fil à ce processus, car s'il y avait là, il n'y aurait rien à faire mais attendre.