異步編程基礎

>>返回《C# 並發編程》

• 1. 概述
• 2. 報告進度
• 3. 等待一組任務完成
• 4. 異常處理
• 5. 等待任意一個任務完成
• 6. 避免上下文延續
• 7. async void

1. 概述

前面的文章介紹了標識了 async 和 await 的代碼，是怎么被線程執行的。

>>同步上下文-7.5 異步編程(Async)

下面介紹一些類庫和常用的API。

2. 報告進度

使用 IProgress<T> 和 Progress<T> 類型

1. 構造 Progress<T> 實例時捕獲當前 同步上下文 實例；
2. Progress<T> 實例的ProgressChanged 事件被調用時使用上面捕獲的同步上下文；
3. 如果在執行構造函數的線程沒有同步上下文時（隱含使用的Default同步上下文），則將在 ThreadPool 中調用事件

static async Task DoProgressAsync(int count, IProgress<int> progress = null)
{
    for (int i = 0; i < count; i++)
    {
        await Task.Delay(200);
        if (progress != null)
            progress.Report(i + 1);
    }
}

static async Task CallProgressAsync()
{
    int count = 5;
    var progress = new Progress<int>();
    progress.ProgressChanged += (sender, args) =>
    {
        System.Console.WriteLine($"{args}/{count}");
    };
    await DoProgressAsync(count, progress);
}

輸出為:

1/5
2/5
3/5
4/5
5/5

3. 等待一組任務完成

Task.WhenAll 方法有以 IEnumerable 類型作為參數的重載，但建議大家不要使用。

• 調用 ToList 或 ToArray 方法后，序列中沒有啟動的任務就開始了

static async Task DownloadAllAsync()
{
    Stopwatch sw = new Stopwatch();
    sw.Start();
    IEnumerable<string> urls = new string[]{
                "https://www.baidu.com/",
                "https://cn.bing.com/"
            };
    var httpClient = new HttpClient();
    // 定義每一個 url 的使用方法。
    var downloads = urls.Select(url =>
    {
        Console.WriteLine($"{url}:start");
        var res = httpClient.GetStringAsync(url);
        res.ContinueWith(t => Console.WriteLine($"{url}:{sw.ElapsedMilliseconds}ms"));
        return res;
    });
    // 注意，到這里，序列還沒有求值，所以所有任務都還沒真正啟動。

    // 下面，所有的 URL 下載同步開始。
    Task<string>[] downloadTasks = downloads.ToArray();
    // 到這里，所有的任務已經開始執行了。
    Console.WriteLine($"await Task.WhenAll");
    // 用異步方式等待所有下載完成。
    string[] htmlPages = await Task.WhenAll(downloadTasks);

    Console.WriteLine($"jobs done.");
}

輸出為:

https://www.baidu.com/:start
https://cn.bing.com/:start
await Task.WhenAll
https://www.baidu.com/:270ms
jobs done.
; 由於返回的是請求的 Task 不是 ContinueWith 的打印 Task
https://cn.bing.com/:1089ms

4. 異常處理

• 如果有一個任務拋出異常，則 Task.WhenAll 會出錯，並把這個異常放在返回的 Task 中
• 如果多個任務拋出異常，則這些異常都會放在返回的 Task 中
• 如果這個 Task 在被 await 調用，就只會拋出該異步方法的一個異常
• 如果要得到每個異常，可以檢查 Task.WhenAll 返回的 Task 的 Exception 屬性:

示例：

static async Task ThrowNotImplementedExceptionAsync()
{
    await Task.Delay(10);
    throw new NotImplementedException();
}

static async Task<int> ThrowInvalidOperationExceptionAsync()
{
    TaskCompletionSource<int> completionSource = new TaskCompletionSource<int>();
    completionSource.TrySetException(new InvalidOperationException());
    return await completionSource.Task;
}
static async Task ObserveOneExceptionAsync()
{
    System.Console.WriteLine("OneException");
    var task1 = ThrowNotImplementedExceptionAsync();
    var task2 = ThrowInvalidOperationExceptionAsync();
    try
    {
        await Task.WhenAll(task1, task2);
    }
    catch (Exception ex)
    {
        // ex 要么是 NotImplementedException，要么是 InvalidOperationException
        System.Console.WriteLine(ex.GetType().Name);
    }
}
static async Task ObserveAllExceptionsAsync()
{
    System.Console.WriteLine("AllExceptions");
    var task1 = ThrowNotImplementedExceptionAsync();
    var task2 = ThrowInvalidOperationExceptionAsync();
    Task allTasks = Task.WhenAll(task1, task2);
    try
    {
        await allTasks;
    }
    catch
    {
        AggregateException allExceptions = allTasks.Exception;
        allExceptions.Handle(ex =>
        {
            System.Console.WriteLine(ex.GetType().Name);
            return true;
        });
    }
}

