DIV CSS 佈局教程網

在 C# 4 中用迭代器實作類似 async/await 的等待流程
編輯:JavaScript基礎知識     

緣起

C# 5 的 async 與 await 極大地簡化了非同步程式設計。但若你因為種種原因仍停留在 Visual Studio 2010 與 C# 4,就無法使用這兩個關鍵字。那時心裡大概會浮現一個念頭:如果我能寫出「看起來同步、實際非同步」的方法,程式碼會清楚多少。

本文要示範的正是這件事。我們將打造一小段基礎結構,讓 C# 4 也能寫出這種風格的方法。必須承認,async/await 是很棒的語法糖,我們這裡得手工撰寫更多類似 AsyncCallback 的銜接程式;但未來升級到新版本時,替換的成本極低——只是語法層面的調整,而非結構性的重寫。

概要:async/await 背後的 Task

async/await 建立在非同步任務模式(TAP)之上。透過 TAP,你可以建立大量將來才會完成的小型工作單元(任務);任務可以啟動其他巢狀任務,也可以掛上只在前置任務完成後才執行的後續任務。前置與後續之間可為一對多或多對一。當巢狀任務完成時,父任務不必與執行緒這種重量級資源綁定,也不必操心時序安排——框架會替你處理。

不幸的是,C# 4 沒有 async 與 await;但缺的僅是這層語法,關鍵的 Task 型別仍然可用。

在 C# 5 的非同步方法中,你 await 一個 Task。這不會讓執行緒進入等待;而是方法把一個 Task 交回呼叫者,由對方決定要等待還是掛上後續。當被等待的任務成功完成,你的方法會從中斷處繼續執行。

關鍵洞察在於:C# 5 編譯器會把非同步方法重寫為一個實作狀態機的巢狀類別。而 C# 從 2.0 起就有另一個能產生狀態機的特徵——迭代器(yield return)。於是我們可以用迭代器方法在 C# 4 中打造狀態機,讓它回傳一序列代表各個等待步驟的 Task;再寫一個方法接收這個列舉,回傳一個代表整體完成(並提供最終結果)的 Task。

最終目標

先確立目標。假設我們要在 C# 5 中實作 Stream.CopyToAsync()(並假設框架尚未內建),寫法如下:

public static async Task CopyToAsync(
    this Stream input,
    Stream output,
    CancellationToken cancellationToken = default(CancellationToken))
{
    byte[] buffer = new byte[0x1000]; // 4 KiB
    while (true)
    {
        cancellationToken.ThrowIfCancellationRequested();
        int bytesRead = await input.ReadAsync(buffer, 0, buffer.Length);
        if (bytesRead == 0) break;
        cancellationToken.ThrowIfCancellationRequested();
        await output.WriteAsync(buffer, 0, bytesRead);
    }
}

對 C# 4,我們把它拆成兩塊:一個對外、簽名相同的公用方法,還有一個私有方法——參數一致但回傳 IEnumerable<Task>,以迭代器逐步產出等待中的任務。序列中的任務可以是無泛型或各種泛型形式的任意組合(所幸 Task<T> 是 Task 的子類別)。

公用方法的回傳型別與原 async 版本一致(void、Task 或 Task<T>),並透過擴充方法把私有迭代器轉為對應的 Task:

public static /*async*/ Task CopyToAsync(
    this Stream input,
    Stream output,
    CancellationToken cancellationToken = default(CancellationToken))
{
    return CopyToAsyncTasks(input, output, cancellationToken).ToTask();
}

private static IEnumerable<Task> CopyToAsyncTasks(
    Stream input, Stream output, CancellationToken cancellationToken)
{
    byte[] buffer = new byte[0x1000]; // 4 KiB
    while (true)
    {
        cancellationToken.ThrowIfCancellationRequested();
        var bytesReadTask = input.ReadAsync(buffer, 0, buffer.Length);
        yield return bytesReadTask;
        if (bytesReadTask.Result == 0) break;
        cancellationToken.ThrowIfCancellationRequested();
        yield return output.WriteAsync(buffer, 0, bytesReadTask.Result);
    }
}

命名慣例是:非同步方法以 "Async" 結尾(事件處理器如 startButton_Click 例外),對應的迭代器則加上 "Tasks" 後綴。三種回傳型別的對應寫法如下:

public /*async*/ void DoSomethingAsync()
{
    DoSomethingAsyncTasks().ToTask();
}

