大部分人可能已经知道，Visual Studio 11引入了新的“async”和“await”。这是另外一篇介绍文章。
（译者注：本文写于 2012 年）
首先，点睛之笔：async 会从根本上改变我们大部分代码的编写方式。
是的，我相信async、await会带来比LINQ更大的影响。在很短时间以后，理解 async 会变成一个基本需求。
让我们开始吧。我会使用一些在后面才会详细说明的内容——在第一部分中请坚持一下。
异步方法看上去就像这样：
public async Task DoSomethingAsync()
{
// 在真实世界里，我们会真的去执行一些操作。。。
// 但对于这个示例，我们只是简单的（异步地）等待100毫秒。
await Task.Delay(100);
}
“async”这个关键字让我们能够在方法内部使用“await”关键字，并且改变了处理结果的方式，这就是async关键字做的全部内容！我们并没有在线程池的线程中运行这个方法，也没有使用任何其它魔法。async关键字只是激活了await关键字（并管理方法结果）。
异步方法在开始执行时，和其它任何方法都是一样的。也就是说，在遇到“await”关键字（或者抛出异常）之前，方法都是同步运行的。
“await”关键字可以让事情异步运行。await就像一元操作符。它接收一个单独的参数：可等待（可等待是一个异步操作）。await会检查可等待操作是否已经结束，如果可等待操作已经完成，方法就会继续运行（就像一个正常的同步运行方法）。
如果“await”发现可等待操作还没有完成，那么就会异步地执行。它会告诉可执行操作，在完成之后，继续执行方法剩余的部分，然后从异步方法返回。
过些时候，当可执行操作完成后，它会执行异步方法的剩余部分。如果你在等待一个内置的可等待操作（例如Task），那么异步方法的剩余部分会在“await”返回之前的“上下文”中执行。
我喜欢将“await”当做“异步等待”。也就是说，异步方法会暂停，直到可等待操作结束（因此它在等待），但实际上线程并不会被阻塞（因此它是异步的）。
如我所说，“await”关键字使用一个单独的参数——“可等待的”，一个异步操作。在.NET框架中，我们有两个常用的可等待类型：Task<T> 和 Task。
我们也有一些其它的可等待类型：有一些特殊方法，例如”Task.Yield”会返回一个可等待的值，但这个值不是Task；对于WinRT运行时（随Windows 8而来）会有一个非托管的可等待类型。你也可以创建自己的可等待类型（通常是为了性能的原因），或者使用扩展方法将一个不可等待的类型变为可等待类型。
这就是我想说的，如何创建你自己的可等待类型。在使用async/await的全部时间里，我不得不创建了几个可等待类型。如果想了解更多关于创建自定义可等待类型的信息，你可以查看 Parallel团队的博客 或者 Jon Skeet的博客。
关于可等待类型，有一点很重要：可等待指的是类型，而不是返回该类型的方法。换句话说，你可以等待一个返回 Task 的方法的结果，这是因为这个方法返回的是Task，而不是因为方法是异步的。这样你也可以等待一个返回 Task 非异步方法的结果。
public async Task NewStuffAsync()
{
//使用await关键字，希望你能玩得开心。
await ...
}
public Task MyOldTaskParallelLibraryCode()
{
// 请注意这不是一个异步方法，因此我们不能够在这里使用await关键字。
...
}
public async Task ComposeAsync()
{
// 我们可以等待任务，而无需关心它们来自何处。
await NewStuffAsync();
await MyOldTaskParallelLibraryCode();
}
小贴士：如果你有一个非常简单的异步方法，你可能根本不会使用 await 关键字（例如，使用Task.FromResult）。如果你可以不使用 await 关键字，那么你就不应该使用它，并将 async 关键字从方法声明中移除。一个返回 Task.FromResult 的非异步方法要比一个返回正常值的异步方法更有效率。
异步方法可以返回Task<T>、Task或者void。在大多数情况下，你可能会希望返回 Task<T> 或者 Task，只有万不得已时，才会返回void。
为什么返回 Task<T> 或者 Task 呢？因为它们是可等待的，而void不是。这样当你有一个返回 Task<T> 或者 Task 的异步方法时，你就可以将结果传递给 await。如果使用void方法，你不能向await传递任何值。
当有异步的事件处理方法时，你只能返回void。
你也可以在其他“高级别”行为上使用异步void方法——例如，针对控制台程序的单独的“static async void MainAsync()”。然而，异步void方法有自身的问题，可以参考异步控制台程序。异步void方法的主要还是用于事件处理。
如果一个异步方法返回 Task 或者 void，那么它不会有返回值，如果一个异步方法返回 Task<T>，那么它必须返回一个类型为 T 的值：
public async Task<int> CalculateAnswer()
{
await Task.Delay(100); // (Probably should be longer...)
// 返回一个int类型，而不是Task<int>。
return 42;
}
这里有点儿奇怪，我们需要去适应。但这样设计的背后，还是有一些“好的理由”的。
在概述中，我提到过，如果你在等待一个内置的可等待操作，那么可等待操作会捕捉当前的“上下文”，并在后面执行异步方法剩余部分时，使用该“上下文”。那么“上下文”到底是什么？
简单的回答是：
复杂的回答：
那么在实际中这意味着什么？首先，捕捉（以及存储）UI、ASP.NET上下文是透明的。
// WinForms示例（对于WPF来说是一样的）
private async void DownloadFileButton_Click(object sender, EventArgs e)
{
// 既然我们使用异步的方式等待，那么UI线程就不会被文件下载所阻塞。
await DownloadFileAsync(fileNameTextBox.Text);
// 既然我们从UI上下文中恢复，我们就可以直接访问UI元素。
resultTextBox.Text = "File downloaded!";
}
// ASP.NET示例
protected async void MyButton_Click(object sender, EventArgs e)
{
// 既然我们使用异步方法来等待，那么ASP.NET线程就不会被文件下载所阻塞。
// 这样当我们等待的时候，ASP.NET线程就可以处理其他的请求。
await DownloadFileAsync(...);
// 既然我们从ASP.NET上下文中恢复，我们就可以访问当前的请求。
// 我们可能实际上是在另外一个*线程*上，但我们有相同的ASP.NET请求上下文。
Response.Write("File downloaded!");
}
对于事件处理来说，这是很棒的，但对于你要写的其它大部分代码来说（实际上，这是你将会写的大部分异步代码），这可能并不是你想要的。
很多时候，你可能并不需要异步回到“主”上下文。对于大部分异步方法来说，在设计时会在头脑中考虑组合：它们会等待其它操作，每个操作本身都代表一个异步操作（这意味着，它们可以和其它操作组合在一起）。在这种情况下，你可以通过调用 ConfigureAwait 方法并传入false的方式，来告诉“等待者”不要捕捉当前的上下文。例如：
private async Task DownloadFileAsync(string fileName)
{
// 使用HttpClient或者其他任何方式来下载文件内容
var fileContents = await DownloadFileContentsAsync(fileName).ConfigureAwait(false);
// 请注意由于ConfigureAwait(false)，我们并没有在原来的上下文中。
// 相反，我们运行在线程池上。
// 将文件内容写入到外部的磁盘文件中。
await WriteToDiskAsync(fileName, fileContents).ConfigureAwait(false);
// 这里第二次调用ConfigureAwait(false)并不是*必需*的，但这是一个最佳实践。
}
// WinForms实例（对于WPF来说是一样的）
private async void DownloadFileButton_Click(object sender, EventArgs e)
{
// 因为我们使用异步方式来等待，UI线程就不会被文件下载所阻塞。
await DownloadFileAsync(fileNameTextBox.Text);
// 因为我们从UI上下文中恢复了， 我们就可以直接访问UI元素了。
resultTextBox.Text = "File downloaded!";
}
在这个示例中， 有一点非常重要：每个“级别”上的异步方法只会调用它自己的上下文。DownloadFileButton_Click 在 UI 上下文中启动，然后调用 DownloadFileAsync 方法。DownloadFileAsync 也在 UI 上下文中启动，但它通过调用 ConfigureAwait(false) 方法将上下文丢弃。DownloadFileAsync 方法剩余部分会运行在线程池上下文中。然而，当 DownloadFileAsync 方法结束后，DownloadButton_Click 方法会恢复执行，它确实会恢复 UI 上下文。
一种好的做法：如果你不知道你确实需要上下文，那么就用 ConfigureAwait(false) 方法。
到目前为止，我们只考虑了连续组合：异步方法一次只会等待一个操作。我们也可以启动多个操作，并等待其中一个（或者全部）结束。为此，我们可以启动这些操作，但到后面再等待它们：
public async Task DoOperationsConcurrentlyAsync()
{
Task[] tasks = new Task[3];
tasks[0] = DoOperation0Async();
tasks[1] = DoOperation1Async();
tasks[2] = DoOperation2Async();
// 在这里，所有的三个任务会同时运行。
// 现在我们等待所有的任务。
await Task.WhenAll(tasks);
}
public async Task<int> GetFirstToRespondAsync()
{
// 调用两个Web服务；然后读取第一个响应。
Task<int>[] tasks = new[] { WebService1Async(), WebService2Async() };
// 等待第一个Web服务响应。
Task<int> firstTask = await Task.WhenAny(tasks);
// 返回结果。
return await firstTask;
}
通过使用并发组合（Task.WhenAll 或者 Task.WhenAny），你可以执行简单的并发操作。你也可以将这些方法和 Task.Run 一起使用，来执行简单的并行计算。然而，这种方式并不适用于任务并行库（Task 并行库）——对于任何CPU密集型的高级并行操作来说，都应该使用 TPL 完成。
请查看“基于任务的异步模式（TAP）文档”。这份文档写得非常好，它包含了API设计方面的指导原则，以及如何正确使用async、await（包括取消以及进度报告）。
现在有很多适用await的新技术，我们应该使用它们，而不是那些旧的技术。如果你还在新的异步代码中使用任何下面列出的旧示例，那么你就做错了：
| 旧技术 | 新技术 | 描述 |
|---|---|---|
| task.Wait | await task | Wait/await for a task to complete 等待一个任务结束 |
| task.Result | await task | Get the result of a completed task 获取已结束任务的结果 |
| Task.WaitAny | await Task.WhenAny | Wait/await for one of a collection of tasks to complete 等待任务集中的任何一个结束 |
| Task.WaitAll | await Task.WhenAll | Wait/await for every one of a collection of tasks to complete 等待任务集中的全部任务都结束 |
| Thread.Sleep | await Task.Delay | Wait/await for a period of time 等待一段时间 |
| Task constructor | Task.Run or TaskFactory.StartNew | Create a code-based task 创建一个基于代码的任务 |
我已经在MSDN中发表了一篇文章：异步编程的最佳实践，这篇文章进一步解释了“避免使用异步void”、“自始至终使用异步”以及“配置上下文”的指导原则。
MSDN 官方文档非常不错，它包含了“基于任务的异步模式文档”的在线版本，这个文档非常好，它讨论了异步方法的设计。
异步团队发表了“async/await FAQ“，我们可以很好地通过它来继续学习异步。在这里面还包含了最好的博客文章和视频的链接。另外，Stephen Toub写的任何文章都非常有启发性。
当然，另外一个资源就是我自己的博客。
我在“Concurrency Cookbook”中包含了大量关于使用 async 和 await 的用例，同时也包含了一些你应该使用任务并行库（TPL）、Rx或者TPL数据流的情况。