輸出為:

OneException
NotImplementedException

AllExceptions
NotImplementedException
InvalidOperationException

5. 等待任意一個任務完成

// 返回第一個響應的 URL 的數據長度。
private static async Task<int> FirstRespondingUrlAsync()
{
    string urlA = "https://www.baidu.com/";
    string urlB = "https://cn.bing.com/";

    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;
    Console.WriteLine($"Finish: {(completedTask == downloadTaskA ? nameof(downloadTaskA) : nameof(downloadTaskA))}");
    Console.WriteLine($"downloadTaskA: {downloadTaskA.Status}");
    Console.WriteLine($"downloadTaskB: {downloadTaskB.Status}");
    return data.Length;
}

輸出為:

Finish: downloadTaskA
downloadTaskA: RanToCompletion
downloadTaskB: WaitingForActivation

如果這個任務完成時有異常，這個異常也不會傳遞給 Task.WhenAny 返回的 Task 對象。因此，通常需要在 Task 對象完成后繼續使用 await。

第一個任務完成后，考慮是否要取消剩下的任務。如果其他任務沒有被取消，也沒有被繼續 await，那它們就處於被遺棄的狀態。被遺棄的任務會繼續運行直到完成，它們的結果會被忽略，拋出的任何異常也會被忽略。

//每個任務需要等到Trace.WriteLine執行完才能執行下一個
static async Task<int> DelayAndReturnAsync(int val)
{
    await Task.Delay(TimeSpan.FromSeconds(val));
    return val;
}
// 當前，此方法輸出“2”,“3”,“1”。 // 我們希望它先輸出先完成的，期望 輸出“1”,“2”,“3”。 
static async Task ProcessTasksAsync1()
{
    // 創建任務隊列。
    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;
        Console.WriteLine(result);
    }
}


//不等Trace.WriteLine切任務並行的解決方案
// 現在，這個方法輸出“1”,“2”,“3”。 
static async Task ProcessTasksAsync2()
{
    // 創建任務隊列。
    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;
        Console.WriteLine(result);
    }).ToArray();
    // 等待全部處理過程的完成。
    await Task.WhenAll(processingTasks);
}
static async Task ProcessTasksAsyncExe()
{
    Stopwatch sw = Stopwatch.StartNew();
    System.Console.WriteLine("ProcessTasksAsync1");
    await ProcessTasksAsync1();
    System.Console.WriteLine($"{sw.ElapsedMilliseconds}ms");
    sw.Restart();
    System.Console.WriteLine();
    System.Console.WriteLine("ProcessTasksAsync2");
    await ProcessTasksAsync2();
    System.Console.WriteLine($"{sw.ElapsedMilliseconds}ms");
}

輸出為:

ProcessTasksAsync1
2
3
1
3007ms

ProcessTasksAsync2
1
2
3
3004ms

6. 避免上下文延續

默認情況下，一個 async 方法在被 await 調用后恢復運行時，會在原來的上下文中運行。 如果是 UI上下文 ，並且有大量的 async 方法在 UI上下文 中恢復，就會引起性能上的問題。

• ConfigureAwait(true) 延續上下文（執行完異步 await ，回到同步上下文）
• ConfigureAwait(false) 不延續上下文（執行完異步 await ，由於沒有記錄之前的同步上下文，后續代碼在 Default上下文 中運行）

7. async void

處理 async void 方法的異常有一個辦法:

• 一個異常從 async void 方法中傳遞出來時，會在其同步上下文中引發出來
• 當async void方法啟動時，同步上下文 就處於激活狀態
  • 如果系統運行環境有特定的 同步上下文（如：UI同步上下文，ASP.Net同步上下文），通常就可以在全局范圍內處理這些頂層的異常
    • PF 有 Application.DispatcherUnhandledException，
    • WinRT 有 Application.UnhandledException
    • ASP.NET 有 Application_Error