C#中使用迭代器處理等待任務_基礎知識

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);
 }
}

public static /*async*/ Task CopyToAsync(
 this Stream input, Stream output,
 CancellationToken cancellationToken = default(CancellationToken))
{
 return CopyToAsyncTasks(input, output, cancellationToken).ToTask();
}
private static IEnumerable 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);
 }
}

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

// C#5
public async Task DoSomethingAsync() {
 while (…) {
 foreach (…) {
 return "Result";
 }
 }
}
 
// C#4; DoSomethingAsync() is necessary but omitted here.
private IEnumerable DoSomethingAsyncTasks() {
 while (…) {
 foreach (…) {
 yield return TaskEx.FromResult("Result");
 goto END;
 }
 }
END: ;
}

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

private abstract class VoidResult { }
 
public static Task ToTask(this IEnumerable tasks) {
 return ToTask(tasks);
}

// BAD CODE !
public static Task ToTask(this IEnumerable tasks)
{
 var tcs = new TaskCompletionSource();
 Task.Factory.StartNew(() => {
 Task last = null;
 try {
 foreach (var task in tasks) {
 last = task;
 task.Wait();
 }
 
 // Set the result from the last task returned, unless no result is requested.
 tcs.SetResult(
 last == null || typeof(TResult) == typeof(VoidResult)
 ? default(TResult) : ((Task) last).Result);
 
 } catch (AggregateException aggrEx) {
 // If task.Wait() threw an exception it will be wrapped in an Aggregate; unwrap it.
 if (aggrEx.InnerExceptions.Count != 1) tcs.SetException(aggrEx);
 else if (aggrEx.InnerException is OperationCanceledException) tcs.SetCanceled();
 else tcs.SetException(aggrEx.InnerException);
 } catch (OperationCanceledException cancEx) {
 tcs.SetCanceled();
 } catch (Exception ex) {
 tcs.SetException(ex);
 }
 });
 return tcs.Task;
}

// 很牛逼，但是我們還沒有。
public static Task ToTask(this IEnumerable tasks)
{
 var taskScheduler =
 SynchronizationContext.Current == null
 ? TaskScheduler.Default : TaskScheduler.FromCurrentSynchronizationContext();
 var tcs = new TaskCompletionSource();
 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(
 IEnumerator taskEnumerator, TaskScheduler taskScheduler,
 TaskCompletionSource 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()) {
 // 設置最后任務返回的結果，直至無需