如何使任务可等待

Question

昨天我开始使用 Microsoft CTP 异步库，但我找不到可等待任务的正确实现。我知道它必须有这样的实现？：

public struct SampleAwaiter<T>
{
    private readonly Task<T> task;
    public SampleAwaiter(Task<T> task) { this.task = task; }
    public bool IsCompleted { get { return task.IsCompleted; } }
    public void OnCompleted(Action continuation) { TaskEx.Run(continuation); }
    public T GetResult() { return task.Result; }
}

但是我现在如何实现一个任务，比方说，等待 5 秒，然后返回一些字符串，例如“Hello World”？

一种方法是直接使用 Task，如下所示：

Task<string> task = TaskEx.Run(
            () =>
                {
                    Thread.Sleep(5000);
                    return "Hello World";
                });

        string str = await task;

但是我将如何使用可等待的实现来做到这一点？或者我只是误解了一切？

感谢您提供任何信息/帮助:)

Answer 1

这里的关键是 AsyncCtpThreadingExtensions.GetAwaiter 它通过扩展方法提供这些方法。由于异步实现是基于模式的（如LINQ），而不是绑定到特定的接口，它可以来自任何地方（在本例中是TaskAwaiter）。

您编写的代码值得等待。例如：

static void Main()
{
    Test();
    Console.ReadLine(); // so the exe doesn't burninate
}
static async void Test() {
    Task<string> task = TaskEx.Run(
           () =>
           {
               Thread.Sleep(5000);
               return "Hello World";
           });
    string str = await task;
    Console.WriteLine(str);
}

5 秒后打印 Hello World。

Answer 2

一年后添加

使用 async-await 一年多了，我知道我在原来的答案中写的关于 async 的一些内容不正确，尽管答案中的代码仍然是正确的。 Hera 有两个链接极大地帮助我理解了 async-await 的工作原理。

这次采访 Eric Lippert 展示了 async-await 的一个很好的类比。在中间的某个位置搜索 async-await。

在本文中，非常乐于助人的 Eric Lippert 展示了一些异步的良好实践-await

原始答案

好的，这是一个在学习过程中对我有帮助的完整示例。

假设您有一个速度较慢的计算器，并且您想在按下按钮时使用它。同时，您希望您的 UI 保持响应能力，甚至可能做其他事情。当计算器完成后，您想要显示结果。

当然：为此使用 async/await，而不是像设置事件标志和等待设置这些事件这样的旧方法。

这是慢速计算器：

private int SlowAdd(int a, int b)
{
    System.Threading.Thread.Sleep(TimeSpan.FromSeconds(5));
    return a+b;
}

如果您想在使用 async-await 时异步使用它，则必须使用 Task.Run(...) 异步启动它。 Task.Run 的返回值是一个可等待的任务：

• Task 如果您运行的函数的返回值为 void
• Task 如果您运行的函数的返回值是 TResult

您可以启动任务，执行其他操作，并且每当您需要任务的结果时，您可以键入await。有一个缺点：

如果您想“等待”，您的函数需要异步并返回 Task 而不是 void 或 Task而不是 TResult。

这是运行慢速计算器的代码。
使用 async 终止异步函数的标识符是常见的做法。

private async Task<int> SlowAddAsync(int a, int b)
{
    var myTask = Task.Run ( () => SlowAdd(a, b));
    // if desired do other things while the slow calculator is working
    // whenever you have nothing to do anymore and need the answer use await
    int result = await myTask;
    return result;
}

旁注：有些人更喜欢 Task.Factory.StartNew 而不是 Start.Run。看看 MSDN 对此有何介绍：

MSDN：Task.Run 与 Task.Factory .开始新的

SlowAdd 作为异步函数启动，并且您的线程继续。一旦它需要答案，它就会等待任务。返回值是 TResult，在本例中是一个 int。

如果您没有什么有意义的事情要做，代码将如下所示：

private async Task`<int`> SlowAddAsync(int a, int b)
{
    return await Task.Run ( () => SlowAdd(a, b));
}

请注意，SlowAddAsync 被声明为异步函数，因此使用此异步函数的每个人也应该是异步的并返回 Task 或 Task> ;:

