C# 5 的 async 與 await 極大地簡化了非同步程式設計。但若你因為種種原因仍停留在 Visual Studio 2010 與 C# 4,就無法使用這兩個關鍵字。那時心裡大概會浮現一個念頭:如果我能寫出「看起來同步、實際非同步」的方法,程式碼會清楚多少。
本文要示範的正是這件事。我們將打造一小段基礎結構,讓 C# 4 也能寫出這種風格的方法。必須承認,async/await 是很棒的語法糖,我們這裡得手工撰寫更多類似 AsyncCallback 的銜接程式;但未來升級到新版本時,替換的成本極低——只是語法層面的調整,而非結構性的重寫。
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。但有幾個嚴重問題:
foreach 迴圈跑在背景,從那一刻起就別想再碰 UI 了——這個寫法完全沒有考慮 SynchronizationContext。Wait():等待巢狀任務時可能會掛上一條執行緒很長一段時間。若要建立大量並行的 SLAM,很快他就會面臨執行緒池耗盡。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);
}
}
這版有幾個亮點:
SynchronizationContext 的 TaskScheduler。如此一來,即便迭代器是在 UI 執行緒啟動的,後續步驟仍能在 UI 執行緒上執行,得以安全存取控制項。ToTaskDoOneStep() 對自身的呼叫也不是遞迴——它是註冊在 taskEnumerator.Current 完成後才執行的匿名函數,而 ContinueWith() 呼叫後當下的活動幾乎立刻返回,與後續步驟完全獨立。但仍有一個大問題與幾個小問題:
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 處取消一個非同步流程並不合適,取消行為理應完全交由迭代器流程掌控——但仍想試試看。結果它行不通:某些情況下任務被取消了,後續步驟卻沒有觸發,導致程式結束後按鈕仍停在不可用狀態。範例原始碼中保留了註解掉的取消檢測,有興趣可以自行測試。