传送门：异步编程系列目录……

最近我为大家陆续介绍了“IAsyncResult异步编程模型 (APM)”和“基于事件的异步编程模式(EAP)”两种异步编程模型。在.NET4.0 中Microsoft又为我们引入了新的异步编程模型“基于任务的异步编程模型(TAP)”，并且推荐我们在开发新的多线程应用程序中首选TAP，在.NET4.5中更是对TPL库进行了大量的优化与改进。那现在我先介绍下TAP具有哪些优势：

1. 目前版本(.NET4.X)的任务调度器(TaskScheduler)依赖于底层的线程池引擎。通过局部队列的任务内联化(task inlining)和工作窃取机制可以为我们提升程序性能。
2. 轻松实现任务等待、任务取消、延续任务、异常处理（System.AggregateException）、GUI线程操作。
3. 在任务启动后，可以随时以任务延续的形式注册回调。
4. 充分利用现有的线程，避免创建不必要的额外线程。
5. 结合C#5.0引入async和await关键字轻松实现“异步方法”。

示例源码：异步编程：.NET 4.5 基于任务的异步编程模型(TAP).rar

术语：

APM              异步编程模型，Asynchronous Programming Model

EAP               基于事件的异步编程模式，Event-based Asynchronous Pattern

TAP               基于任务的异步编程模式，Task-based Asynchronous Pattern

TPL                任务并行库，Task Parallel Library

理解CLR线程池引擎、理解全局队列、理解线程的局部队列及性能优势

1. CLR线程池引擎

CLR线程池引擎维护了一定数量的空闲工作线程以支持工作项的执行，并且能够重用已有的线程以避免创建新的不必要的线程所花费的昂贵的处理过程。并且使用爬山算法（hill-climbing algorithm）检测吞吐量，判断是否能够通过更多的线程来完成更多的工作项。这个算法的判断依据是工作项所需某些类型资源的可用情况，例如：CPU、网络带宽或其他。此外这个算法还会考虑一个饱和点，即达到饱和点的时候，创建更多地线程反而会降低吞吐量。（线程池的详细介绍请看《异步编程：使用线程池管理线程》）

目前版本的TAP的任务调度器（TaskScheduler）基于CLR线程池引擎实现。当任务调度器（TaskScheduler）开始分派任务时：

1)        在主线程或其他并没有分配给某个特定任务的线程的上下文中创建并启动的任务，这些任务将会在全局队列中竞争工作线程。这些任务被称为顶层任务。

2)        然而，如果是在其他任务的上下文中创建的任务（子任务或嵌套任务），这些任务将被分配在线程的局部队列中。

1. 线程池的全局队列

当调用ThreadPool.QueueUserWorkItem()添加工作项时，该工作项会被添加到线程池的全局队列中。线程池中的空闲线程以FIFO的顺序将工作项从全局队列中取出并执行，但并不能保证按某个指定的顺序完成。

线程的全局队列是共享资源，所以内部会实现一个锁机制。当一个任务内部会创建很多子任务时，并且这些子任务完成得非常快，就会造成频繁的进入全局队列和移出全局队列，从而降低应用程序的性能。基于此原因，线程池引擎为每个线程引入了局部队列。

1. 线程的局部队列为我们带来两个性能优势：任务内联化(task inlining)和工作窃取机制。

1)        任务内联化(task inlining)----活用顶层任务工作线程

我们用一个示例来说明：

结果：

分析：（目前内联机制只有出现在等待任务场景）

这个示例，我们从Main方法主线程中创建了一个headTask顶层任务并开启。在headTask任务中又创建了三个嵌套任务并最后WaitAll() 这三个嵌套任务执行完成(嵌套任务安排在局部队列)。此时出现的情况就是headTask任务的线程被阻塞，而“任务内联化”技术会使用阻塞的headTask的线程去执行局部队列中的任务。因为减少了对额外线程需求，从而提升了程序性能。

局部队列“通常”以LIFO的顺序抽取任务并执行，而不是像全局队列那样使用FIFO顺序。LIFO顺序通常用有利于数据局部性，能够在牺牲一些公平性的情况下提升性能。

