C#并发编程-2 异步编程基础-Task

一 异步延迟

在异步方法中，如果需要让程序延迟等待一会后，继续往下执行，应使用Task.Delay()方法。

//创建一个在指定的毫秒数后完成的任务。
public static Task Delay(int millisecondsDelay);
//创建一个在指定的毫秒数后完成的可取消任务。
public static Task Delay(TimeSpan delay, CancellationToken cancellationToken);

下例演示Delay的简单用法：

public static void Main()
{
    var t = Task.Run(async delegate
    {
        await Task.Delay(1000);
        return 42;
    });
    t.Wait();
    Console.WriteLine("Task t Status: {0}, Result: {1}",
                      t.Status, t.Result);
}

下面的例子启动了一个Task，该Task包含对Delay(Int32, CancellationToken)方法的调用，延迟时间为一秒。

token将在延迟时间间隔到期前被取消。因此将引发一个TaskCanceledException，并且Task.Status的属性被设置为Canceled。

public static void Main()
{
    CancellationTokenSource source = new CancellationTokenSource();

    var t = Task.Run(async delegate
    {
        await Task.Delay(1000, source.Token);
        return 42;
    });
    source.Cancel();
    try
    {
        t.Wait();
    }
    catch (AggregateException ae)
    {
        foreach (var e in ae.InnerExceptions)
            Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message);
    }
    Console.Write("Task t Status: {0}", t.Status);
    if (t.Status == TaskStatus.RanToCompletion)
        Console.Write(", Result: {0}", t.Result);
    source.Dispose();
}

下面的例子用Task.Delay实现了一个简单的超时功能：

static async Task<string> DownloadStringWithTimeout(string uri)
{
    using (var client = new HttpClient())
    {
        var downloadTask = client.GetStringAsync(uri);
        var timeoutTask = Task.Delay(3000);
        //如果服务在3秒内没有响应，就返回null
        var completedTask = await Task.WhenAny(downloadTask, timeoutTask);
        if (completedTask == timeoutTask)
            return null;
        return await downloadTask;
    }
}

二 返回完成的Task

2.1 Task.FromResult

如果从异步接口或基类继承代码，但希望用同步的方法来实现它，就会出现这样一个问题，如何实现一个具有异步签名的同步方法？

可以使用 Task.FromResult 方法创建并返回一个新的 Task<T> 对象，这个 Task 对象是已经成功完成的，并有指定的结果。

public static Task<TResult> FromResult<TResult>(TResult result);

如下所示：

interface IMyAsyncInterface
{
    Task<int> GetValueAsync();
}
class MySynchronousImplementation : IMyAsyncInterface
{
    public Task<int> GetValueAsync()
    {
        return Task.FromResult(13);
    }
}

在用同步代码实现异步接口时，要避免使用任何形式的阻塞操作。在异步方法中进行阻塞操作，然后返回一个完成的 Task 对象，这种做法并不可取。

2.1 TaskCompletionSource

Task.FromResult 只能提供结果正确的同步 Task 对象。如果要让返回的 Task 对象有一个其他类型的结果（例如以 NotImplementedException 结束的 Task 对象），

需要使用TaskCompletionSource ：

static Task<T> NotImplementedAsync<T>()
{
    var tcs = new TaskCompletionSource<T>();
    tcs.SetException(new NotImplementedException());
    return tcs.Task;
}

三 报告进度

异步操作执行的过程中，如果需要展示操作的进度，可以考虑使用IProgress<T> 和 Progress<T>。

static async Task CallMyMethodAsync()
{
    var progress = new Progress<double>();
    progress.ProgressChanged += (sender, args) =>
    {
        Console.WriteLine($"当前进度：{args}%");
    };
    await MyMethodAsync(progress);
}

static async Task MyMethodAsync(IProgress<double> progress = null)
{
    double percentComplete = 0;
    while (percentComplete < 100)
    {
        await Task.Delay(100);
        percentComplete++;
        if (progress != null)
            progress.Report(percentComplete);
    }
}

按照惯例，如果不需要报告进度，IProgress<T> 参数可以是 null，因此在 async 方法中一定要对此进行检查。

需要注意的是，IProgress<T>.Report 方法可以是异步的。这意味着真正报告进度之前，MyMethodAsync 方法会继续运行。

基于这个原因，最好把 T 定义为一个不可变类型，或者至少是值类型。如果 T 是一个可变的引用类型，就必须在每次调用 IProgress<T>.Report 时，创建一个单独的副本。

Progress<T> 会在创建时捕获当前上下文，并且在这个上下文中调用回调函数。这意味着，如果在 UI 线程中创建了 Progress<T>，就能在 Progress<T> 的回调函数中更新 UI，