public /*async*/ Task DoSomethingAsync()
{
    return DoSomethingAsyncTasks().ToTask();
}

public /*async*/ Task<String> DoSomethingAsync()
{
    return DoSomethingAsyncTasks().ToTask<String>();
}

成對的迭代器並不更複雜:當原方法等待無泛型 Task 時,迭代器直接把控制權交給它;當需要 Task 的結果時,迭代器先把 Task 存進變數、切到該方法,之後再取其回傳值。CopyToAsyncTasks() 兩種情況都示範了。

若 SLAM 最終要回傳 Task<X>,ToTask<X>() 會負責把最後一個 Task 轉為該型別以取出結果。若迭代器只是要打包一個中間計算值,.NET 5 提供了方便的靜態方法,.NET 4 則需自行以 TaskEx.FromResult<T>(value) 實作。

最後,非同步方法可以從多層巢狀區塊中返回,我們的迭代器靠跳躍到尾端來模擬:

// C# 5
public async Task<String> DoSomethingAsync()
{
    while (…) {
        foreach (…) {
            return "Result";
        }
    }
}

// C# 4:DoSomethingAsync() 是必要的,此處省略
private IEnumerable<Task> DoSomethingAsyncTasks()
{
    while (…) {
        foreach (…) {
            yield return TaskEx.FromResult("Result");
            goto END;
        }
    }
END: ;
}

簡單的開端

我們在 System.Threading.Tasks.TaskEx 下實作三個方法,先從兩個較簡單的開始。FromResult() 先建立一個 TaskCompletionSource,設定結果後回傳其 Task:

public static Task<TResult> FromResult<TResult>(TResult resultValue)
{
    var completionSource = new TaskCompletionSource<TResult>();
    completionSource.SetResult(resultValue);
    return completionSource.Task;
}

兩個 ToTask() 幾乎相同,唯一差別是要不要為回傳的 Task 設定 Result。既然不想寫兩段重複程式,就用其中一個實作另一個。我們常用泛型作為回傳型別,如此既能容納「無回傳值」的情況,也免得最後再做型別轉換。因此先實作非泛型版本:

private abstract class VoidResult { }

public static Task ToTask(this IEnumerable<Task> tasks)
{
    return ToTask<VoidResult>(tasks);
}

到目前為止,只剩 ToTask<T>() 尚未實作。

第一次天真的嘗試

最直覺的做法是枚舉每個任務並呼叫 Wait(),最後把末位任務作為結果。既然不想佔用目前的執行緒,就用另一條執行緒跑這個迴圈:

// 錯誤示範
public static Task<TResult> ToTask<TResult>(this IEnumerable<Task> tasks)
{
    var tcs = new TaskCompletionSource<TResult>();
    Task.Factory.StartNew(() => {
        Task last = null;
        try {
            foreach (var task in tasks) {
                last = task;
                task.Wait();
            }
            // 以最後一個任務的結果作為最終結果,除非不需要結果
            tcs.SetResult(
                last == null || typeof(TResult) == typeof(VoidResult)
                    ? default(TResult)
                    : ((Task<TResult>) last).Result);
        }
        catch (AggregateException aggrEx) {
            // Wait() 拋出的例外會被包進 Aggregate,需拆開
            if (aggrEx.InnerExceptions.Count != 1)
                tcs.SetException(aggrEx);
            else if (aggrEx.InnerException is OperationCanceledException)
                tcs.SetCanceled();
            else
                tcs.SetException(aggrEx.InnerException);
        }
        catch (OperationCanceledException) {
            tcs.SetCanceled();
        }
        catch (Exception ex) {
            tcs.SetException(ex);
        }
    });
    return tcs.Task;
}

這段程式碼有幾個可取之處,而且只要不碰使用者介面,它真的能用:

  • 它確實回傳一個由 TaskCompletionSource 產生、並正確設定完成狀態的 Task。
  • 它示範了如何從迭代器的最後一個任務取出最終 Result,同時避開「根本沒有結果」的情形。
  • 它會擷取迭代器拋出的例外並相應設定 Canceled 或 Faulted 狀態,同時傳遞被枚舉任務的狀態。

