C#中使用迭代器等待任务的操作是怎样的
这篇文章将为大家详细讲解有关C# 中使用迭代器等待任务的操作方法,文章内容质量较高,因此小编分享给大家做个参考,希望大家阅读完这篇文章后对相关知识有一定的了解。
创新互联建站-专业网站定制、快速模板网站建设、高性价比古蔺网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式古蔺网站制作公司更省心,省钱,快速模板网站建设找我们,业务覆盖古蔺地区。费用合理售后完善,十载实体公司更值得信赖。
可能你已经阅读 C#5 关于 async 和 await 关键字以及它们如何帮助简化异步编程的,可惜的是在升级VS2010后短短两年时间,任然没有准备好升级到VS2012,在VS2010和C#4中不能使用异步关键字,你可能会想 “如果我能在VS 2010中写看起来同步的方法,但异步执行.我的代码会更清晰.”
我们必须承认,async 和 await 是非常好的语法糖,我们的方法需要编写更多的"AsyncResultcallback"方法适应这种变化.而当你终于升级到VS2012(或以后),这将是一件微不足道的小事,用C#关键字替换这个方法,只要简单的语法变化,而不是一个艰苦的结构重写。
概要
async/await 是基于异步任务模式的关键字。鉴于 此处已经有了非常完备的文档描述,这里我就不再加以说明。但必须指出的是,TAP简直帅到极点了!通过它你可以创建大量的将在未来某时间完成的小型单元工作(任务);任务可以启动其他的(嵌套)任务 并且/或者 建立一些仅当前置任务完成后才会启动的后续任务。前置与后续任务则可以链接为一对多或是多对一的关系。当内嵌任务完成时,父级任务无需与线程(重量级资源!)相绑定。执行任务时也不必再担心线程的时序安排,只需作出一些小小提示,框架将会自动为你处理这些事情。当程序开始运行,所有的任务将如溪流汇入大海般各自走向终点,又像柏青哥的小铁球一样相互反弹相互作用。
然而在C#4里面我们却没有async和await,不过缺少的也只是这一点点.Net5的新特性而已,这些新特性我们要么可以稍作回避,要么可以自己构建,关键的Task类型还是可用的。
在一个C#5的异步(async)方法里,你要等待一个Task。这不会导致线程等待;而是这个方法返回一个Task给它的调用者,这个Task能够等待(如果它自己是异步的)或者附上后续部分。(它同样能在任务中或它的结果中调用Wait(),但这会和线程耦合,所以避免那样做。)当等待的任务成功完成,你的异步方法会在它中断的地方继续运行。
也许你会知道,C#5的编译器会重写它的异步方法为一个生成的实现了状态机的嵌套类。C#正好还有一个特征(从2.0开始):迭代器(yield return 的方式)。这里的方法是使用一个迭代器方法在C#4中建造状态机,返回一系列在全部处理过程中的等待步骤的Task。我们可以编写一个方法接收一个从迭代器返回的任务的枚举,返回一个重载过的Task来代表全部序列的完成以及提供它的最终结果(如果有)。
最终目标
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); } }
对C#4,我们将分成两块:一个是相同访问能力的方法,另一个是私有方法,参数一样但返回类型不同。私有方法用迭代实现同样的处理,结果是一连串等待的任务(IEnumerable
相同访问能力(公用)方法返回与相应async方法一致的类型:void,Task,或者泛型Task
public static /*async*/ Task CopyToAsync( this Stream input, Stream output, CancellationToken cancellationToken = default(CancellationToken)) { return CopyToAsyncTasks(input, output, cancellationToken).ToTask(); } private static IEnumerableCopyToAsyncTasks( 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”(如startButton_ClickTasks)。如果异步方法返回void值,它仍然会调用ToTask()但不会返回Task。如果异步方法返回Task
public /*async*/ void DoSomethingAsync() { DoSomethingAsyncTasks().ToTask(); } public /*async*/ Task DoSomethingAsync() { return DoSomethingAsyncTasks().ToTask(); } public /*async*/ TaskDoSomethingAsync() { return DoSomethingAsyncTasks().ToTask (); }
成对的迭代器方法不会更复杂。当异步方法等待非通用的Task时,迭代器简单的将控制权转给它。当异步方法等待task结果时,迭代器将task保存在一个变量中,转到该方法,之后再使用它的返回值。两种情况在上面的CopyToAsyncTasks()例子里都有显示。
对包含通用resultTask
最后一件你需要知道的事情是如何处理中间返回的值。一个异步的方法可以从多重嵌套的块中返回;我们的迭代器简单的通过跳转到结尾来模仿它。
// C#5 public async TaskDoSomethingAsync() { 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: ; }
现在我们知道如何在C#4中写SLAM了,但是只有实现了FromResult
简单的开端
我们将在类System.Threading.Tasks.TaskEx下实现3个方法, 先从简单的那2个方法开始。FromResult()方法先创建了一个TaskCompletionSource(), 然后给它的result赋值,最后返回Task。
public static TaskFromResult (TResult resultValue) { var completionSource = new TaskCompletionSource (); completionSource.SetResult(resultValue); return completionSource.Task; }
很显然, 这2个ToTask()方法基本相同, 唯一的区别就是是否给返回对象Task的Result属性赋值. 通常我们不会去写2段相同的代码, 所以我们会用其中的一个方法来实现另一个。 我们经常使用泛型来作为返回结果集,那样我们不用在意返回值同时也可以避免在最后进行类型转换。 接下来我们先实现那个没有用泛型的方法。
private abstract class VoidResult { } public static Task ToTask(this IEnumerabletasks) { return ToTask (tasks); }
目前为止我们就剩下一个 ToTask
第一次天真的尝试
对于我们第一次尝试实现的方法,我们将枚举每个任务的Wait()来完成,然后将最终的任务做为结果(如果合适的话)。当然,我们不想占用当前线程,我们将另一个线程来执行循环该任务。
// BAD CODE ! public static TaskToTask (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; }
这里有一些好东西,事实上它真的有用,只要不触及用户界面:
它准确的返回了一个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,因此失去了那种可能。
是需要想点办法的时候了!
连续循环
最大的想法是直接从迭代器中获取其所产生的第一个任务。 我们创建了一个延续,使其在完成时能够检查任务的状态并且(如果成功的话)能接收下一个任务和创建另一个延续直至其结束。(如果没有,即迭代器没有需要完成的需求。)
// 很牛逼,但是我们还没有。 public static TaskToTask (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()) { // 设置最后任务返回的结果,直至无需结果为止。 tcs.SetResult( typeof(TResult) == typeof(VoidResult) ? default(TResult) : ((Task ) completedTask).Result); } else { taskEnumerator.Current.ContinueWith( t => ToTaskDoOneStep(taskEnumerator, taskScheduler, tcs, t), taskScheduler); } }
这里有许多值得分享的:
1.我们的后续部分(continuations)使用涉及SynchronizationContext的TaskScheduler,如果有的话。这使得我们的迭代器在UI线程初始化以后,立刻或者在一个继续点被调用,去访问UI控件。
2.进程不中断的运行,因此没有线程挂起等待!顺便说一下,在ToTaskDoOneStep()中对自身的调用不是递归调用;它是在taskEnumerator.Currenttask结束后调用的匿名函数,当前活动在调用ContinueWith()几乎立刻退出,它完全独立于后续部分。
3.此外,我们在继续点中验证每个嵌套task的状态,不是检查一个预测值。
然而,这儿至少有一个大问题和一些小一点的问题。
1.如果迭代器抛出一个未处理异常,或者抛出OperationCanceledException而取消,我们没有处理它或设置主task的状态。这是我们以前曾经做过的但在此版本丢失了。
2.为了修复问题1,我们不得不在两个方法中调用MoveNext()的地方引入同样的异常处理机制。即使是现在,两个方法中都有一样的后续部分建立。我们违背了“不要重复你自己”的信条
3.如果异步方法被期望给出一个结果,但是迭代器没有提供就退出了会怎么样呢?或者它最后的task是错误的类型呢?第一种情形下,我们默默返回默认的结果类型;第二种情形,我们抛出一个未处理的InvalidCastException,主task永远不会到达结束状态!我们的程序将永久的挂起
4.最后,如果一个嵌套的task取消或者发生错误呢?我们设置主task状态,再也不会调用迭代器。可能是在一个using块,或带有finally的try块的内部,并且有一些清理要做。我们应当遵守过程在中断的时候使它结束,而不要等垃圾收集器去做这些。我们怎么做到呢?当然通过一个后续部分!
为了解决这些问题,我们从ToTask()中移走MoveNext()调用,取而代之一个对ToTaskDoOneStep()的初始化的同步调用。然后我们将在一个提防增加合适的异常处理。
最终版本
这里是ToTask
public static TaskToTask (this IEnumerable tasks) { var taskScheduler = SynchronizationContext.Current == null ? TaskScheduler.Default : TaskScheduler.FromCurrentSynchronizationContext(); var taskEnumerator = tasks.GetEnumerator(); var completionSource = new TaskCompletionSource (); // Clean up the enumerator when the task completes. completionSource.Task.ContinueWith(t => taskEnumerator.Dispose(), taskScheduler); ToTaskDoOneStep(taskEnumerator, taskScheduler, completionSource, null); return completionSource.Task; } private static void ToTaskDoOneStep ( IEnumerator taskEnumerator, TaskScheduler taskScheduler, TaskCompletionSource completionSource, Task completedTask) { // Check status of previous nested task (if any), and stop if Canceled or Faulted. TaskStatus status; if (completedTask == null) { // This is the first task from the iterator; skip status check. } else if ((status = completedTask.Status) == TaskStatus.Canceled) { completionSource.SetCanceled(); return; } else if (status == TaskStatus.Faulted) { completionSource.SetException(completedTask.Exception); return; } // Find the next Task in the iterator; handle cancellation and other exceptions. Boolean haveMore; try { haveMore = taskEnumerator.MoveNext(); } catch (OperationCanceledException cancExc) { completionSource.SetCanceled(); return; } catch (Exception exc) { completionSource.SetException(exc); return; } if (!haveMore) { // No more tasks; set the result (if any) from the last completed task (if any). // We know it's not Canceled or Faulted because we checked at the start of this method. if (typeof(TResult) == typeof(VoidResult)) { // No result completionSource.SetResult(default(TResult)); } else if (!(completedTask is Task )) { // Wrong result completionSource.SetException(new InvalidOperationException( "Asynchronous iterator " + taskEnumerator + " requires a final result task of type " + typeof(Task ).FullName + (completedTask == null ? ", but none was provided." : "; the actual task type was " + completedTask.GetType().FullName))); } else { completionSource.SetResult(((Task ) completedTask).Result); } } else { // When the nested task completes, continue by performing this function again. taskEnumerator.Current.ContinueWith( nextTask => ToTaskDoOneStep(taskEnumerator, taskScheduler, completionSource, nextTask), taskScheduler); } }
瞧! 现在你会在Visual Studio 2010中用没有async和await的 C#4 (或 VB10)写SLAMs(看起来同步的方法,但异步执行)。
关于C# 中使用迭代器等待任务的操作方法就分享到这里了,希望以上内容可以对大家有一定的帮助,可以学到更多知识。如果觉得文章不错,可以把它分享出去让更多的人看到。
新闻名称:C#中使用迭代器等待任务的操作是怎样的
当前地址:http://scyanting.com/article/igsdss.html