Comment est-ce que C# 5.0 asynchrone-attendent fonction diffère de la TPL?

Je ne vois pas la différence entre C#(et VB s) nouveau async fonctionnalités, et .NET 4.0 Task Parallel Library. Prenez, par exemple, Eric Lippert du code à partir d'ici:

async void ArchiveDocuments(List<Url> urls) {
    Task archive = null;
    for(int i = 0; i < urls.Count; ++i) {
        var document = await FetchAsync(urls[i]);
        if (archive != null)
            await archive;
        archive = ArchiveAsync(document);
    }
}

Il semble que la await mot-clé sert à deux fins. La première occurrence (FetchAsync) semble signifier, "Si cette valeur est utilisée plus tard dans la méthode et sa tâche n'est pas terminée, attendez jusqu'à ce qu'elle se termine avant de continuer." La deuxième instance (archive) semble signifier, "Si cette tâche n'est pas encore terminé, attendez maintenant jusqu'à la fin." Si je me trompe, corrigez-moi.

Ne pourrait-elle pas tout aussi bien être écrit comme ceci?

void ArchiveDocuments(List<Url> urls) {
    for(int i = 0; i < urls.Count; ++i) {
        var document = FetchAsync(urls[i]);       //removed await
        if (archive != null)
            archive.Wait();                       //changed to .Wait()
        archive = ArchiveAsync(document.Result);  //added .Result
    }
}

J'ai remplacé la première await avec un Task.Result où la valeur est réellement nécessaire, et la deuxième await avec Task.Wait(), où l'attente est en train de se produire. La fonctionnalité est (1) déjà mis en œuvre, et (2) beaucoup plus proche sémantiquement à ce qui se passe réellement dans le code.

Je me rends compte qu'un async méthode est réécrit comme une machine d'état, semblables à des itérateurs, mais je ne vois pas quels sont les avantages que cela implique. Tout code qui nécessite un autre thread pour fonctionner (comme le téléchargement) auront encore besoin d'un autre thread, et tout le code qui ne fonctionne pas (comme la lecture à partir d'un fichier) pourrait encore utiliser le TPL de travailler avec un seul thread.

Je suis évidemment manquant de quelque chose d'énorme ici; quelqu'un peut-il m'aider à comprendre un peu mieux?