但有幾個嚴重問題:

  • 迭代器之所以需要「非同步」的承諾,是因為它可能從 UI 執行緒啟動,之後要能存取 UI 控制項。而這裡的 foreach 迴圈跑在背景,從那一刻起就別想再碰 UI 了——這個寫法完全沒有考慮 SynchronizationContext。
  • 即使不涉及 UI 也有麻煩。看看迴圈裡的 Wait():等待巢狀任務時可能會掛上一條執行緒很長一段時間。若要建立大量並行的 SLAM,很快他就會面臨執行緒池耗盡。
  • 這種拆開 AggregateException 的做法並不自然。我們真正需要的是擷取並傳遞完成狀態,而不是拋出例外。
  • 有時 SLAM 能立刻決定完成狀態,C# 5 的 async 在這種情況下可以完全非同步且有效率地處理;而這裡我們總是排入一個背景任務,白白喪失了這個優勢。

連續循環

核心想法是:直接從迭代器取得它產生的第一個任務,建立一個 continuation,讓它在完成時檢查狀態,若成功則取出下一個任務並再建立一個 continuation,直到序列結束。這樣就完全不需要任何執行緒等待。

// 不錯,但還不夠好
public static Task<TResult> ToTask<TResult>(this IEnumerable<Task> tasks)
{
    var taskScheduler = SynchronizationContext.Current == null
        ? TaskScheduler.Default
        : TaskScheduler.FromCurrentSynchronizationContext();

    var tcs = new TaskCompletionSource<TResult>();
    var taskEnumerator = tasks.GetEnumerator();

    if (!taskEnumerator.MoveNext()) {
        tcs.SetResult(default(TResult));
        return tcs.Task;
    }

    taskEnumerator.Current.ContinueWith(
        t => ToTaskDoOneStep(taskEnumerator, taskScheduler, tcs, t),
        taskScheduler);

    return tcs.Task;
}

private static void ToTaskDoOneStep<TResult>(
    IEnumerator<Task> taskEnumerator,
    TaskScheduler taskScheduler,
    TaskCompletionSource<TResult> tcs,
    Task completedTask)
{
    var status = completedTask.Status;
    if (status == TaskStatus.Canceled) {
        tcs.SetCanceled();
    } else if (status == TaskStatus.Faulted) {
        tcs.SetException(completedTask.Exception);
    } else if (!taskEnumerator.MoveNext()) {
        // 以最後一個任務的結果作為最終結果,除非不需要結果
        tcs.SetResult(
            typeof(TResult) == typeof(VoidResult)
                ? default(TResult)
                : ((Task<TResult>) completedTask).Result);
    } else {
        taskEnumerator.Current.ContinueWith(
            t => ToTaskDoOneStep(taskEnumerator, taskScheduler, tcs, t),
            taskScheduler);
    }
}

這版有幾個亮點:

  • continuation 使用(若有)伴隨 SynchronizationContext 的 TaskScheduler。如此一來,即便迭代器是在 UI 執行緒啟動的,後續步驟仍能在 UI 執行緒上執行,得以安全存取控制項。
  • 整個流程不中斷,因此沒有執行緒被掛起等待。ToTaskDoOneStep() 對自身的呼叫也不是遞迴——它是註冊在 taskEnumerator.Current 完成後才執行的匿名函數,而 ContinueWith() 呼叫後當下的活動幾乎立刻返回,與後續步驟完全獨立。
  • 我們在每個 continuation 中驗證各個巢狀任務的實際狀態,而非依賴預測值。

但仍有一個大問題與幾個小問題:

  • 若迭代器拋出未處理的例外,或拋出 OperationCanceledException 表達取消,我們沒有處理它,也沒有設定主任務的狀態。這個能力在上一版有,這一版卻弄丟了。
  • 為了解決上述問題,我們得在兩處呼叫 MoveNext() 的地方都加上同樣的例外處理。而且兩個方法裡都有相同的 continuation 建立程式。這違反了「不要重複自己」的原則。
  • 若非同步方法預期要給出結果,但迭代器沒提供就結束了,會怎樣?或者最後一個任務的型別不對呢?前者我們默默回傳預設值;後者會拋出一個未處理的 InvalidCastException,主任務永遠不會到達完成狀態,程式就此永久掛起。
  • 若某個巢狀任務被取消或發生錯誤,我們設定主任務狀態後就不再呼叫迭代器了。萬一它正身處 using 區塊或帶有 finally 的 try 區塊中,還有清理工作要做。我們應該在流程中斷時把它收尾,而不是等垃圾回收。這該怎麼做?當然也是靠一個 continuation。

解法是:把 MoveNext() 的呼叫從 ToTask() 移走,改為同步呼叫一次 ToTaskDoOneStep() 作為初始化,並在合適的位置補上例外處理。

