线程是创建并发的底层工具，对于开发者而言，想实现细粒度并发具有一定的局限性，比如将小的并发组合成大的并发，还有性能方面的影响。
Task可以很好的解决这些问题，Task是一个更高级的抽象概念，代表一个并发操作，但不一定依赖线程完成。
Task从Framework4.0开始引入，Framework4.5又添加了一些功能,比如Task.Run()，async/await关键字等，
在.NET Framework4.5之后，基于任务的异步处理已经成为主流模式, (Task-based Asynchronous Pattern,TAP)基于任务的异步模式。
在使用异步函数之前，先看下Task的基本操作。
一. Task 基本操作
1.1 Task 启动方式
Task.Run(()=>Console.WriteLine("Hello Task"));
Task.Factory.StartNew(()=>Console.WriteLine("Hello Task"));
Task.Run是Task.Factory.StartNew的快捷方式。
启动的都是后台线程，并且默认都是线程池的线程
Task.Run(() =>
{
Console.WriteLine(
$"TaskRun IsBackGround:{CurrentThread.IsBackground}, IsThreadPool:{CurrentThread.IsThreadPoolThread}");
});
Task.Factory.StartNew(() =>
{
Console.WriteLine(
$"TaskFactoryStartNew IsBackGround:{CurrentThread.IsBackground}, IsThreadPool:{CurrentThread.IsThreadPoolThread}");
});
如果Task是长任务，可以添加TaskCreationOptions.LongRunning参数，使任务不运行在线程池上，有利于提升性能。
Task.Factory.StartNew(() =>
{
Console.WriteLine(
$"TaskFactoryStartNew IsBackGround:{CurrentThread.IsBackground}, IsThreadPool:{CurrentThread.IsThreadPoolThread}");
}, TaskCreationOptions.LongRunning);
1.2 Task 返回值/带参数
Task 有一个泛型子类Task<TResult>,允许返回一个值。
Task<string> task =Task.Run(()=>SayHello("Jack"));
string SayHello(string name)
{
return "Hello " + name;
}
Console.WriteLine(task.Result);
通过任务的Result属性获取返回值，这是会堵塞线程，尤其是在桌面客户端程序中，谨慎使用Task.Result,容易导致死锁！
同时带参数的方式也不是很合理，后面可以被async/await方式直接替代。
1.3 Task 异常/异常处理
当任务中的代码抛出一个未处理异常时，调用任务的Wait()或者Result属性时，异常会被重新抛出。
var task = Task.Run(ThrowError);
try
{
task.Wait();
}
catch(AggregateException ex)
{
Console.WriteLine(ex.InnerException is NullReferenceException ? "Null Error!" : "Other Error");
}
void ThrowError()
{
throw new NullReferenceException();
}
对于自治任务(没有wait()和Result或者是延续的任务)，使用静态事件TaskScheduler.UnobservedTaskException可以在全局范围订阅未观测的异常。
以便记录错误日志
1.4 Task 延续
延续通常由一个回调方法实现，该方法会在任务完成之后执行，延续方法有两种
（1）调用任务的GetAwaiter方法，将返回一个awaiter对象。这个对象的OnCompleted方法告知任务当执行完毕或者出错时调用一个委托。
Task<string> learnTask = Task.Run(Learn);
var awaiter = learnTask.GetAwaiter();
awaiter.OnCompleted(() =>
{
var result = awaiter.GetResult();
Console.WriteLine(result);
});
string Learn()
{
Console.WriteLine("Learn Method Executing");
Thread.Sleep(1000);
return "Learn End";
}
如果learnTask任务出现错误，延续代码awaiter.GetResult()将重新抛出异常，其中GetResult可以直接得到原始的异常，如果使用Result属性，只能解析AggergateException.
这种延续方法更适用于富客户端程序，延续可以提交到同步上下文，延续回到UI线程中。
当编写库文件，可以使用ConfigureAwait方法，延续代码会运行在任务运行的线程上，从而避免不必要的切换开销。
var awaiter =learnTask.ConfigureAwait(false).GetAwaiter();
（2）另一种方法使用ContiuneWith
Task<string> learnTask = Task.Run(Learn);
learnTask.ContinueWith(antecedent =>
{
var result = learnTask.Result;
Console.WriteLine(result);
});
string Learn()
{
Console.WriteLine("Learn Method Executing");
Thread.Sleep(1000);
return "Learn End";
}
当任务出现错误时，必须处理AggregateException, ContiuneWith更适合并行编程场景。
1.5 TaskCompletionSource类使用
从如下源码中可以看出当实例化TaskCompletionSource时，构造函数会新建一个Task任务。
public class TaskCompletionSource
{
private readonly Task _task;
/// <summary>Creates a <see cref="TaskCompletionSource"/>.</summary>
public TaskCompletionSource() => _task = new Task();
/// <summary>
/// Gets the <see cref="Tasks.Task"/> created
/// by this <see cref="TaskCompletionSource"/>.
/// </summary>
/// <remarks>
/// This property enables a consumer access to the <see cref="Task"/> that is controlled by this instance.
/// The <see cref="SetResult"/>, <see cref="SetException(Exception)"/>, <see cref="SetException(IEnumerable{Exception})"/>,
/// and <see cref="SetCanceled"/> methods (and their "Try" variants) on this instance all result in the relevant state
/// transitions on this underlying Task.
/// </remarks>
public Task Task => _task;
}
它的真正的作用是创建一个不绑定线程的任务。
eg: 可以使用Timer类，CLR在定时之后触发一个事件，而无需使用线程。
实现通用Delay方法：
Delay(5000).GetAwaiter().OnCompleted(()=>{ Console.WriteLine("Delay End"); });
Task Delay(int millisecond)
{
var tcs = new TaskCompletionSource<object>();
var timer = new System.Timers.Timer(millisecond) { AutoReset = false };
timer.Elapsed += delegate
{
timer.Dispose();
tcs.SetResult(null);
};
timer.Start();
return tcs.Task;
}
这个方法类似Task.Delay()方法。
二. 异步原则(补充)
同步操作：先完成其工作再返回调用者
异步操作：大部分工作则是在返回调用者之后才完成的，也称非阻塞方法。
异步编程的原则：
（1）以异步的方式编写运行时间很长（或者可能很长）的函数，会在一个新的线程或者任务上调用这些函数，从而实现需要的并发性。
（2）异步方法的并发性是在长时间运行的方法内启动的，而不是从这个方法外启动的。
- I/O密集的并发性的实现不需要绑定线程(如1.5节的例子所示)，因此可以提高可伸缩性和效率。
- 富客户端应用程序可以减少工作线程的代码，因此可以简化线程安全性的实现。
Task支持延续，因此非常适合进行异步编程的，如1.5节的Delay方法。
在计算密集的方法中，我们使用Task.Run创建线程相关的异步性。但是异步编程的不同点在于，更希望将异步放在底层调用图上，
因此富客户端应用程序的高层方法就可以一直在UI线程上运行，访问控件、共享状态而不用担心会出现线程安全问题。
看Task.Run的例子：
//粗粒度并发
Task.Run(() => DisplayPrimeCounts());
/// <summary>
/// 显示素数个数
/// </summary>
void DisplayPrimeCounts()
{
for (int i = 0; i < 10; i++)
Console.WriteLine(GetPrimesCount(i * 1000000 + 2, 1000000) +
" primes between " + (i * 1000000) + " and " + ((i + 1) * 1000000 - 1));
Console.WriteLine("Done!");
}
/// <summary>
/// 获取素数个数
/// </summary>
int GetPrimesCount(int start, int count)
{
return
ParallelEnumerable.Range(start, count).Count(n =>
Enumerable.Range(2, (int)Math.Sqrt(n) - 1).All(i => n % i > 0));
}
这是一种粗粒度并发，如果想实现细粒度并发，需要编写异步的方法。
看异步版本：
DisplayPrimeCountsAsync();
Task DisplayPrimeCountsAsync()
{
var machine = new PrimesStateMachine();
machine.DisplayPrimeCountsFrom(0);
return machine.Task;
}
class PrimesStateMachine
{
TaskCompletionSource<object> _tcs = new TaskCompletionSource<object>();
public Task Task { get { return _tcs.Task; } }
/// <summary>
/// 异步显示素数个数
/// </summary>
/// <param name="i"></param>
public void DisplayPrimeCountsFrom(int i)
{
var awaiter = GetPrimesCountAsync(i * 1000000 + 2, 1000000).GetAwaiter();
awaiter.OnCompleted(() =>
{
Console.WriteLine(awaiter.GetResult()+" primes between " + (i * 1000000) + " and " + ((i + 1) * 1000000 - 1));
if (i++ < 10) DisplayPrimeCountsFrom(i);
else { Console.WriteLine("Done"); _tcs.SetResult(null); }
});
}
/// <summary>
/// 异步获取素数个数
/// </summary>
/// <param name="start"></param>
/// <param name="count"></param>
/// <returns></returns>
Task<int> GetPrimesCountAsync(int start, int count)
{
return Task.Run(() =>
ParallelEnumerable.Range(start, count).Count(n =>
Enumerable.Range(2, (int)Math.Sqrt(n) - 1).All(i => n % i > 0)));
}
}
可以看到改造异步后的实现方式，很复杂。 GetPrimesCountAsync改为方法内部启动异步，DisplayPrimeCountsFrom通过TaskCompletionSource实现异步。
这时async和await登场！
async和await关键字极大的简化了程序的复杂度。
async/await版本：
DisplayPrimeCountsAsync();
/// <summary>
/// 异步显示素数个数
/// </summary>
async Task DisplayPrimeCountsAsync()
{
for (int i = 0; i < 10; i++)
Console.WriteLine(await GetPrimesCountAsync(i * 1000000 + 2, 1000000) +
" primes between " + (i * 1000000) + " and " + ((i + 1) * 1000000 - 1));
Console.WriteLine("Done!");
}
/// <summary>
/// 异步获取素数个数
/// </summary>
Task<int> GetPrimesCountAsync(int start, int count)
{
return Task.Run(() =>
ParallelEnumerable.Range(start, count).Count(n =>
Enumerable.Range(2, (int)Math.Sqrt(n) - 1).All(i => n % i > 0)));
}
从编程形式上，有点类似同步方法一样直观简洁。其实async/await编译器也是将其转换为一个状态机。通常我们称之为C#语法糖。
编译器背后的原理可以参考这篇文章：https://www.cnblogs.com/zh7791/p/9951478.html
三. 异步函数
这章开始进入异步函数的使用，由上面一章已经引出async/await关键字。可以使用同步的代码风格编写异步代码，极大地降低了异步编程的复杂度。
简单捋下async/await
如下语句中使用了await附加了延续，statement(s)是expression的延续。
这个“等待”被编译器转化为如下同等功能的代码。
这是如果想要成功编译就必须添加async修饰符，如下图提示。
async修饰符会指示编译器将await作为一个关键字而非标识符，来避免二义性（C#5之前有可能作为标识符使用），添加async修饰符的方法称为异步函数。
3.1 富客户端异步函数Demo
通过WPF的例子展示异步函数在富客户端应用程序中的作用：在执行计算密集的方法时，仍然保持UI的响应，不堵塞UI线程。
先看同步调用的情况：
private void ExecuteTaskOnClick(object sender, RoutedEventArgs e)
{
TextBoxMessage.Text = "Call Worker" + Environment.NewLine;
DoSomething();//同步调用
}
private void DoSomething()
{
Thread.Sleep(3000);//模拟计算密集耗时
TextBoxMessage.Text += "Calculate Done" + Environment.NewLine;
}
上图可以清楚的看到，当使用同步调用耗时方法时，UI线程无法响应用户事件请求，TextBox的信息显示也是等耗时方法结束后才更新。
原因是在耗时方法执行期间，UI线程已经被阻塞，UI线程接收的处理请求都会进入请求队列，无法及时响应(包括鼠标键盘的事件请求，控件更新),很影响用户体验。
下面看异步版本：
btnExecuteTaskAsync.Click += (sender, args) => ExecuteTaskAsync();
private async void ExecuteTaskAsync()
{
btnExecuteTaskAsync.IsEnabled = false;
TextBoxMessage.Text = "Call Worker Async" + Environment.NewLine;
await DoSomethingAsync();//异步调用
TextBoxMessage.Text += "Calculate Async Done" + Environment.NewLine;
btnExecuteTaskAsync.IsEnabled = true;
}
private async Task DoSomethingAsync()
{
await Task.Run(() =>
{
Thread.Sleep(3000); //模拟计算密集耗时
});
}
更改为异步版本后，在执行耗时任务时，UI线程没有被堵塞，可以正常响应用户事件和控件更新，提高了用户体验。
3.2 异步调用执行过程
根据3.1节的例子，整个调用过程如下：
当用户点击按钮时触发事件，事件调用ExecuteTaskAsync 方法，ExecuteTaskAsync 方法调用DoSomethingAsync方法，而后调用await，而await会使执行点返回给调用者，
当DoSomethingAsync方法完成(或者出现错误)时，执行点会从停止之处恢复执行DoSomethingAsync后面的代码。
ExecuteTaskAsync 方法则会'租用'UI线程的时间，即ExecuteTaskAsync 方法在消息循环注1中是以伪并发的方式执行的(执行会在UI线程的其他事件处理中穿插进行)。
在整个伪并发的过程中，只有await的过程中才会进行抢占，这就简化了线程的安全性。DoSomethingAsync会运行在工作线程上，正真的并发发生在DoSomethingAsync方法的Task.Run部分，在Task.Run部分尽量避免访问共享状态和UI组件。
注1：UI线程上的消息循环的伪代码如下：
待续。。。