InformationsquelleAutor zildjohn01 | 2010-10-29
  1. 71

    Je pense que le malentendu se pose ici:

    Il semble que le mot clé await est de servir à deux fins. La première occurrence (FetchAsync) semble signifier, "Si cette valeur est utilisée par la suite dans la méthode et sa tâche n'est pas terminée, attendez jusqu'à ce qu'elle se termine avant de continuer." La deuxième instance (archive) semble signifier, "Si cette tâche n'est pas encore terminé, attendez maintenant jusqu'à la fin." Si je me trompe, corrigez-moi.

    C'est en fait tout à fait incorrect. Ces deux ont le même sens.

    Dans votre premier cas:

    var document = await FetchAsync(urls[i]);

    Ce qui se passe ici, c'est que le runtime dit "Commencer à appeler FetchAsync, puis retourne le point de l'exécution du thread appelant cette méthode." Il n'y a pas de "en attente" ici - à la place, l'exécution retourne à l'appelant contexte de synchronisation, et les choses ressasser. À un certain moment dans l'avenir, FetchAsync sa Tâche terminée, et à ce point, ce code va reprendre sur le thread appelant contexte de synchronisation, et de la prochaine instruction (affectation de la variable de document) va se produire.

    Exécution continuera ensuite jusqu'à la deuxième attendent d'appel à laquelle, la même chose va se produire - si le Task<T> (archive) n'est pas complète, l'exécution sera libéré dans le contexte de l'appel - dans le cas contraire, l'archive sera réglé.

    Dans le second cas, les choses sont très différentes - ici, vous êtes bloque, ce qui signifie que l'appelant contexte de synchronisation n'obtiendrez jamais une chance d'exécuter le code jusqu'à ce que l'ensemble de votre méthode est terminée. Certes, il y est encore asynchronisme, mais l'asynchronie est entièrement contenue à l'intérieur de ce bloc de code pas de code en dehors de cette collé le code qui va se passer sur ce thread jusqu'à ce que l'ensemble de votre code terminée.

    InformationsquelleAutor Reed Copsey
  2. 25

    Il y a une énorme différence:

    Wait() blocs, await ne bloque pas. Si vous exécutez la version asynchrone de ArchiveDocuments() sur votre thread GUI, au GUI va rester sensible alors que l'extraction et l'archivage des opérations sont en cours d'exécution.
    Si vous utilisez le TPL version avec Wait(), de votre interface sera bloqué.

    Noter que async parvient à le faire sans introduire de fils - point de la await, le contrôle est simplement retourné à la boucle de message. Une fois la tâche attendu est terminée, le reste de la méthode (suite) est mis en file d'attente sur la boucle de message et le thread GUI continuera de fonctionner ArchiveDocuments où il l'a laissée.

    InformationsquelleAutor Daniel
  3. 24

    Anders bouilli vers le bas pour une très brève réponse dans le Canal 9 interview en Direct qu'il a fait. Je le recommande fortement

    La nouvelle Async et await mots-clés vous permettent de orchestrer la simultanéité dans vos applications. Ils n'ont pas fait introduire toute la simultanéité dans votre application.

    TPL et plus précisément la Tâche est une façon vous pouvez utiliser pour effectuer les opérations simultanément. La nouvelle async et await mots clés vous permettent de composer ces opérations simultanées dans un "synchrone" ou "linéaire" de la mode.

    De sorte que vous pouvez toujours écrire un linéaire de flux de contrôle dans vos programmes, tandis que le calcul peut ou peut ne pas se produire simultanément. Lorsque le calcul ne se produire simultanément, attendent et async vous permettent de composer ces opérations.

    • Ce n'est pas réellement dire rien, est-il? Permettez-moi de reformuler: Comment est-ce répondre à la question posée?
    • La question est "Comment est-ce que C# 5.0 asynchrone-attendent fonction diffère de la TPL?" Ma réponse est approprié pour cette question de l'OMI
    InformationsquelleAutor Brad Cunningham
  4. 6

    La capacité de transformer le programme de flux de contrôle dans une machine d'état est ce qui rend ces nouveaux mots-clés intéressant. Il pense que cession du contrôle, plutôt que de valeurs.

    Découvrez ce Canal 9 de la vidéo de Anders parler de la nouvelle fonction.

    InformationsquelleAutor John Leidegren
  5. 4

    Le problème ici est que la signature de ArchiveDocuments est trompeuse. Il a un retour explicite de void mais vraiment le retour est Task. Pour moi nulle implique synchrone comme il n'existe aucun moyen "d'attendre" la fin de la. Considérer l'autre signature de la fonction.

    async Task ArchiveDocuments(List<Url> urls) { 
  ...
}

    Pour moi quand c'est écrit de cette façon, la différence est beaucoup plus évident. Le ArchiveDocuments fonction n'est pas celle qui se termine de façon synchrone mais de le terminer plus tard.

    • Ce code serait de faire beaucoup plus de sens si "archive" ont été un membre ou variable statique, et n'est pas définie dans la méthode... cela étant dit, nul retour asynchrone fonctions sont parfaitement valables et acceptables, et un "fire and forget", qui signifie, selon les spécifications de la documentation.
    • Dites-vous que l'appel à ArchiveDocuments() ressemblerait Task task = ArchiveDocuments(List<Url> urls);? Cela ne semble pas juste... et si je comprends bien, l'appelant n'est pas vraiment s'attendre à tout. En effet, si l'on se soucie de l'issue de ArchiveDocuments(), l'ensemble du scénario tombe à l'eau et ne fonctionne pas.
    • Je suis d'accord, ils sont en effet valide et correct. Je trouve qu'il est très trompeuse et un peu presumpstious que peut-être je ne veux pas l'oublier 😉
    • Je dis que je pense que la différence qui fait un peu plus senes si vous considérez que Task est également de retour valable.
    InformationsquelleAutor JaredPar
  6. 0

    L'appel à FetchAsync() va encore bloquer jusqu'à la fin (à moins d'une déclaration dans les appels await?) La clé est que le contrôle est renvoyé à l'appelant (parce que le ArchiveDocuments méthode elle-même est déclarée comme async). Si l'appelant peut être heureux et de continuer le traitement logique de l'INTERFACE utilisateur, répondre à des événements, etc.

    Quand FetchAsync() se termine, il interrompt l'appelant pour terminer la boucle. Il frappe ArchiveAsync() et de blocs, mais ArchiveAsync() probablement juste de crée une nouvelle tâche, il commence, et renvoie la tâche. Cela permet à la deuxième boucle pour commencer, et que la tâche est en cours de traitement.

    La deuxième boucle hits FetchAsync() et de blocs, de rendre le contrôle à l'appelant. Lorsque FetchAsync() complète, une fois encore, les interruptions de l'appelant à poursuivre le traitement. Il frappe ensuite await archive, qui retourne le contrôle à l'appelant jusqu'à ce que le Task créé dans la boucle 1 est terminée. Une fois que la tâche est terminée, l'appelant est de nouveau interrompue, et la deuxième boucle appels ArchiveAsync(), qui est une tâche lancée et commence la boucle 3, répétez les ad nauseam.

    La clé est de rendre le contrôle à l'appelant si le lourd poussoirs sont en cours d'exécution.

    • Notez que "la lourde poussoirs" pourrait ne pas être en cours d'exécution. Ils pourraient ne pas être en parallèle à tous. Ils peuvent être des unités de travail qui sont mis sur ce thread à chaque fois que ce fil va au ralenti, par exemple. Je vais voir un beaucoup de l'agrégation de l'asynchronie avec le parallélisme et je suis impatient de détromper les gens de cette notion; l'asynchronie est souvent à propos de pas la production de plus de threads de travail. La clé est en fait le retour de contrôle à l'appelant après "la lourde poussoirs" ont fait quelque chose pour s'assurer que leur tâche se termine à un certain moment dans l'avenir.
    • Comprendre ce que vous dites, et vous acceptez la await ed méthode n'a pas besoin de lancer ou de planifier quoi que ce soit. Ce qui m'a incité à faire cette déclaration a été de la archive.Wait(). Dans cet exemple, le code est certainement écrit à attendre qu'un thread pour faire quelque chose d'immédiatement et complète. Ma déclaration a été dans le cadre de cet exemple, seulement.
    • concernant les "...n'a pas besoin de lancer ou de planifier quoi que ce soit": il éventuellement calendrier, ou de lancer des s/t, à droite?
    InformationsquelleAutor James King
  7. 0

    Le mot clé await ne pas introduire de la concurrence. C'est comme le mot clé yield, il indique au compilateur de restructurer votre code en lambda contrôlé par une machine d'état.

    De voir ce qui attend les code ressemblerait sans "attendre" voir cet excellent lien: http://blogs.msdn.com/b/windowsappdev/archive/2012/04/24/diving-deep-with-winrt-and-await.aspx

    InformationsquelleAutor Tb.