2)        工作窃取机制----活用空闲工作线程

当一个工作线程的局部队列中有很多工作项正在等待时，而存在一些线程却保持空闲，这样会导致CPU资源的浪费。此时任务调度器（TaskScheduler）会让空闲的工作线程进入忙碌线程的局部队列中窃取一个等待的任务，并且执行这个任务。

由于局部队列为我们带来了性能提升，所以，我们应尽可能地使用TPL提供的服务（任务调度器（TaskScheduler）），而不是直接使用ThreadPool的方法。

任务并行Task

一个任务表示一个异步操作。任务运行的时候需要使用线程，但并不是说任务取代了线程，理解这点很重要。事实上，在《异步编程：.NET4.X 数据并行》中介绍的System.Threading.Tasks.Parallel类构造的并行逻辑内部都会创建Task，而它们的并行和并发执行都是由底层线程支持的。任务和线程之间也没有一对一的限制关系，通用语言运行时（CLR）会创建必要的线程来支持任务执行的需求。

1. Task简单的实例成员

分析：

1)        CancellationToken、IsCancel

对于长时间运行的计算限制操作来说，支持取消是一件很“棒”的事情。.NET 4.0提供了一个标准的取消操作模式。即通过使用CancellationTokenSource创建一个或多个取消标记CancellationToken（cancellationToken可在线程池中线程或 Task 对象之间实现协作取消），然后将此取消标记传递给应接收取消通知的任意数量的线程或Task对象。当调用CancellationToken关联的CancellationTokenSource对象的Cancle()时，每个取消标记(CancellationToken)上的IsCancellationRequested属性将返回true。异步操作中可以通过检查此属性做出任何适当响应。也可调用取消标记的ThrowIfCancellationRequested()方法来抛出OperationCanceledException异常。

更多关于CancellationToken与CancellationTokenSource的介绍及示例请看《协作式取消》….

       在Task任务中实现取消，可以使用以下几种选项之一终止操作：

1. i.              简单地从委托中返回。在许多情况下，这样已足够；但是，采用这种方式“取消”的任务实例会转换为RanToCompletion状态，而不是 Canceled 状态。
2. ii.              创建Task时传入CancellationToken标识参数，并调用关联CancellationTokenSource对象的Cancel()方法：

a)        如果Task还未开始，那么Task实例直接转为Canceled状态。（注意，因为已经Canceled状态了，所以不能再在后面调用Start()）

b)        （见示例：TaskOperations.Test_Cancel();）如果Task已经开始，在Task内部必须抛出OperationCanceledException异常（注意，只能存在OperationCanceledException异常，可优先考虑使用CancellationToken的ThrowIfCancellationRequested()方法），Task实例转为Canceled状态。

若对抛出OperationCanceledException异常且状态为Canceled的Task进行等待操作（如：Wait/WaitAll），则会在Catch块中捕获到OperationCanceledException异常，但是此异常指示Task成功取消，而不是有错误的情况。因此IsCancel为true；IsFaulted为false且Exception属性为null。

1. iii.              对于使用TaskContinuationOptions枚举值为NotOn或OnlyOn创建的延续任务A，在其前面的任务结束状态不匹配时，延续任务A将转换为Canceled状态，并且不会运行。

2)        TaskCreationOptions枚举

定义任务创建、调度和执行的一些可选行为。

3)        IsCompleted

Task实现了IAsyncResult接口。在任务处于以下三个最终状态之一时IsCompleted返回 true：RanToCompletion、 Faulted 或 Canceled。

4)        TaskStatus枚举

表示 Task 的生命周期中的当前阶段。一个Task实例只会完成其生命周期一次，即当Task到达它的三种可能的最终状态之一时，Task就结束并释放。

状态图如下：

5)        Dispose()

尽管Task为我们实现了IDisposable接口，但依然不推荐你主动调用Dispose()方法，而是由系统终结器进行清理。原因：

a)        Task调用Dispose()主要释放的资源是WaitHandle对象。