最終版本

以下是 ToTask<T>() 的最終實作。它以 TaskCompletionSource 回傳主任務,永遠不造成執行緒等待,若有 SynchronizationContext 也會加以尊重;例外由迭代器處理,巢狀任務的完成狀態直接傳遞(而非包成 AggregateException);必要時回傳值給主任務;當預期有結果但迭代器沒以正確的 Task<T> 結束時,拋出友善的錯誤訊息。

public static Task<TResult> ToTask<TResult>(this IEnumerable<Task> tasks)
{
    var taskScheduler = SynchronizationContext.Current == null
        ? TaskScheduler.Default
        : TaskScheduler.FromCurrentSynchronizationContext();

    var taskEnumerator = tasks.GetEnumerator();
    var completionSource = new TaskCompletionSource<TResult>();

    // 任務完成時順手清理列舉器
    completionSource.Task.ContinueWith(t => taskEnumerator.Dispose(), taskScheduler);

    ToTaskDoOneStep(taskEnumerator, taskScheduler, completionSource, null);
    return completionSource.Task;
}

private static void ToTaskDoOneStep<TResult>(
    IEnumerator<Task> taskEnumerator,
    TaskScheduler taskScheduler,
    TaskCompletionSource<TResult> completionSource,
    Task completedTask)
{
    // 檢查上一個巢狀任務的狀態(若有),已取消或出錯則停止
    TaskStatus status;
    if (completedTask == null) {
        // 這是迭代器產生的第一個任務,略過狀態檢查
    } else if ((status = completedTask.Status) == TaskStatus.Canceled) {
        completionSource.SetCanceled();
        return;
    } else if (status == TaskStatus.Faulted) {
        completionSource.SetException(completedTask.Exception);
        return;
    }

    // 取得迭代器中的下一個任務,處理取消與其他例外
    Boolean haveMore;
    try {
        haveMore = taskEnumerator.MoveNext();
    } catch (OperationCanceledException) {
        completionSource.SetCanceled();
        return;
    } catch (Exception exc) {
        completionSource.SetException(exc);
        return;
    }

    if (!haveMore) {
        // 沒有更多任務了。以最後一個已完成任務的結果作為結果(若有需要)。
        // 開頭已檢查過,因此它不會是 Canceled 或 Faulted。
        if (typeof(TResult) == typeof(VoidResult)) {
            // 不需要結果
            completionSource.SetResult(default(TResult));
        } else if (!(completedTask is Task<TResult>)) {
            // 結果型別不符
            completionSource.SetException(new InvalidOperationException(
                "Asynchronous iterator " + taskEnumerator +
                " requires a final result task of type " +
                typeof(Task<TResult>).FullName +
                (completedTask == null
                    ? ", but none was provided."
                    : "; the actual task type was " + completedTask.GetType().FullName)));
        } else {
            completionSource.SetResult(((Task<TResult>) completedTask).Result);
        }
    } else {
        // 巢狀任務完成後,再次執行本函數以繼續
        taskEnumerator.Current.ContinueWith(
            nextTask => ToTaskDoOneStep(taskEnumerator, taskScheduler, completionSource, nextTask),
            taskScheduler);
    }
}

如此一來,即便在 Visual Studio 2010 的 C# 4(或 VB10)環境中,你也能寫出「看起來同步、實際非同步」的方法了。

一些補充

在定稿之前,我一直有把 CancellationToken 傳進 ToTask() 並沿 continuation 一路傳遞(與本文主題無關,故已移除,有興趣可參考範例原始碼中的註解痕跡)。這麼做有兩個理由。

其一,處理 OperationCanceledException 時,我會檢查它的 CancellationToken 是否與本操作相符;若不符,就以錯誤而非取消來呈現。技術上沒問題,但取消權杖在傳遞過程中容易被無關資訊混淆,反而使問題複雜化,因此並不划算。

其二,我原本會在每次呼叫迭代器的 MoveNext() 之前檢查權杖是否已取消,讓主任務能立即取消、無須依賴迭代器自行檢查。我並不認為這是正確做法——在 yield return 處取消一個非同步流程並不合適,取消行為理應完全交由迭代器流程掌控——但仍想試試看。結果它行不通:某些情況下任務被取消了,後續步驟卻沒有觸發,導致程式結束後按鈕仍停在不可用狀態。範例原始碼中保留了註解掉的取消檢測,有興趣可以自行測試。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved