C# 4 中使用迭代器的等待任务 已翻译 100%

oschina 投递于 2012/12/09 20:52 (共 15 段, 翻译完成于 03-14)
阅读 3195
收藏 37
C#
2
加载中

介绍

可能你已经阅读 C#5 关于 async 和 await 关键字以及它们如何帮助简化异步编程的,可惜的是在升级VS2010后短短两年时间,任然没有准备好升级到VS2012,在VS2010和C#4中不能使用异步关键字,你可能会想 “如果我能在VS 2010中看起来同步的方法,但异步执行.我的代码会更清晰.

看完这篇文章后,您将能够做到这一点。我们将开发一个小的基础结构代码,让我们写"看起来同步的方法,但异步执行"的方法,这个VS2012 异步关键字一样, 享受C#5的特性.

我们必须承认,async 和 await 是非常好的语法糖,我们的方法需要编写更多的"AsyncResultcallback"方法适应这种变化.而当你终于升级到VS2012(或以后),这将是一件微不足道的小事,用C#关键字替换这个方法,只要简单的语法变化,而不是一个艰苦的结构重写。

wangking873
wangking873
翻译于 2012/12/27 11:13
2

概要

async/await 是基于异步任务模式的关键字。鉴于 此处已经有了非常完备的文档描述,这里我就不再加以说明。但必须指出的是,TAP简直帅到极点了!通过它你可以创建大量的将在未来某时间完成的小型单元工作(任务);任务可以启动其他的(嵌套)任务 并且/或者 建立一些仅当前置任务完成后才会启动的后续任务。前置与后续任务则可以链接为一对多或是多对一的关系。当内嵌任务完成时,父级任务无需与线程(重量级资源!)相绑定。执行任务时也不必再担心线程的时序安排,只需作出一些小小提示,框架将会自动为你处理这些事情。当程序开始运行,所有的任务将如溪流汇入大海般各自走向终点,又像柏青哥的小铁球一样相互反弹相互作用。

然而在C#4里面我们却没有async和await,不过缺少的也只是这一点点.Net5的新特性而已,这些新特性我们要么可以稍作回避,要么可以自己构建,关键的Task类型还是可用的。

QiNark
QiNark
翻译于 2013/03/04 18:27
2

在一个C#5的异步(async)方法里,你要等待一个Task。这不会导致线程等待;而是这个方法返回一个Task给它的调用者,这个Task能够等待(如果它自己是异步的)或者附上后续部分。(它同样能在任务中或它的结果中调用Wait(),但这会和线程耦合,所以避免那样做。)当等待的任务成功完成,你的异步方法会在它中断的地方继续运行。

也许你会知道,C#5的编译器会重写它的异步方法为一个生成的实现了状态机的嵌套类。C#正好还有一个特征(从2.0开始):迭代器(yield return 的方式)。这里的方法是使用一个迭代器方法在C#4中建造状态机,返回一系列在全部处理过程中的等待步骤的Task。我们可以编写一个方法接收一个从迭代器返回的任务的枚举,返回一个重载过的Task来代表全部序列的完成以及提供它的最终结果(如果有)。

excepiton
excepiton
翻译于 2013/03/05 13:08
2

最终目标

Stephen Covey 建议我们目标有先后。这就是我们现在做的。已经有大量例子来告诉我们如何使用async/await来实现SLAMs(synchronous-looking asynchronous methods)。那么我们不使用这些关键字如何实现这个功能。我们来做一个C#5 async的例子,看看如何在C#4里实现它。然后我们讨论一下转换这些代码的一般方法。

下面的例子展示了我们在C#5里实现异步读写方法Stream.CopyToAsync()的一种写法。假设这个方法并没有在.NET5里实现。

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);
    }
}
dodola
dodola
翻译于 2013/01/12 10:31
2

对C#4,我们将分成两块:一个是相同访问能力的方法,另一个是私有方法,参数一样但返回类型不同。私有方法用迭代实现同样的处理,结果是一连串等待的任务(IEnumerable<Task>)。序列中的实际任务可以是非泛型或者不同类型泛型的任意组合。(幸运的是,泛型Task<T>类型是非泛型Task类型的子类型)

相同访问能力(公用)方法返回与相应async方法一致的类型:void,Task,或者泛型Task<T>。它将使用扩展方法调用私有迭代器并转化为Task或者Task<T>。

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);
    }
}
申江渔夫
申江渔夫
翻译于 2013/03/08 14:26
2

