Est-Tâche.Résultat le même que .GetAwaiter.GetResult()?

J'ai récemment été la lecture d'un code qui utilise beaucoup de méthodes asynchrones, mais alors parfois besoin de les exécuter de manière synchrone. Le code n':

Foo foo = GetFooAsync(...).GetAwaiter().GetResult();

Est-ce le même que

Foo foo = GetFooAsync(...).Result;

À partir de la documentation de GetResult: "Ce type et ses membres sont destinés à une utilisation par le compilateur." Autre personne ne devrait pas l'utiliser.
Ceci est appelé "la synchronisation via async", et, sauf si vous savez comment la tâche est mise en œuvre peut être un vraiment mauvaise idée. Il peut instantanément blocage dans de nombreux cas (un async/await méthode MVC, par exemple)
Ne pas Bloquer sur Async Code
Dans le monde réel, nous avons les constructeurs, nous avons "sans attendre" interfaces nous avons besoin pour mettre en œuvre, et il nous est donné de méthodes asynchrones partout. Je serais heureux d'utiliser quelque chose qui fonctionne sans que je me demande pourquoi il est "dangereux", "ne pas utiliser" ou "éviter à tout prix". À chaque fois je dois me débattre avec async à son tour d'un mal de tête.

InformationsquelleAutor Jay Bazuzi | 2013-06-24

async-await c#

152

Assez bien. Une petite différence: si le Task échoue, GetResult() va juste jeter l'exception causé directement, tandis que Task.Result va jeter un AggregateException. Cependant, ce qui est le point de l'utilisation de l'une de celles où il est async? L'100x meilleure option est d'utiliser await.

Aussi, vous n'êtes pas censé utiliser GetResult(). Il est destiné à être pour le compilateur d'utiliser uniquement, pas pour vous. Mais si vous ne voulez pas l'ennuyeux AggregateException, l'utiliser.
- "L'100x meilleure option est d'utiliser l'attendent". Un exemple de ce qui est fait est dans l'unité des méthodes d'essai. Tu dois synchroniser quelque temps, non?
- Pas si votre framework de test unitaire prend en charge async les tests unitaires, qui, je pense, les versions les plus récentes de la plupart des cadres n'.
- Au niveau supérieur, vous devriez idéalement être la création d'une nouvelle synchronisation contexte (c'est à dire une boucle de message) pour effectuer le test. Comme il a été mentionné, certains cadres maintenant le faire pour vous. S'ils ne le font pas, il est probablement temps pour vous de réellement faire de votre propre, étant donné que vous êtes le plus susceptible de tests de code qui suppose qu'il aura un contexte de synchronisation et d'exister au sein d'une boucle de message. Si le code de la structure elle-même n'est pas écrit pour être async cela signifie simplement que vous avez besoin d'une boucle de message par test (ce qui est bien, et probablement une bonne chose) plutôt que pour l'ensemble de la suite.
- MSTest, xUnit, et NUnit tout le soutien async Task les tests unitaires, et depuis un certain temps maintenant.
- repoussant sur le 100x - c'est 1000x pire d'utilisation s'offrent à vous si vous êtes l'adaptation de l'ancien code et à l'aide de l'attendent nécessite une réécriture.
- de toute façon, parfois, vous devez appeler méthode async constructeur du formulaire. Dans ce cas, vous devez bloquer sur Result.
- href="http://blog.stephencleary.com/2013/01/async-oop-2-constructors.html" >je suis en désaccord.
- eh bien, parfois, il s'adapte. Mais par exemple, quand je lance certains d'initialisation dans le constructeur de service WCF (ou n'importe quel autre framework), alors je ne peux pas dire cadre de " hey, mon cool méthode statique à la place du constructeur).
- The 100x better option is to use await. Je déteste ce type de déclarations, si je pouvais claque await en face d'elle, je le ferais. Mais, quand j'essaie de faire async code du travail à l'égard des non-async code comme ce qui arrive souvent à moi beaucoup dans Xamarin, je finis par avoir à utiliser des choses comme ContinueWith un lot afin de faire il pas de blocage de l'INTERFACE utilisateur. Edit: je sais que c'est vieux, mais ce n'est pas de soulager ma frustration de trouver les réponses que l'état de sans solutions de rechange pour les situations où vous ne pouvez pas utiliser await.
- .GetAwaiter.Result est recommandé d'utiliser à la place de .Result. Votre réponse est trompeur... consultez les Microsoft Blog
- mon obsession du détail juste des coups de pied dans, en fait, le blog dit .GetAwaiter().GetResult()
- Comment venir", il est juste destiné à être utilisé par le compilateur"? Où avez-vous cette information?
- Un endroit où je voir l'utilisation de la machine synchrone d'attente, c'est lors d'un refactoring legacy / mauvais code. Quand la dépendance est déjà de retour d'un Task, mais l'appel n'est pas encore prêt ou l'utilise par exemple dans son constructeur.
InformationsquelleAutor It'sNotALie.
112

Task.GetAwaiter().GetResult() est préféré au Task.Wait et Task.Result parce qu'elle se propage exceptions plutôt que de les envelopper dans un AggregateException. Cependant, les trois méthodes de provoquer des risques de blocage et le pool de thread la famine questions. Ils devraient tous être évités en faveur de async/await.

La citation ci-dessous explique pourquoi Task.Wait et Task.Result ne pas se contenter de contenir la propagation d'exception comportement de Task.GetAwaiter().GetResult() (en raison d'un "très haut niveau de compatibilité de la barre").

