async 和 await 关键字

C# 5.0中引入了async 和 await。这两个关键字可让你更方便的按照同步的方式写出异步代码。也就是说使你更方便的异步编程。常规的写法格式以下：

var result = await expression;
statement(s);

这种写法至关于： 

var awaiter = expression.GetAwaiter();
awaiter.OnCompleted (() =>
{
var result = awaiter.GetResult();
statement(s);
);

这里的expression一般是Task或者Task<TResult>，可是事实上能够本身定义一些可使用await的对象。可是要知足必定的条件。先看一个例子。 

static void Main(string[] args)
       {
           DisplayPrimesCount();
           Thread.Sleep(5000);//等待异步执行完成
       }
       static 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)));
       }
       static async void DisplayPrimesCount()
       {
           int result = await GetPrimesCountAsync(2, 1000000);//此处会阻塞
           Console.WriteLine(result);
       }

这是比较常见的写法。

要异步执行GetPrimesCountAsync方法，首先GetPrimesCountAsync返回的必须是"可等待"对象。上述代码中GetPrimesCountAsync返回的是Task<int>类型。而后，使用await的方法必需要标注async关键字。而且能够看到await GetPrimesCountAsync(2, 1000000);这个语句返回的是int，而不是Task<int>。

上述代码用天然语言描述就是以下：

当调用DisplayPrimesCount，DisplayPrimesCount会运行一个新的Task，这个task会计算素数的个数。完成后，会将计算所得的值返回，并将这个返回值放到Task对象中，而且返回给调用者。调用者得到这个Task值后，取出Task的result值。

当程序逻辑遇到await GetPrimesCountAsync方法，线程就会被挂起，直到异步运行完成，获得result值后，再会继续运行下去。

本质上说await和async的出现也只是一颗语法糖，可是这颗语法糖可使得异步编程更优雅，直接摒弃了原先EAP和APM这种处处BeginXXX，EndXXX的丑陋模式，提升了生产力。

可使用await的方法，返回值必须是awaitable对象，自定义awaitable对象比较麻烦，一个对象必须知足下列条件才行：

1. 必须有一个 GetAwaiter()方法，扩展方法或者实例方法均可以
2. GetAwaiter() 方法返回值必须是awaiter对象。一个对象要成为awaiter对象必须知足下列条件:
   • 该对象实现接口 INotifyCompletion 或者ICriticalNotifyCompletion
   • 必须有 IsCompleted属性
   • 必须有 GetResult()方法，能够返回void或者其余返回值。

因为微软并未给出知足上述条件的接口，所以能够本身实现这样的接口。 

public interface IAwaitable<out TResult>
    {
        IAwaiter<TResult> GetAwaiter();
    }
    public interface IAwaiter<out TResult> : INotifyCompletion // or ICriticalNotifyCompletion
    {
        bool IsCompleted { get; }
        TResult GetResult();
    }

因为对于拉姆达表达式不能够直接使用await，所以能够经过编程，技巧性的实现这一功能。好比对某一个Func委托实现扩展方法，注意： 扩展方法必须在顶级静态类中定义。 

public static class FuncExtensions
    {
        public static IAwaiter<TResult> GetAwaiter<TResult>(this Func<TResult> function)
        {
            return new FuncAwaiter<TResult>(function);
        }
    }
    public interface IAwaitable<out TResult>
    {
        IAwaiter<TResult> GetAwaiter();
    }
    public interface IAwaiter<out TResult> : INotifyCompletion // or ICriticalNotifyCompletion
    {
        bool IsCompleted { get; }
        TResult GetResult();
    }
    internal struct FuncAwaitable<TResult> : IAwaitable<TResult>
    {
        private readonly Func<TResult> function;
        public FuncAwaitable(Func<TResult> function)
        {
            this.function = function;
        }
        public IAwaiter<TResult> GetAwaiter()
        {
            return new FuncAwaiter<TResult>(this.function);
        }
    }
    public struct FuncAwaiter<TResult> : IAwaiter<TResult>
    {
        private readonly Task<TResult> task;
        public FuncAwaiter(Func<TResult> function)
        {
            this.task = new Task<TResult>(function);
            this.task.Start();
        }
        bool IAwaiter<TResult>.IsCompleted
        {
            get
            {
                return this.task.IsCompleted;
            }
        }
        TResult IAwaiter<TResult>.GetResult()
        {
            return this.task.Result;
        }
        void INotifyCompletion.OnCompleted(Action continuation)
        {
            new Task(continuation).Start();
        }
    }

在main中能够以下写：

  static void Main(string[] args)
        {
            Func(() => { Console.WriteLine("await..");return 0;});
            Thread.Sleep(5000);//等待异步执行完成
        }
        static async void Func(Func<int> f)
        {
            int result = await new Func<int>(f);
            Console.WriteLine(result);
        }

其中：

Func方法能够异步执行了，由于Func<int>已经实现扩展方法GetAwaiter，而且返回值类型是本身定义的IAwaitable类型。

固然，更加简单的方法是，采用微软提供的Task对象，让拉姆达表达式返回Task类型就能够了。 

static void Main(string[] args)
        {
            Func(() =>
            {
                return Task<int>.Run<int>(() => { return Enumerable.Range(1,100).Sum(); });
            });
            Thread.Sleep(5000);//等待异步执行完成
        }
        static async void Func(Func<Task<int>> f)
        {
            int result = await f();
            Console.WriteLine(result);
        }

参考资料：《C# 5.0 IN A NUTSHELL》

http://weblogs.asp.net/dixin/archive/2012/11/08/understanding-c-async-await-2-awaitable-awaiter-pattern.aspx