异步方法通常以"Async"结尾命名(除非它是事件处理器如startButton_Click)。给迭代器以同样的名字后跟“Tasks”(如startButton_ClickTasks)。如果异步方法返回void值,它仍然会调用ToTask()但不会返回Task。如果异步方法返回Task<X>,那么它就会调用通用的ToTask<X>()扩展方法。对应三种返回类型,异步可替代的方法像下面这样:

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()例子里都有显示。



super0555
super0555
翻译于 2013/03/08 18:25
1

对包含通用resultTask<X>的SLAM,迭代器必须将控制转交给确切的类型。ToTask<X>()将最终的task转换为那种类型以便提取其结果。经常的你的迭代器将计算来自中间task的结果数值,而且仅需要将其打包在Task<T>中。.NET 5为此提供了一个方便的静态方法。而.NET 4没有,所以我们用TaskEx.FromResult<T>(value)来实现它。

最后一件你需要知道的事情是如何处理中间返回的值。一个异步的方法可以从多重嵌套的块中返回;我们的迭代器简单的通过跳转到结尾来模仿它。

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

现在我们知道如何在C#4中写SLAM了,但是只有实现了FromResult<T>()和两个 ToTask()扩展方法才能真正的做到。下面我们开始做吧。

super0555
super0555
翻译于 2013/03/08 16:01
2

简单的开端

我们将在类System.Threading.Tasks.TaskEx下实现3个方法, 先从简单的那2个方法开始。FromResult()方法先创建了一个TaskCompletionSource(), 然后给它的result赋值,最后返回Task。

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

很显然, 这2个ToTask()方法基本相同, 唯一的区别就是是否给返回对象Task的Result属性赋值. 通常我们不会去写2段相同的代码, 所以我们会用其中的一个方法来实现另一个。 我们经常使用泛型来作为返回结果集,那样我们不用在意返回值同时也可以避免在最后进行类型转换。 接下来我们先实现那个没有用泛型的方法。

private abstract class VoidResult { }
 
public static Task ToTask(this IEnumerable<Task> tasks) {
    return ToTask<VoidResult>(tasks);
}
目前为止我们就剩下一个 ToTask<T>()方法还没有实现。
闹闹爷
闹闹爷
翻译于 2013/03/08 14:47
2

第一次天真的尝试

对于我们第一次尝试实现的方法,我们将枚举每个任务的Wait()来完成,然后将最终的任务做为结果(如果合适的话)。当然,我们不想占用当前线程,我们将另一个线程来执行循环任务

// BAD CODE !
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();
            }
 
            // Set the result from the last task returned, unless no result is requested.
            tcs.SetResult(
                last == null || typeof(TResult) == typeof(VoidResult)
                    ? default(TResult) : ((Task<TResult>) 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;
}
黎舜桀
黎舜桀
翻译于 2013/02/27 10:10
2

这里有一些好东西,事实上它真的有用,只要不触及用户界面:

它准确的返回了一个TaskCompletionSource的Task,并且通过源代码设置了完成状态。
  1. 它显示了我们怎么通过迭代器的最后一个任务设置task的最终Result,同时避免可能没有结果的情况。
  2. 它从迭代器中捕获异常并设置Canceled或Faulted状态. 它也传播枚举的task状态 (这里是通过Wait(),该方法可能抛出一个包装了cancellation或fault的异常的集合).

但这里有些主要的问题。最严重的是:

  1. 由于迭代器需要实现“异步态的”的诺言,当它从一个UI线程初始化以后,迭代器的方法将能访问UI控件。你能发现这里的foreach循环都是运行在后台;从那个时刻开始不要触摸UI!这种方法没有顾及SynchronizationContext。
  2.  在UI之外我们也有麻烦。我们可能想制造大量大量的由SLAM实现的并行运行的Tasks。但是看看循环中的Wait()!当等待一个嵌套task时,可能远程需要一个很长的时间完成,我们会挂起一个线程。我们面临线程池的线程资源枯竭的情况。
  3. 这种解包Aggregate异常的方法是不太自然的。我们需要捕获并传播它的完成状态而不抛出异常。
  4. 有时SLAM可以立刻决定它的完成状态。那种情形下,C#5的async可以异步并且有效的操作。这里我们总是计划了一个后台task,因此失去了那种可能。

是需要想点办法的时候了!

super0555
super0555
翻译于 2013/03/10 21:35
2
本文中的所有译文仅用于学习和交流目的,转载请务必注明文章译者、出处、和本文链接。
我们的翻译工作遵照 CC 协议,如果我们的工作有侵犯到您的权益,请及时联系我们。
加载中

评论(1)

Eriloan
Eriloan
这个思路不错。
返回顶部
顶部