b)        .NET4.5 对.NET4.0 中提出的Task进行过大量的优化，让其尽量不再依赖WaitHandle对象（eg：.NET4.0种Task的WaitAll()/WaitAny()的实现依赖于WaitHandle）。

c)        在使用Task时，大多数情况下找不到一个好的释放点，保证该Task已经完成并且没有被其他地方在使用。

d)        Task.Dispose()方法在“.NET Metro风格应用程序”框架所引用的程序集中甚至并不存在（即此框架中Task没有实现IDisposable接口）。

更详细更专业的Dispose()讨论请看《.NET4.X并行任务Task需要释放吗？》…

1. Task的实例方法

分析：

1)        TaskContinuationOptions

在创建一个Task作为另一个Task的延续时，你可以指定一个TaskContinuationOptions参数，这个参数可以控制延续另一个任务的任务调度和执行的可选行为。

注意：

a)        如果使用默认选项TaskContinuationOptions.None，并且之前的任务被取消了，那么延续任务任然会被调度并启动执行。

b)        如果该条件在前面的任务准备调用延续时未得到满足，则延续将直接转换为 Canceled 状态，之后将无法启动。

c)        如果调用多任务延续（即：调用TaskFactory或TaskFactory<TResult>的静态ContinueWhenAll和ContinueWhenAny方法）时，NotOn和OnlyOn六个标识或标识的组合都是无效的。也就是说，无论先驱任务是如何完成的，ContinueWhenAll和ContinueWhenAny都会执行延续任务。

d)        TaskContinuationOptions.ExecuteSynchronously，指定同步执行延续任务。延续任务会使用前一个任务的数据，而保持在相同线程上执行就能快速访问高速缓存中的数据，从而提升性能。此外，也可避免调度这个延续任务产生不必要的额外线程开销。

如果在创建延续任务时已经完成前面的任务，则延续任务将在创建此延续任务的线程上运行。只应同步执行运行时间非常短的延续任务。

2)        开启任务

只有Task处于TaskStatus.Created状态时才能使用实例方法Start()。并且，只有在使用Task的公共构造函数构造的Task实例才能处于TaskStatus.Created状态。

当然我们还知道有其他方式可以创建Task并开启任务，比如Task.Run()/Task.ContinueWith()/Task.Factory.StartNew()/TaskCompletionSource/异步方法(即使用async与await关键字的方法)，但是这些方法返回的Task已经处于开启状态，即不能再调用Start()。更丰富更专业的讨论请看《.NET4.X 并行任务中Task.Start()的FAQ》…

3)        延续任务ContinueWith

a)        ContinueWith() 方法可创建一个根据TaskContinuationOptions参数限制的延续任务。可以为同一个Task定义多个延续任务让它们并行执行。

比如，为t1定义两个并行延续任务t2、t3.

b)        调用Wait()方法和Result属性会导致线程阻塞，极有可能造成线程池创建一个新线程，这增大了资源的消耗，并损害了伸缩性。可以在延续任务中访问这些成员，并做相应操作。

c)        对前面任务的引用将以参数形式传递给延续任务的用户委托，以将前面任务的数据传递到延续任务中。

4)        Wait()

一个线程调用Wait()方法时，系统会检查线程要等待的Task是否已开始执行。

a)        如果是，调用Wait()的线程会阻塞，直到Task运行结束为止。

b)        如果Task还没有开始执行，系统可能（取决于局部队列的内联机制）使用调用Wait()的线程来执行Task。如果发生这种情况，那么调用Wait()的线程不会阻塞；它会执行Task并立刻返回。

1. i.              这样做的好处在于，没有线程会被阻塞，所以减少了资源的使用（因为不需要创建一个线程来替代被阻塞的线程），并提升了性能（因为不需要花时间创建一个线程，也没有上下文切换）。
2. ii.              但不好的地方在于，假如线程在调用Wait()前已经获得一个不可重入的线程同步锁(eg：SpinLock)，而Task试图获取同一个锁，就会造成一个死锁的线程！

5)        RunSynchronously

可在指定的TaskScheduler或TaskScheduler.Current中同步运行 Task。即RunSynchronously()之后的代码会阻塞到Task委托执行完毕。

示例如下：

