Devez-vous mettre à la Tâche.Exécuter dans une méthode pour le rendre asynchrone?

J'essaie de comprendre async vous attendent dans la forme la plus simple. Je veux créer une méthode très simple qui ajoute deux nombres pour les besoins de cet exemple, accordé, il n'est pas temps de traitement à tous, c'est juste une question de formulation d'un exemple ici.

Exemple 1

private async Task DoWork1Async()
{
    int result = 1 + 2;
}

Exemple 2

private async Task DoWork2Async()
{
    Task.Run( () =>
    {
        int result = 1 + 2;
    });
}

Si j'attends DoWork1Async() le code est exécuté de manière synchrone ou asynchrone?

Ai-je besoin d'envelopper le code de synchronisation avec Task.Run pour rendre la méthode awaitable ET asynchrone afin de ne pas bloquer le thread d'INTERFACE utilisateur?

Je suis en train de voir si ma méthode est un Task ou retourne Task<T> dois-je placer le code avec Task.Run pour le rendre asynchrone.

Question stupide, mais je suis sûr que je voir des exemples sur le net où les gens sont en attente de code qui n'a rien asynchrone à l'intérieur et n'est pas enroulé dans un Task.Run ou StartNew.

  • N'est pas votre premier extrait de vous donner tous les avertissements?
InformationsquelleAutor Neal | 2013-06-15
  1. 534

    Tout d'abord, nous allons clarifier la terminologie: "asynchrone" (async) signifie qu'il peut céder le contrôle de retour pour le thread appelant avant qu'il ne commence. Dans un async méthode, ces "rendement" points sont await expressions.

    C'est très différent que le terme "asynchrone", comme (sig)utilisé par la documentation MSDN pour les années à dire "s'exécute sur un thread d'arrière-plan".

    Pour de plus amples confondre la question, async est très différent de "awaitable"; il y a quelques async des méthodes dont le type de retour ne sont pas awaitable, et de nombreuses méthodes de retour awaitable types qui ne sont pas async.

    Assez sur ce qu'ils ne sont pas; voici ce qu'ils sont:

    • La async mot-clé permet une méthode asynchrone (qui est, il permet await expressions). async méthodes peuvent retourner Task, Task<T>, ou (si vous devez) void.
    • Tout type qui suit un certain modèle peut être awaitable. La plus courante awaitable types sont Task et Task<T>.

    Donc, si nous reformuler votre question "comment puis-je exécuter une opération sur un thread d'arrière-plan d'une manière qui il est awaitable", la réponse est d'utiliser Task.Run:

    private Task<int> DoWorkAsync() //No async because the method does not need await
{
  return Task.Run(() =>
  {
    return 1 + 2;
  });
}

    (Mais ce modèle est une mauvaise approche, voir ci-dessous).

    Mais si votre question est "comment puis-je créer un async méthode qui peut le rendement jusqu'à son appelant au lieu de le bloquer", la réponse est de déclarer la méthode async et l'utilisation await pour son "rendement" des points:

    private async Task<int> GetWebPageHtmlSizeAsync()
{
  var client = new HttpClient();
  var html = await client.GetAsync("http://www.example.com/");
  return html.Length;
}

    Ainsi, le motif de base des choses, c'est d'avoir async code dépendent de "awaitables" dans son await expressions. Ces "awaitables" peut-être d'autres async méthodes ou tout simplement des méthodes régulières de retour awaitables. Des méthodes régulières de retour Task/Task<T> peut utilisation Task.Run d'exécuter du code sur un thread d'arrière-plan, ou (plus souvent) qu'ils peuvent utiliser TaskCompletionSource<T> ou l'un de ses raccourcis (TaskFactory.FromAsync, Task.FromResult, etc). Je ne pas recommander l'enchaînement d'un ensemble de méthode dans Task.Run; les méthodes synchrones doivent avoir synchrone signatures, et il devrait être laissé au consommateur qu'il doit être enveloppé dans un Task.Run:

    private int DoWork()
{
  return 1 + 2;
}

private void MoreSynchronousProcessing()
{
  //Execute it directly (synchronously), since we are also a synchronous method.
  var result = DoWork();
  ...
}