即使异步方法是在后台线程中调用 Report 的。

四 等待一组Task完成

如果需要执行几个Task，等待他们全部完成，可以使用Task.WhenAll方法。

//创建一个任务，该任务将在数组中的所有 Task 对象都已完成时完成。
public static Task WhenAll(params Task[] tasks);

下示简单例子：

Task task1 = Task.Delay(TimeSpan.FromSeconds(1));
Task task2 = Task.Delay(TimeSpan.FromSeconds(2));
Task task3 = Task.Delay(TimeSpan.FromSeconds(1));
await Task.WhenAll(task1, task2, task3);

如果所有任务的结果类型相同，并且全部成功地完成，则 Task.WhenAll 返回存有每个任务执行结果的数组：

Task task1 = Task.FromResult(3);
Task task2 = Task.FromResult(5);
Task task3 = Task.FromResult(7);
int[] results = await Task.WhenAll(task1, task2, task3);
// "results" 含有 { 3, 5, 7 }

Task.WhenAll 方法有以 IEnumerable 类型作为参数的重载，但最好不要使用。只要异步代码与 LINQ 结合，显式的“具体化”序列（即对序列求值，创建集合）就会使代码更清晰：

static async Task<string> DownloadAllAsync(IEnumerable<string> urls)
{
    var httpClient = new HttpClient();
    // 定义每一个 url 的使用方法。
    var downloads = urls.Select(url => httpClient.GetStringAsync(url));
    // 注意，到这里，序列还没有求值，所以所有任务都还没真正启动。
    // 下面，所有的 URL 下载同步开始。
    Task<string>[] downloadTasks = downloads.ToArray();
    // 到这里，所有的任务已经开始执行了。
    // 用异步方式等待所有下载完成。
    string[] htmlPages = await Task.WhenAll(downloadTasks);
    return string.Concat(htmlPages);
}

如果有一个任务抛出异常，则 Task.WhenAll 会出错，并把这个异常放在返回的 Task 中。如果多个任务抛出异常，则这些异常都会放在返回的 Task 中。

但是，如果这个 Task 在被await 调用，就只会抛出其中的一个异常。如果要得到每个异常，可以检查 Task.WhenALl返回的 Task 的 Exception 属性：

static async Task ThrowNotImplementedExceptionAsync()
{
    throw new NotImplementedException();
}
static async Task ThrowInvalidOperationExceptionAsync()
{
    throw new InvalidOperationException();
}
static async Task ObserveOneExceptionAsync()
{
    var task1 = ThrowNotImplementedExceptionAsync();
    var task2 = ThrowInvalidOperationExceptionAsync();
    try
    {
        await Task.WhenAll(task1, task2);
    }
    catch (Exception ex)
    {
        // ex 要么是 NotImplementedException，要么是 InvalidOperationException
    }
}

static async Task ObserveAllExceptionsAsync()
{
    var task1 = ThrowNotImplementedExceptionAsync();
    var task2 = ThrowInvalidOperationExceptionAsync();
    Task allTasks = Task.WhenAll(task1, task2);
    try
    {
        await allTasks;
    }
    catch
    {
        //如果要得到每个异常，可以检查 Task.WhenALl返回的 Task 的 Exception 属性：
        AggregateException allExceptions = allTasks.Exception;
    }
}

五 等待任意一个Task完成

若需要执行若干个任务，只需要对其中任意一个的完成进行响应。如：对一个操作进行多种独立的尝试，只要一个尝试完成，任务就算完成。

可以使用Task.WhenAny方法，该方法的参数是一批任务，当其中任意一个任务完成时就会返回。作为返回结果的 Task 对象，就是那个完成的任务，即表示提供的任务之一已完成的任务。

public static Task<Task> WhenAny(params Task[] tasks);

下示简单例子：

// 返回第一个响应的 URL 的数据长度。
private static async Task<int> FirstRespondingUrlAsync(string urlA, string urlB)
{
    var httpClient = new HttpClient();
    // 并发地开始两个下载任务。
    Task<byte[]> downloadTaskA = httpClient.GetByteArrayAsync(urlA);
    Task<byte[]> downloadTaskB = httpClient.GetByteArrayAsync(urlB);
    // 等待任意一个任务完成。
    Task<byte[]> completedTask =
    await Task.WhenAny(downloadTaskA, downloadTaskB);
    // 返回从 URL 得到的数据的长度。
    byte[] data = await completedTask;
    return data.Length;
}

注意，返回的任务将在提供的任何任务完成时完成。

返回的任务将始终以 RanToCompletion 状态结束，其 Result 设置为完成的第一个任务。 即使第一个完成的任务以或Faulted状态结束Canceled，也是如此。