1. Task的静态方法

分析：

1)        FromResult<TResult>(TResult result);

创建指定结果的、成功完成的Task<TResult>。我们可以使用此方法创建包含预先计算结果/缓存结果的 Task<TResult>对象，示例代码或CachedDownloads.cs示例文件。

2)        Delay

创建将在指定延迟后完成的任务，返回Task。可以通过await或Task.Wait()来达到Thread.Sleep()的效果。尽管，Task.Delay() 比Thread.Sleep()消耗更多的资源，但是Task.Delay()可用于为方法返回Task类型；或者根据CancellationToken取消标记动态取消等待。

Task.Delay()等待完成返回的Task状态为RanToCompletion；若被取消，返回的Task状态为Canceled。

1. Task<TResult>:Task

Task<TResult>继承自Task，表示一个可以返回值的异步操作，提供Result只读属性用于访问异步操作的返回值。该属性会阻塞线程，直到Task执行完毕并返回值。

System.Threading.Tasks.TaskFactory

1. 设置共用\默认的参数

通过TaskFactory对象提供的Scheduler、CancellationToken、CreationOption和ContinuationOptions属性可以为Task设置共用\默认的参数，以便快捷的创建Task或延续任务。影响StartNew()、ContinueWhenAll()|ContinueWhenAny()、FromAsync()方法的默认参数设置。

1. StartNew()

Task.Factory.StartNew()可快速创建一个Task并且开启任务。代码如下：

这等效于：

表现方面，前者更高效。Start()采用同步方式运行以确保任务对象保持一致的状态即使是同时调用多次Start()，也可能只有一个调用会成功。相比之下，StartNew()知道没有其他代码能同时启动任务，因为在StartNew()返回之前它不会将创建的Task引用给任何人，所以StartNew()不需要采用同步方式执行。更丰富更专业的讨论请看《.NET4.X 并行任务中Task.Start()的FAQ》…

1. ContinueWhenAll()

创建一个延续 Task 或延续 Task<TResult>，它将在提供的一组任务完成后马上开始。延续任务操作委托接受一个Task[]数组做参数。

1. ContinueWhenAny()

创建一个延续 Task 或延续 Task<TResult>，它将在提供的组中的任何一个任务完成后马上开始。延续任务操作委托接受一个 Task 做参数。

1. 通过Task.TaskFactory.FromAsync() 实例方法，我们可以将APM转化为TAP。示例见此文的后面小节“AMP转化为TAP和EAP转化为TAP”。

System.Threading.Tasks.TaskScheduler

TaskScheduler表示一个处理将任务排队到线程中的底层工作对象。TaskScheduler通常有哪些应用呢？

1. TaskScheduler是抽象类，可以继承它实现自己的任务调度计划。如：默认调度程序ThreadPoolTaskScheduler、与SynchronizationContext.Current关联的SynchronizationContextTaskScheduler。
2. 由TaskScheduler.Default获取默认调度程序ThreadPoolTaskScheduler。
3. 由TaskScheduler.Current获取当前任务执行的TaskScheduler。
4. 由 TaskScheduler.TaskSchedulerFromCurrentSynchronizationContext() 方法获取与SynchronizationContext.Current关联的SynchronizationContextTaskScheduler，SynchronizationContextTaskScheduler上的任务都会通过SynchronizationContext.Post()在同步上下文中进行调度。通常用于实现跨线程更新控件。
5. 通过MaximumConcurrencyLevel设置任务调度计划能支持的最大并发级别。
6. 通过UnobservedTaskException事件捕获未被观察到的异常。

System.Threading.Tasks.TaskExtensions

提供一组用于处理特定类型的 Task 实例的静态方法。将特定Task实例进行解包操作。

AMP转化为TAP和EAP转化为TAP

1. AMP转化为TAP

通过Task.TaskFactory.FromAsync() 实例方法，我们可以将APM转化为TAP。

注意点：

1)        FromAsync方法返回的任务具有WaitingForActivation状态，并将在创建该任务后的某一时间由系统启动。如果尝试在这样的任务上调用 Start，将引发异常。