Comme je l'ai mentionné précédemment, nous avons un très haut niveau de compatibilité de la barre, et ainsi, nous avons évité la rupture des changements. En tant que tel, Task.Wait conserve le comportement de toujours de l'emballage. Cependant, vous pouvez vous trouver dans des situations où vous souhaitez un comportement similaire de la machine synchrone bloquant employé par Task.Wait, mais où vous voulez l'exception d'origine propagées déballé plutôt que d'être enfermé dans un AggregateException. Pour y parvenir, vous pouvez cibler la Tâche awaiter directement. Lorsque vous écrivez “await task;”, le compilateur traduit que dans l'utilisation de la Task.GetAwaiter() méthode, qui renvoie une instance qui a un GetResult() méthode. Lorsqu'il est utilisé sur un reproché à la Tâche, GetResult() va propager l'exception d'origine (c'est de cette façon “await task;” obtient son comportement). Ainsi, vous pouvez utiliser “task.GetAwaiter().GetResult()” si vous voulez invoquer directement cette propagation de la logique.

https://blogs.msdn.microsoft.com/pfxteam/2011/09/28/task-exception-handling-in-net-4-5/

“GetResult” signifie en fait “vérifier la tâche pour les erreurs”

En général, j'essaie de mon mieux pour éviter le blocage synchrone sur une tâche asynchrone. Cependant, il ya une poignée de situations où je ne violent que le projet de directive. Dans ces conditions rares, ma méthode préférée est GetAwaiter().GetResult(), car elle préserve la tâche des exceptions au lieu de les envelopper dans un AggregateException.

http://blog.stephencleary.com/2014/12/a-tour-of-task-part-6-results.html
- Donc, fondamentalement, Task.GetAwaiter().GetResult() est équivalent à await task. Je suppose que la première option est utilisée lorsque la méthode ne peut pas être marqué avec async(constructeur par exemple). Est-ce exact? Si oui, alors il entre en collision avec la top réponse @Il'sNotALie
- est plus équivalent à Task.Wait et Task.Result (dans tous les trois vont bloquer de façon synchrone et ont le potentiel des blocages), mais Task.GetAwaiter().GetResult() a l'exception de propagation de comportement de l'attendent tâche.
- Ne pouvez-vous pas éviter les blocages dans ce scénario (Tâche).ConfigureAwait(false).GetAwaiter().GetResult(); ?
- Voir la citation suivante: "à l'Aide de ConfigureAwait(faux) pour éviter les blocages est une pratique dangereuse. Vous devez utiliser ConfigureAwait(false) pour tous les attendent dans la fermeture transitive de toutes les méthodes appelées par le code de blocage, y compris tous les troisième et de seconde partie de code. À l'aide de ConfigureAwait(faux) pour éviter un blocage est, au mieux, juste un hack). ... la meilleure solution est de “Ne pas bloquer sur async code”." - blog.stephencleary.com/2012/07/dont-block-on-async-code.html
- Ah, je vois le dilemme. Si le haut de la code est synchrone à travers toutes les couches et puis vous finissez par avoir à appeler une méthode asynchrone, la meilleure réponse est que vous devriez faire asynchrone. Toutefois, si vous avez des dizaines de méthodes qui arrive d'appeler cela une méthode qui doit ensuite appeler une méthode asynchrone, il n'est pas si facile de changer. Si vous pouvez garantir ConfigureAwait(faux) il y a, vous pouvez techniquement le faire, mais il est dangereux et mal vu.
- Je n'ai pas l'obtenir. De la tâche.D'attente et de la Tâche.Résultat sont brisées par le design? Pourquoi ne sont-ils pas devenus obsolètes?
InformationsquelleAutor Nitin Agarwal
66