如果这个任务完成时有异常，这个异常也不会传递给Task.WhenAny 返回的 Task 对象。因此，通常需要在 Task 对象完成后继续使用 await。

注意，第一个任务完成后，考虑是否要取消剩下的任务。如果其他任务没有被取消，也没有被继续 await，那它们就处于被遗弃的状态。

被遗弃的任务会继续运行直到完成，它们的结果会被忽略，抛出的任何异常也会被忽略。

六 Task完成时的处理

如果正在 await 一批任务，希望在每个任务完成时对它做一些处理。另外，希望在任务一完成就立即进行处理，而不需要等待其他任务。

举个例子，下面的代码启动了 3 个延时任务，然后对每一个进行 await。

static async Task<int> DelayAndReturnAsync(int val)
{
    await Task.Delay(TimeSpan.FromSeconds(val));
    return val;
}
// 当前，此方法输出 2 3 1
// 我们希望它输出   1 2 3
static async Task ProcessTasksAsync()
{
    // 创建任务队列。
    Task<int> taskA = DelayAndReturnAsync(2);
    Task<int> taskB = DelayAndReturnAsync(3);
    Task<int> taskC = DelayAndReturnAsync(1);
    var tasks = new[] { taskA, taskB, taskC };
    // 按顺序 await 每个任务。
    foreach (var task in tasks)

    {
        var result = await task;
        Trace.WriteLine(result);
    }
}

虽然列表中的第二个任务是首先完成的，当前这段代码仍按列表的顺序对任务进行 await。

如果我们希望按任务完成的次序进行处理（例如 Trace.WriteLine），不必等待其他任务，可以考虑下面的方案：

static async Task AwaitAndProcessAsync(Task<int> task)
{
    var result = await task;
    Trace.WriteLine(result);
}

// 现在，这个方法输出 1 2 3
static async Task ProcessTasksAsync()
{
    // 创建任务队列。
    Task<int> taskA = DelayAndReturnAsync(2);
    Task<int> taskB = DelayAndReturnAsync(3);
    Task<int> taskC = DelayAndReturnAsync(1);
    var tasks = new[] { taskA, taskB, taskC };
    var processingTasks = (from t in tasks
                           select AwaitAndProcessAsync(t)).ToArray();
    // 等待全部处理过程的完成。
    await Task.WhenAll(processingTasks);
}

上面的代码也可以这么写：

static async Task ProcessTasksAsync()
{
    Task<int> taskA = DelayAndReturnAsync(2);
    Task<int> taskB = DelayAndReturnAsync(3);
    Task<int> taskC = DelayAndReturnAsync(1);
    var tasks = new[] { taskA, taskB, taskC };
    var processingTasks = tasks.Select(async t =>
    {
        var result = await t;
        Trace.WriteLine(result);
    }).ToArray();

    await Task.WhenAll(processingTasks);
}

重构后的代码是解决本问题较清晰、可移植性较好的方法。不过它与原始代码有一个细微的区别。重构后的代码并发地执行处理过程，而原始代码是一个接着一个地处理。

七 避免上下文延续

在默认情况下，一个 async 方法在被 await 调用后恢复运行时，会在原来的上下文中运行。

如果是 UI 上下文，并且有大量的 async 方法在 UI 上下文中恢复，就会引起性能上的问题。

为了避免在上下文中恢复运行，可调用 ConfigureAwait 方法，将其参数continueOnCapturedContext 设为 false来解决：

async Task ResumeOnContextAsync()
{
    await Task.Delay(TimeSpan.FromSeconds(1));
    // 这个方法在同一个上下文中恢复运行。
}
async Task ResumeWithoutContextAsync()
{
    await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
    // 这个方法在恢复运行时，会丢弃上下文。
}

八 处理 async Task 方法的异常

可以用简单的 try/catch 来捕获异常，和同步代码使用的方法一样：

static async Task ThrowExceptionAsync()
{
    await Task.Delay(TimeSpan.FromSeconds(1));
    throw new InvalidOperationException("Test");
}

static async Task TestAsync()
{
    // 抛出异常并将其存储在 Task 中。
    Task task = ThrowExceptionAsync();
    try
    {
        // Task 对象被 await 调用，异常在这里再次被引发。
        await task;
    }
    catch (InvalidOperationException)
    {
        // 这里，异常被正确地捕获。
    }
}

关于 asnyc void 方法抛出的异常处理，没什么好的方法，如果可以的话，方法的返回类型不要用 void，把它改为 Task。

最好不要从 async void 方法抛出异常。如果必须使用 async void 方法，可考虑把所有代码放在 try 块中，直接处理异常。

以上。