2)        转化的APM异步模型必须符合两个模式：

a)        接受Begin***和End***方法。此时要求Begin***方法签名的委托必须是AsyncCallback以及 End***方法只接受IAsyncResult一个参数。此模式AsyncCallback回调由系统自动生成，主要工作是调用End***方法。

b)        接受IAsyncResult对象以及End***方法。此时Begin***方法的签名已经无关紧要只要（即：此模式支持传入自定义回调委托）能返回IAsyncResult的参数以及 End***方法只接受IAsyncResult一个参数。

3)        当然，我们有时需要给客户提供统一的 Begin***() 和 End***() 调用方式，我们可以直接使用Task从零开始构造APM。即：在 Begin***() 创建并开启任务，并返回Task。因为Task是继承自IAsyncResult接口的，所以我们可以将其传递给 End***() 方法，并在此方法里面调用Result属性来等待任务完成。

4)        对于返回的Task，可以随时以任务延续的形式注册回调。

现在将在《APM异步编程模型》博文中展现的示例转化为TAP模式。关键代码如下：

1. EAP转化为TAP

我们可以使用TaskCompletionSource<TResult>实例将EAP操作表示为一个Task<TResult>。

TaskCompletionSource<TResult>表示未绑定委托的Task<TResult>的制造者方，并通过TaskCompletionSource<TResult>.Task属性获取由此Tasks.TaskCompletionSource<TResult>创建的Task<TResult>。

注意，TaskCompletionSource<TResult>创建的任何任务将由TaskCompletionSource启动，因此，用户代码不应在该任务上调用 Start()方法。

现在我将在《基于事件的异步编程模式(EAP)》博文中展现的BackgroundWorker2组件示例转化为TAP模式。

我们需要修改地方有：

1)        创建一个TaskCompletionSource<int>实例tcs；

2)        为tcs.Task返回的任务创建延续任务，延续任务中根据前面任务的IsCanceled、IsFaulted、Result等成员做逻辑；

3)        Completed事件，在这里面我们将设置返回任务的状态。

关键代码如下：

使用关键字async和await实现异步方法

在C#5.0中引入了async和await关键字，可以方便我们使用顺序结构流(即不用回调)来实现异步编程，大大降低了异步编程的复杂程度。（vs2010打Visual Studio Async CTP for VS2010补丁可以引入关键字”async”和”await”的支持，但是得不到.net4.5新增API的支持）

async和await关键字不会导致其他线程的创建，执行异步方法的线程为其调用线程。而异步方法旨在成为非阻塞操作，即当await等待任务运行时，异步方法会将控制权转移给异步方法外部，让其不受阻塞的继续执行，待await等待的任务执行完毕再将控制权转移给await处，继续执行异步方法后续的代码。

1. 我们可通过下图来明白异步方法的构建和异步方法的执行流程。（代码详见我提供的示例程序async_await_method项目）

需要注意的一个问题：被“async”关键字标记的方法的调用都会强制转变为异步方式吗？

不会，当你调用一个标记了”async”关键字的方法，它会在当前线程以同步的方式开始运行。所以，如果你有一个同步方法，它返回void并且你做的所有改变只是将其标记的“async”，这个方法调用依然是同步的。返回值为Task或Task<TResult>也一样。

方法用“async”关键字标记不会影响方法是同步还是异步运行并完成，而是，它使方法可被分割成多个片段，其中一些片段可能异步运行，这样这个方法可能异步完成。这些片段界限就出现在方法内部显示使用“await”关键字的位置处。所以，如果在标记了“async”的方法中没有显示使用“await”，那么该方法只有一个片段，并且将以同步方式运行并完成。

1. 编译器转换

使用 async 关键字标记方法，会导致 C# 或 Visual Basic 编译器使用状态机重新编写该方法的实现。借助此状态机，编译器可以在该方法中插入多个中断点，以便该方法可以在不阻止线程的情况下，挂起和恢复其执行。这些中断点不会随意地插入。它们只会在您明确使用 await 关键字的位置插入：