private async Task DoVariousThingsFromTheUIThreadAsync()
{
  //I have a bunch of async work to do, and I am executed on the UI thread.
  var result = await Task.Run(() => DoWork());
  ...
}

    J'ai un async/attendre intro sur mon blog; à la fin, il est intéressant de suivi des ressources. La MSDN docs pour async sont exceptionnellement bonnes, trop.

    • Vous avez dit: "Il y a quelques méthodes asynchrones dont le type de retour ne sont pas awaitable". Voulez-vous dire "async void" méthodes? Si non, veuillez donner un exemple.
    • Oui. async méthodes doivent retourner Task, Task<T>, ou void. Task et Task<T> sont awaitable; void ne l'est pas.
    • En fait, un async void signature de la méthode de compiler, c'est juste une très mauvaise idée que vous perdez votre pointeur de votre tâche asynchrone
    • Oui, ils vont compiler, mais void n'est pas awaitable.
    • Salut @StephenCleary simplement si l'on doit exécuter un awaitable Tâche de façon synchrone (par exemple, en raison de certaines contraintes extérieures) est la meilleure façon de faire quelque chose comme var result = Task.Run(() => AwaitableTaskIMustUse()).Result;?
    • Il n'y a pas de réponse universelle. Je couvre une variété d'approches dans mon article sur friches industrielles async développement. Vous pouvez utiliser Task.Run(() => SomethingAsync()).GetAwaiter().GetResult() seulement si SomethingAsync peut en toute sécurité être exécuté sur un thread du pool et de votre application n'est pas en danger de pool de threads de la famine.
    • désolé pour ma réponse tardive mais je suis vraiment essayer de comprendre quelque chose. J'ai lu votre blog: blog.stephencleary.com/2013/11/... et vous avez dit qu'à l'aide de la Tâche.Exécuter dans l'implémentation Asynchrone est une mauvaise pratique. N'est-ce pas ce que vous faites dans DoVariousThingsFromTheUIThreadAsync() ? Et je vois que la nature de l'utiliser aussi dans la réponse ci-dessous (DoWorkAsync() méthode qui utilise la Tâche.Exécuter(..))..
    • Non, ce dont je parle dans le billet de blog, c'est quand l'ensemble de la méthode est juste un appel à Task.Run (comme DoWorkAsync dans cette réponse). À l'aide de Task.Run à appel une méthode à partir d'une INTERFACE utilisateur contexte est approprié (comme DoVariousThingsFromTheUIThreadAsync).
    • La pensée n'est pas directement lié mais que vous voulez poser, dans le cadre de asp.net l'api web qui est implicitement multithread, à partir d'un contrôleur si je dois consommer externe api REST qui fournit seulement les méthodes synchrones, est-il bénéfique pour envelopper l'api synchrones dans la Tâche.Run()?
    • Pas de. Si c'est une API REST, vous devriez être en mesure d'appeler de manière asynchrone (en utilisant, par exemple, HttpClient).
    • Désolé je confond probablement vous. C'est un externe .net api pour le cloud d'accès aux données; et l'api ne fournit pas de méthodes asynchrones.
    • href="https://msdn.microsoft.com/en-us/magazine/dn802603.aspx" >Puis il suffit de les appeler de manière synchrone; ne pas envelopper dans Task.Run.
    • Parce qu'il augmente en fait de changement de contexte étant donné que la Tâche.Exécuter allons utiliser un autre pool de thread? Même si la demande initiale thread est débloqué, il bloque en réalité un autre pool de thread Tâche.Utilise?
    • Oui; suivre le lien que j'ai donné pour plus d'informations.
    • Génial! Merci beaucoup!
    • Je viens de lire votre article (le dernier lien que vous avez partagé ci-dessus, à partir de Mar 16), et je comprends à quel rendement sur le pool de threads peut être bénéfique pour vraiment-des opérations asynchrones (le "il n'y a pas de fil" genre", comme I/O), car il n'y a pas de blocage et le fil peut faire d'autres choses. Mais si nous parlons de la pseudo-async? E. g. J'ai un ancien de la bibliothèque qui est synchrone, mais de longue durée d'exécution des méthodes. Je veux les lancer dans une tâche et le rendement, mais n'est-ce pas encore à exécuter sur (et donc bloquer) un thread quelque part? Ils ne sont pas les "il n'y a pas de fil" type d'opérations.
    • ... eh bien, dans une certaine mesure, au plus profond, ils comprennent les opérations d'e/S, ce qui serait vraiment asynchrone, mais c'est seulement une partie de ce que ces méthodes (à partir de l'ancienne bibliothèque) sont en train de faire. Je veux faire de l'ensemble de l'appel à la méthode asynchrone, mais il semble quand même le code, tout en produisant à le thread principal, serait encore long "synchrone" sur un thread du pool (par exemple par l'intermédiaire de la Tâche.Run()).
    • Exemple: var t = await Task.Run(() => MyOldLibrarySynchronousMethod()); // is this blocking a thread pool thread, even though it yields to the calling thread?
    • Oui, synchrone I/O dans un Task.Run va bloquer un thread du pool. C'est bien d'appeler les vieux modes de synchronisation avec await Task.Run, mais vous ne voulez pas exposer un async-à la recherche wrapper - c'est ce que j'appelle des "faux async". Vous voudrez peut-être vérifier mon Task.Run l'étiquette de la série.
    • Merci beaucoup! Donc, la raison pour laquelle je ne veux pas avoir un "faux async" la méthode est tout simplement parce qu'il est surprenant -- développeurs pense qu'il est vraiment-async? Alors que si je ne await Task.Run pour appeler une méthode de synchronisation, il est clair qu'il va faire, c'est à dire exécuter une méthode de synchronisation sur un thread d'arrière-plan et de bloquer l'ensemble du thread?
    • Oui, exactement. Il est valide pour utiliser Task.Run à appeler d'une méthode, mais si il y a un Task.Run autour de tous (ou presque tous) le code de la méthode, puis que c'est un anti-pattern - il suffit de garder la méthode synchrone et déplacer le Task.Run jusqu'à un niveau.

    InformationsquelleAutor Stephen Cleary
  2. 21

    L'une des choses les plus importantes à retenir lors de la décoration d'une méthode avec async est qu'au moins il n'y a un attendent opérateur à l'intérieur de la méthode. Dans votre exemple, je voudrais le traduire comme indiqué ci-dessous à l'aide de TaskCompletionSource.

    private Task<int> DoWorkAsync()
{
    //create a task completion source
    //the type of the result value must be the same
    //as the type in the returning Task
    TaskCompletionSource<int> tcs = new TaskCompletionSource<int>();
    Task.Run(() =>
    {
        int result = 1 + 2;
        //set the result to TaskCompletionSource
        tcs.SetResult(result);
    });
    //return the Task
    return tcs.Task;
}

private async void DoWork()
{
    int result = await DoWorkAsync();
}
    • Pourquoi utilisez-vous TaskCompletionSource, au lieu de simplement retourner tâche retourné par la Tâche.Méthode Run () (et la modification de son corps pour revenir résultat)?
    • Juste une note de côté. Une méthode qui a un "async void" la signature est généralement une mauvaise pratique et considérée comme un mauvais code, car il peut conduire à l'INTERFACE utilisateur de blocage assez facilement. La principale exception est asynchrone des gestionnaires d'événements.
    InformationsquelleAutor Ronald Ramos
  3. 12

    Lorsque vous utilisez la Tâche.Exécuter pour exécuter une méthode, la Tâche devient un thread du pool de threads pour exécuter cette méthode. Donc, à partir de la thread de l'INTERFACE utilisateur, il est "asynchrone", comme on ne veut pas bloquer le thread d'INTERFACE utilisateur.C'est bien pour l'application de bureau que vous n'avez généralement pas besoin de beaucoup de fils pour prendre soin d'interactions de l'utilisateur.

    Toutefois, pour l'application de web chaque demande est traitée par un thread du pool de thread et donc le nombre de demandes actives peut être augmenté par l'économie de tels fils. Souvent en utilisant des threads de pool de threads pour simuler l'opération asynchrone n'est pas extensible pour les applications web.

    Vrai Asynchrone n'est pas nécessairement impliquant l'utilisation d'un thread pour les opérations d'e/S, tels que le fichier /DB accès, etc. Vous pouvez lire ceci pour comprendre pourquoi l'opération d'e/S n'a pas besoin de fils. http://blog.stephencleary.com/2013/11/there-is-no-thread.html

    Dans votre exemple simple,c'est un pur lié au PROCESSEUR de calcul, donc à l'aide de la Tâche.Run est fine.

    • Donc, si j'ai à consommer synchrone api externe au sein d'une web api contrôleur, je ne devrais PAS envelopper l'appel synchrone dans la Tâche.Run()? Comme vous l'avez dit, cela permettra de garder la demande initiale fil débloqué mais c'est à l'aide d'un autre pool de thread à l'appel de l'api externe. En fait, je pense que c'est encore une bonne idée, car de cette manière, il peut, en théorie, l'utilisation de deux pool de threads pour traiter de nombreuses demandes par exemple, un thread peut traiter de nombreuses demandes entrantes et d'un autre on peut appeler l'api externe pour toutes ces demandes?
    • Je suis d'accord.Je ne dis pas que vous ne devriez pas tout à fait envelopper tous les appels synchrones au sein de la Tâche.Run(). Je suis simplement remarquer problème potentiel.
    • ne doit PAS être enroulé à l'appel synchrone dans la Tâche.Run() qui est correcte. Si vous le faites, vous serait juste de passer les fils. c'est à dire que vous êtes un déblocage de la demande initiale, fil, mais vous êtes en prenant un autre thread du pool de threads qui aurait pu être utilisé pour traiter une autre demande. Le seul résultat est un changement de contexte de surcharge lorsque l'appel est terminé pour absolument zéro le gain
    InformationsquelleAutor zheng yu