https://github.com/aspnet/Security/issues/59

"Une dernière remarque: vous devez éviter d'utiliser Task.Result et Task.Wait comme
autant que possible, comme ils l'ont toujours encapsuler l'intérieur d'exception dans un
AggregateException et remplacer le message par un générique (Un ou
plusieurs erreurs se sont produites), ce qui rend le débogage plus difficile. Même si l'
version synchrone ne doit pas être utilisé souvent, il est fortement
pensez à utiliser Task.GetAwaiter().GetResult() à la place."
- La source de référence est quelqu'un en citant quelqu'un d'autre, sans une référence. Tenir compte du contexte: je vois beaucoup de gens aveuglément à l'aide de GetAwaiter().GetResult() partout après la lecture de ce.
- Il ne faut donc pas l'utiliser?
- Si deux tâches fin avec une exception, vous perdrez de la deuxième, dans ce scénario Task.WhenAll(task1, task2).GetAwaiter().GetResult();.
- Voici un autre exemple: github.com/aspnet/AspNetCore/issues/13611
InformationsquelleAutor scyuo
29

Une autre différence, c'est quand async fonction renvoie juste Task au lieu de Task<T> alors vous ne pouvez pas utiliser
```
GetFooAsync(...).Result;
```
Alors que
```
GetFooAsync(...).GetAwaiter().GetResult();
```
fonctionne toujours.

Je sais que l'exemple de code dans la question, pour le cas Task<T>, cependant, la question est posée d'une manière générale.
- Ce n'est pas vrai. Découvrez mon violon qui utilise exactement cette construction: dotnetfiddle.net/B4ewH8
- Dans votre code, vous utilisez Result avec GetIntAsync() qui renvoie Task<int> pas seulement Task. Je vous suggère de lire ma réponse encore une fois.
- Vous avez raison, j'ai d'abord entendu de vous répondre que vous ne pouvez pas GetFooAsync(...).Result à l'intérieur une fonction qui renvoie Task. Cela fait maintenant de sens, car il n'y a aucun vide Propriétés en C# (Task.Result est une propriété), mais vous pouvez bien appeler une méthode void.
InformationsquelleAutor Nuri Tasdemir
12

Comme déjà mentionné, si vous pouvez utiliser await. Si vous avez besoin pour exécuter le code synchrone comme vous le mentionnez .GetAwaiter().GetResult(), .Result ou .Wait() est un risque pour les blocages comme beaucoup l'ont dit dans les commentaires/réponses. Puisque la plupart d'entre nous aiment les oneliners vous pouvez les utiliser pour .Net 4.5<

L'acquisition d'une valeur par l'intermédiaire d'une méthode asynchrone:
```
var result = Task.Run(() => asyncGetValue()).Result;
```
Syncronously de l'appel d'une méthode async
```
Task.Run(() => asyncMethod()).Wait();
```
Pas de l'impasse problèmes ne se produisent en raison de l'utilisation de Task.Run.

Source:

https://stackoverflow.com/a/32429753/3850405

InformationsquelleAutor Ogglas
0

Si une tâche de défauts, à l'exception sera levée lors de la poursuite
les appels de code awaiter.GetResult(). Plutôt que d'appeler GetResult, nous
peut simplement accéder à la propriété du Résultat de la tâche. L'avantage
à l'appel de GetResult est que si la tâche de défauts, à l'exception des
jeté directement sans être enveloppé dans AggregateException, permettant
pour plus simple et plus propre blocs catch.

Pour nongeneric tâches, GetResult() a une valeur de retour void. Sa durée de
la fonction est alors seul à relever des exceptions.

source : c# 7.0 en un Mot

InformationsquelleAutor Ali Abdollahi

Vous devez vous connecter pour publier un commentaire.