private async Task UpdateForm()
{
     int x = this.textBox1.Text;
     int y = this.textBox2.Text;
     int sum = await this.SlowAddAsync(x, y);
     this.label1.Text = sum.ToString();
}

async/await 的好处是你不必摆弄ContinueWith 来等待上一个任务完成。只需使用await，您就知道任务已完成并且您有返回值。 wait 之后的语句是您通常在ContinueWith 中执行的操作。

顺便说一句，你的 Task.Run 不必调用函数，你也可以在其中放置一个语句块：

int sum = await Task.Run( () => {
    System.Threading.Thread.Sleep(TimeSpan.FromSeconds(5));
    return a+b});

然而，单独函数的好处是，你可以为那些不需要/想要/理解异步的人提供帮助，可以在没有 async/await 的情况下使用该函数。

记住：

每个使用await的函数都应该是异步的

每个异步函数都应返回 Task 或 Task>




“但是我的事件处理程序无法返回任务！”

private void OnButton1_Clicked(object sender, ...){...}

你是对的，因此这是唯一的例外：

异步事件处理程序可能返回 void

因此，当单击按钮时，异步事件处理程序将使 UI 保持响应：

private async void OnButton1_Clicked(object sender, ...)
{
    await this.UpdateForm();
}

但是，您仍然必须声明事件处理程序异步

许多 .NET 函数都有返回任务或任务> 的异步版本。




有异步函数
- 互联网接入
- 流读写
- 数据库访问
- 等等。

要使用它们，您不必调用 Task.Run，​​它们已经返回 Task 和 Task>只需打电话给他们，继续做你自己的事情，当你需要等待任务的答案并使用 TResult 时。

启动多项任务并等待它们完成
如果您启动多个任务并且想要等待所有任务完成，请使用 Task.WhenAll(...) NOT Task.Wait

Task.Wait 返回 void。 Task.WhenAll 返回一个 Task，因此您可以等待它。

一旦一个任务执行完毕，返回值已经是await的返回了，但是如果你await Task.WhenAll(new Task[]{TaskA, TaskB, TaskC});
您必须使用 Task>.Result 属性来了解任务的结果：

int a = TaskA.Result;

如果其中一个任务引发异常，则会将其包装为 AggregateException 中的 InnerException。因此，如果您等待 Task.WhenAll，请准备好捕获 AggregateException 并检查 innerExceptions 以查看您启动的任务引发的所有异常。使用 AggregateException.Flatten 函数可以更轻松地访问异常。

有关取消的有趣阅读：

MSDN 关于托管中的取消线程

最后：您使用 Thread.Sleep(...)。异步版本是 Task.Delay(TimeSpan)：

private async Task`<int`> MySlowAdd(int a, int b)
{
    await Task.Delay(TimeSpan.FromSeconds(5));
    return a+b;
}

如果您使用此函数，您的程序将保持响应。

Answer 3

我最终得到了这个示例代码......这是可等待模式的正确实现吗？

namespace CTP_Testing
{
using System;
using System.Linq;
using System.Net;
using System.Threading;
using System.Threading.Tasks;

public class CustomAsync
{
    public static CustomAwaitable GetSiteHeadersAsync(string url)
    {
        return new CustomAwaitable(url);
    }
}

public class CustomAwaitable
{
    private readonly Task<string> task;
    private readonly SynchronizationContext ctx;

    public CustomAwaitable(string url)
    {
        ctx = SynchronizationContext.Current;
        this.task = Task.Factory.StartNew(
            () =>
                {
                    var req = (HttpWebRequest)WebRequest.Create(url);
                    req.Method = "HEAD";
                    var resp = (HttpWebResponse)req.GetResponse();
                    return this.FormatHeaders(resp.Headers);
                });
    }
    public CustomAwaitable GetAwaiter() { return this; }
    public bool IsCompleted { get { return task.IsCompleted; } }
    public void OnCompleted(Action continuation)
    {
        task.ContinueWith(_ => ctx.Post(delegate { continuation(); }, null));
    }
    public string GetResult() { return task.Result; }

    private string FormatHeaders(WebHeaderCollection headers)
    {
        var headerString = headers.Keys.Cast<string>().Select(
            item => string.Format("{0}: {1}", item, headers[item]));

        return string.Join(Environment.NewLine, headerString.ToArray());
    }
}