当您等待未完成的异步操作时，编译器生成的代码可确保与该方法相关的所有状态（例如，局部变量）封装并保留在堆中。然后，该函数将返回到调用程序，允许在其运行的线程中执行其他任务。当所等待的异步操作在稍后完成时，该方法将使用保留的状态恢复执行。

任何公开 await 模式的类型都可以进行等待。该模式主要由一个公开的 GetAwaiter()方法组成，该方法会返回一个提供 IsCompleted、OnCompleted 和 GetResult 成员的类型。当您编写以下代码时：

编译器会生成一个包含 MoveNext 方法的状态机类：

在实例someObject上使用这些成员来检查该对象是否已完成（通过 IsCompleted），如果未完成，则挂接一个续体（通过 OnCompleted），当所等待实例最终完成时，系统将再次调用 MoveNext 方法，完成后，来自该操作的任何异常将得到传播或作为结果返回（通过 GetResult），并跳转至上次执行中断的位置。

1. 自定义类型支持等待

如果希望某种自定义类型支持等待，我们可以选择两种主要的方法。

1)        一种方法是针对自定义的可等待类型手动实现完整的 await 模式，提供一个返回自定义等待程序类型的 GetAwaiter 方法，该等待程序类型知道如何处理续体和异常传播等等。

2)        第二种实施该功能的方法是将自定义类型转换为Task，然后只需依靠对等待任务的内置支持来等待特殊类型。前文所展示的“EAP转化为TAP”正属于这一类，关键代码如下：

处理TAP中的异常

在任务抛出的未处理异常都封装在System.AggregateException对象中。这个对象会存储在方法返回的Task或Task<TResult>对象中，需要通过访问Wait()、Result、Exception成员才能观察到异常。（所以，在访问Result之前，应先观察IsCanceled和IsFaulted属性）

1. AggregateException对象的三个重要成员

1)        InnerExceptions属性

获取导致当前异常的System.Exception实例的只读集合（即，ReadOnlyCollection<Exception>）。不要将其与基类Exception提供的InnerException属性混淆。

2)        Flatten() 方法

遍历InnerExceptions异常列表，若列表中包含类型为AggregateException的异常，就移除所有嵌套的AggregateException，直接返回其真真的异常信息（效果如下图）。

1)        Handle(Func<Exception, bool> predicate)方法

它为AggregateException中包含的每个异常都调用一个回调方法。然后，回调方法可以为每个异常决定如何对其进行处理，回调返回true表示异常已经处理，返回false表示没有。在调用Handle之后，如果至少有一个异常没有处理，就创建一个新的AggregateException对象，其中只包含未处理的异常，并抛出这个新的AggregateException对象。

比如：将任何OperationCanceledException对象都视为已处理。其他任何异常都造成抛出一个新的AggregateException，其中只包含未处理的异常。

1. 父任务生成了多个子任务，而多个子任务都抛出了异常

1)        嵌套子任务

对于“嵌套子任务”中子任务的异常都会包装在父任务返回的Task或Task<TResult>对象中。如此例子中 t4.Exception.InnerExceptions的Count为3。

对于子任务返回的异常类型为包装过的AggregateException对象，为了避免循环访问子任务异常对象的InnerExceptions才能获取真真的异常信息，可以使用上面提到的Flatten() 方法移除所有嵌套的AggregateExceprion。

2)        Continue子任务

对于“Continue子任务”中的子任务其异常与父任务是分离的，各自包装在自己返回的Task或 Task<TResult>对象中。如此示例 t1、t2、t3 的Exception.InnerExceptions的Count都为1。

1. TaskScheduler的UnobservedTaskException事件

假如你一直不访问Task的Wait()、Result、Exception成员，那么你将永远注意不到这些异常的发生。为了帮助你检测到这些未处理的异常，可以向TaskScheduler对象的UnobservedTaskException事件注册回调函数。每当一个Task被垃圾回收时，如果存在一个没有注意到的异常，CLR的终结器线程会引发这个事件。

可在事件回调函数中调用UnobservedTaskExceptionEventArgs对象的SetObserved() 方法来指出已经处理好了异常，从而阻止CLR终止线程。然而并不推荐这么做，宁愿终止进程也不要带着已经损坏的状态继续运行。

示例代码：（要监控此代码必须在GC.Collect();和事件里两个地方进行断点）

1. 返回void的async“异步方法”中的异常

我们已经知道返回Task或Task<TResult>对象的任务中抛出的异常会随着返回对象一起返回，可通过Exception属性获取。这对于返回Task或Task<TResult>对象的“异步方法”情况也是一样。

然而对于返回void的“异步方法”，方法中抛出的异常会直接导致程序奔溃。

另外，我们还要特别注意lambda表达式构成的“异步方法”，如：

本博文到此结束，我相信你看累了，其实我也写了很久…很久…，写完此文，我的“异步编程系列”也算有头有尾了（还会继续扩充）。本博文主要介绍了Task的重要API、任务的CLR线程池引擎、TaskFactory对象、TaskScheduler对象、TaskExtensions对象、AMP转化为TAP和EAP转化为TAP、使用关键字async和await实现异步方法以及自定义类型支持等待、处理TAP中的异常。

感谢你的观看，如果对你有帮助，还请多多推荐……

===================================================================

本篇博文基于.NET4.5中TPL所写。对于.NET4.0中TPL会有些差异，若有园友知道差异还请告知，我这边做个记录方便大家也方便自己。

1、.NET4.0中TPL未观察到的异常会在GC回收时终止进程。（园友：YamatAmain，讨论见21-26楼）

===================================================================

推荐阅读：

异步性能：了解 Async 和 Await 的成本-----有讲解到使用Task.ConfigureAwait(false)来避免捕获原上下文来提升性能。

关于async与await的FAQ      -----详细讲解了await和async的作用和意义，以及什么是可等待对象、等待者……（此文可帮助你解决80%关于await和async关键字的疑惑）

深入探究 WinRT 和 await      -----基于WinRT平板win8系统，讲解了异步功能API、TAP、编译器转换……

参考资料：MSDN

书籍：《CLR via C#(第三版)》

书籍：《C# 并行编程高级教程：精通.NET 4 Parallel Extensions》

using System;

using System.IO;

using System.Threading;

namespace AsynSample

{

    class FileReader

    {

        /// <summary>

        /// 缓存池

        /// </summary>

        private byte[] Buffer { get; set; }

        /// <summary>

        /// 缓存区大小

        /// </summary>

        public int BufferSize { get; set; }

        public FileReader(int bufferSize)

        {

            this.BufferSize = bufferSize;

            this.Buffer = new byte[BufferSize];

        }

        /// <summary>

        /// 同步读取文件

        /// </summary>

        /// <param name="path">文件路径</param>

        public void SynsReadFile(string path)

        {

            Console.WriteLine("同步读取文件 begin");

            using (FileStream fs = new FileStream(path, FileMode.Open))

            {

                fs.Read(Buffer, 0, BufferSize);

                string output = System.Text.Encoding.UTF8.GetString(Buffer);

                Console.WriteLine("读取的文件信息：{0}",output);

            }

            Console.WriteLine("同步读取文件 end");

        }

        /// <summary>

        /// 异步读取文件

        /// </summary>

        /// <param name="path"></param>

        public void AsynReadFile(string path)

        {

            Console.WriteLine("异步读取文件 begin");

            //执行Endread时报错，fs已经释放，注意在异步中不能使用释放需要的资源

            //using (FileStream fs = new FileStream(path, FileMode.Open))

            //{

            //    Buffer = new byte[BufferSize];

            //    fs.BeginRead(Buffer, 0, BufferSize, AsyncReadCallback, fs);

            //}

            if (File.Exists(path))

            {

                FileStream fs = new FileStream(path, FileMode.Open);

                fs.BeginRead(Buffer, 0, BufferSize, AsyncReadCallback, fs);

            }

            else

            {

                Console.WriteLine("该文件不存在");

            }

        }

        /// <summary>

        ///

        /// </summary>

        /// <param name="ar"></param>

        void AsyncReadCallback(IAsyncResult ar)

        {

            FileStream stream = ar.AsyncState as FileStream;

            if (stream != null)

            {

                Thread.Sleep(1000);

                //读取结束

                stream.EndRead(ar);

                stream.Close();

                string output = System.Text.Encoding.UTF8.GetString(this.Buffer);

                Console.WriteLine("读取的文件信息：{0}", output);

            }

        }

    }

}

using System;

using System.Threading;

namespace AsynSample

{

    class Program

    {

        static void Main(string[] args)

        {

            FileReader reader = new FileReader(1024);

            //改为自己的文件路径

            string path = "C:\\Windows\\DAI.log";

            Console.WriteLine("开始读取文件了...");

            //reader.SynsReadFile(path);

            reader.AsynReadFile(path);

            Console.WriteLine("我这里还有一大滩事呢.");

            DoSomething();

            Console.WriteLine("终于完事了，输入任意键，歇着！");

            Console.ReadKey();

        }

        /// <summary>

        ///

        /// </summary>

        static void DoSomething()

        {

            Thread.Sleep(1000);

            for (int i = 0; i < 10000; i++)

            {

                if (i % 888 == 0)

                {

                    Console.WriteLine("888的倍数：{0}",i);

                }

            }

        }

    }

}

using System;

using System.Text;

namespace AsynSample

{

    /// <summary>

    /// 下载委托

    /// </summary>

    /// <param name="fileName"></param>

    public delegate string AysnDownloadDelegate(string fileName);

    /// <summary>

    /// 通过委托实现异步调用

    /// </summary>

    class DownloadFile

    {

        /// <summary>

        /// 同步下载

        /// </summary>

        /// <param name="fileName"></param>

        public string Downloading(string fileName)

        {

            string filestr = string.Empty;

            Console.WriteLine("下载事件开始执行");

            System.Threading.Thread.Sleep(3000);

            Random rand = new Random();

            StringBuilder builder =new StringBuilder();

            int num;

            for(int i=0;i<100;i++)

            {

                num = rand.Next(1000);

                builder.Append(i);

            }

            filestr = builder.ToString();

            Console.WriteLine("下载事件执行结束");

            return filestr;

        }

        /// <summary>

        /// 异步下载

        /// </summary>

        public IAsyncResult BeginDownloading(string fileName)

        {

            string fileStr = string.Empty;

            AysnDownloadDelegate downloadDelegate = new AysnDownloadDelegate(Downloading);

            return downloadDelegate.BeginInvoke(fileName, Downloaded, downloadDelegate);

        }

        /// <summary>

        /// 异步下载完成后事件

        /// </summary>

        /// <param name="result"></param>

        private void Downloaded(IAsyncResult result)

        {

            AysnDownloadDelegate aysnDelegate = result.AsyncState as AysnDownloadDelegate;

            if (aysnDelegate != null)

            {

                string fileStr = aysnDelegate.EndInvoke(result);

                if (!string.IsNullOrEmpty(fileStr))

                {

                    Console.WriteLine("下载文件：{0}", fileStr);

                }

                else

                {

                    Console.WriteLine("下载数据为空!");

                }

            }

            else

            {

                Console.WriteLine("下载数据为空!");

            }

        }

    }

}

在迭代器块中用于向枚举数对象提供值或发出迭代结束信号。

yield return <expression>; yield break;

计算表达式并以枚举数对象值的形式返回；expression 必须可以隐式转换为迭代器的 yield 类型。

yield 语句只能出现在 iterator 块中，该块可用作方法、运算符或访问器的体。

一个迭代器块（iterator block）是一个能够产生有序的值序列的块。迭代器块和普通语句块的区别就是其中出现的一个或多个yield语句。 yield return语句产生迭代的下一个值。 yield break语句表示迭代完成。

示例

using System;

using System.Collections;

public class List

{

    public static IEnumerable Power(int number, int exponent)

    {

        int counter = 0;

        int result = 1;

        while (counter++ < exponent)

        {

            result = result * number;

            yield return result;

        }

    }

    static void Main()

    {

        // Display powers of 2 up to the exponent 8:

        foreach (int i in Power(2, 8))

        {

            Console.Write("{0} ", i);

        }

    }

}

2 4 8 16 32 64 128 256