Est Asynchrone mot clé await équivalent à un ContinueWith lambda?

Quelqu'un pourrait-veuillez avoir l'amabilité de confirmer si j'ai bien compris la Async mot clé await correctement? (À l'aide de la version 3 de la CTP)

Donc à présent je n'ai travaillé que d'insérer le mot clé await avant un appel de méthode essentiellement 2 choses, A. Il crée un retour immédiat et B. Il crée une "suite" qui est appelée à la fin de la méthode async invocation. En tout cas, la suite est le reste du bloc de code pour la méthode.

Alors ce que je demande, ce sont ces deux bouts de code techniquement équivalent, et si oui, est-ce fondamentalement signifie que le mot clé await est identique à la création d'un ContinueWith Lambda (c'est à dire: c'est en fait un compilateur de raccourci pour une)? Si non, quelles sont les différences?

bool Success =
    await new POP3Connector(
        "mail.server.com", txtUsername.Text, txtPassword.Text).Connect();
//At this point the method will return and following code will
//only be invoked when the operation is complete(?)
MessageBox.Show(Success ? "Logged In" : "Wrong password");

(new POP3Connector(
    "mail.server.com", txtUsername.Text, txtPassword.Text ).Connect())
.ContinueWith((success) =>
    MessageBox.Show(success.Result ? "Logged In" : "Wrong password"));

InformationsquelleAutor Maxim Gershkovich | 2012-01-07

async-await async-ctp c#continuations

80

L'idée générale est correcte - le reste de la méthode est en fait une continuation de toutes sortes.

La "fast path" post de blog a des détails sur la façon dont le async/await compilateur travaux de transformation.

Différences, sur le dessus de ma tête:

La await mot-clé permet également l'utilisation d'une "planification d'contexte" concept. La programmation, le contexte est SynchronizationContext.Current si elle existe, pour retomber sur TaskScheduler.Current. La poursuite est alors exécuté sur la planification de contexte. Donc une approximation plus proche serait de passer TaskScheduler.FromCurrentSynchronizationContext en ContinueWith, pour retomber sur TaskScheduler.Current si nécessaire.

Le réel async/await mise en œuvre est basée sur le pattern matching; il utilise un "awaitable" pattern qui permet à d'autres choses en plus de tâches à être attendu. Quelques exemples sont le WinRT des Api asynchrones, des méthodes un peu spéciales comme Yield, Rx observables, et prise spéciale awaitables qui ne touche pas la table comme dur. Les tâches sont puissants, mais ils ne sont pas la seule awaitables.

Un plus mineur pinailleurs différence vient à l'esprit: si le awaitable est déjà terminée, le async méthode ne permet pas réellement de retour à ce point, qu'il continue de façon synchrone. Donc c'est un peu comme passer TaskContinuationOptions.ExecuteSynchronously, mais sans la pile de problèmes liés à l'.
- très bien dit, j'essaye de reporter de Jon postes qu'ils sont donc beaucoup plus vaste que tout ce que j'aurais le temps de le mettre dans une réponse, mais Stephen est absolument droit. WRT ce qui est awaitable (et GetAwaiter en particulier), son post #3 est très utile à mon humble avis 🙂 msmvps.com/blogs/jon_skeet/archive/2011/05/13/...
- Stephen est point ici. Pour des exemples simples, il est facile de penser que async/await est juste un raccourci pour ContinueWith - cependant, j'aime penser que c'est dans le sens inverse. Async/await est en fait un plus puissant expression de ce que vous avez l'habitude d'utiliser ContinueWith pour. Le problème est que ContinueWith(...) utilise des lambdas, et permet l'exécution pour obtenir transféré à la poursuite, mais d'autres le contrôle de flux de concepts tels que les boucles sont assez impossible si vous avez de mettre la moitié du corps de la boucle avant de la ContinueWith(...) et l'autre moitié après. Vous vous retrouvez avec de manuel la continuation de la série.
- Un autre exemple où async/await est beaucoup plus expressive que ContinueWith(...) coule des exceptions. Vous pouvez attendre plusieurs fois dans le même bloc try, et pour chaque étape de l'exécution, leur exceptions peuvent être acheminés à la même catch(...) en bloc sans avoir à écrire des tonnes de code que le faire explicitement.
- La dernière partie de async/await qui est remarquable, c'est que c'est un "niveau plus élevé concept" alors que ContinueWith(...) est plus manuelle et est explicitement lambdas, délégué créations, etc. Niveau supérieur concepts il y a plus de possibilité pour l'optimisation - ainsi, par exemple, plusieurs attend dans la même méthode, en fait de "partager" les mêmes lambda fermeture (c'est comme la surcharge d'une seule lambda), alors que ContinueWith(...) obtient la surcharge chaque fois que vous invoquez-le, parce que vous l'avez explicitement écrit un lambda, de sorte que le compilateur donne que pour vous.
- Pourriez-vous élaborer sur ce qui se passerait si Connect méthode a déclenché une exception au sein de la Fpo code? Serait ContinueWith toujours être déclenché dans ce cas? Et si oui, est-il une meilleure approche pour obtenir des que comportement à l'aide de seulement async/await? Je veux exécuter deux tâches, l'une après l'autre, et je ne m'inquiète pas si le premier lève une exception, le deuxième doit toujours exécuter. AFAICT, si je suis allé avec l'attend, j'aurais à traiter explicitement des exceptions et de créer le total exception.
- Si Connect jeta un SpecificException, puis le ContinueWith à l'exécution; un accès à la Result propriété poserait un AggregateException emballage de la SpecificException. L'exception serait alors ignoré. I want to run two tasks one after the other, and I don't care if the first one throws an exception, the second should always run. Il ya une tendance pour que: try { await first(); } finally { await second(); } qui travaille pour le C#6 / VS2015, mais sur VS2013, vous auriez à try { await first(); } catch { } await second();.
InformationsquelleAutor Stephen Cleary
8

C'est "essentiellement", mais le code généré n'a strictement plus que cela. Pour beaucoup plus de détails sur le code généré, je vous conseille de Jon Skeet est Eduasync série:

http://codeblog.jonskeet.uk/category/eduasync/

En particulier, post #7 pénètre dans ce qui est généré (comme de la CTP 2) et pourquoi, alors, probablement, un ajustement parfait pour ce que vous êtes à la recherche pour le moment:

http://codeblog.jonskeet.uk/2011/05/20/eduasync-part-7-generated-code-from-a-simple-async-method/

EDIT: je pense que c'est probablement plus de détails que ce que vous recherchez à partir de la question, mais si vous vous demandez ce que les choses ressembler lorsque vous avez plusieurs attend dans la méthode, c'est contenue dans le post #9 🙂

http://codeblog.jonskeet.uk/2011/05/30/eduasync-part-9-generated-code-for-multiple-awaits/

InformationsquelleAutor James Manning

Vous devez vous connecter pour publier un commentaire.