解释

下面是一个高层async/await的快速示例。除此之外，还有很多细节需要考虑。

注意:Task.Delay(1000)模拟工作1秒。我认为最好将此视为等待来自外部资源的响应。由于我们的代码正在等待响应，系统可以将正在运行的任务设置到一边，并在完成后返回到它。同时，它可以在该线程上做一些其他工作。

在下面的例子中，第一个块正是这样做的。它立即启动所有任务(Task。延迟线)，并把它们放到一边。代码将在await一行上暂停，直到1秒的延迟完成，然后才进入下一行。由于b、c、d和e几乎与a同时开始执行(由于缺少await)，因此在本例中它们应该大致同时完成。

在下面的例子中，第二个块正在启动一个任务，并在开始后续任务之前等待它完成(这就是await所做的)。每次迭代需要1秒。await是暂停程序并在继续之前等待结果。这是第一块和第二块的主要区别。

例子

Console.WriteLine(DateTime.Now);

// This block takes 1 second to run because all
// 5 tasks are running simultaneously
{
    var a = Task.Delay(1000);
    var b = Task.Delay(1000);
    var c = Task.Delay(1000);
    var d = Task.Delay(1000);
    var e = Task.Delay(1000);

    await a;
    await b;
    await c;
    await d;
    await e;
}

Console.WriteLine(DateTime.Now);

// This block takes 5 seconds to run because each "await"
// pauses the code until the task finishes
{
    await Task.Delay(1000);
    await Task.Delay(1000);
    await Task.Delay(1000);
    await Task.Delay(1000);
    await Task.Delay(1000);
}
Console.WriteLine(DateTime.Now);

输出:

5/24/2017 2:22:50 PM
5/24/2017 2:22:51 PM (First block took 1 second)
5/24/2017 2:22:56 PM (Second block took 5 seconds)

关于SynchronizationContext的额外信息

注意:这就是我感到有点模糊的地方，所以如果我错了什么，请纠正我，我会更新答案。对它的工作原理有一个基本的了解是很重要的，但只要你从来没有使用过ConfigureAwait(false)，你也可以成为这方面的专家，尽管我认为你可能会失去一些优化的机会。

有一个方面使得异步/等待概念有点难以掌握。事实上，在这个例子中，这一切都发生在同一个线程上(或者至少在SynchronizationContext方面看起来是同一个线程)。默认情况下，await将恢复运行它的原始线程的同步上下文。例如，在ASP中。NET中你有一个HttpContext，当请求进入时它被绑定到一个线程上。此上下文包含特定于原始Http请求的内容，例如原始request对象，其中包含语言、IP地址、报头等内容。如果你在处理过程中切换线程，你可能会在不同的HttpContext中尝试从这个对象中提取信息，这可能是灾难性的。如果您知道您不会将上下文用于任何事情，您可以选择“不关心”它。这基本上允许您的代码在单独的线程上运行，而无需带上下文。

你如何做到这一点?默认情况下，await a;代码实际上做了一个假设，你想要捕获和恢复上下文:

await a; //Same as the line below
await a.ConfigureAwait(true);

如果你想让主代码在没有原始上下文的情况下继续在一个新线程上运行，你只需使用false而不是true，这样它就知道它不需要恢复上下文。

await a.ConfigureAwait(false);

在程序暂停之后，它可能会继续在一个具有不同上下文的完全不同的线程上运行。这就是性能改进的来源——它可以在任何可用的线程上继续运行，而不必恢复它开始时的原始上下文。

这些东西让人困惑吗?地狱耶!你能算出来吗?可能!一旦你掌握了概念，然后转向Stephen Cleary的解释，它往往更适合那些已经对async/await有技术理解的人。

除了其他答案，还有await (c#参考)

更具体地说，在包含的例子中，它解释了您的情况

下面的Windows窗体示例说明了await在 异步方法，WaitAsynchronouslyAsync。对比一下它的行为 方法使用waitsynchrontically的行为。没有等待 应用到任务的操作符，waitsynchronize同步运行 尽管在定义中使用了async修饰符，并且调用了 线程。睡在它的身体里。

private async void button1_Click(object sender, EventArgs e)
{
    // Call the method that runs asynchronously.
    string result = await WaitAsynchronouslyAsync();

    // Call the method that runs synchronously.
    //string result = await WaitSynchronously ();

    // Display the result.
    textBox1.Text += result;
}

// The following method runs asynchronously. The UI thread is not
// blocked during the delay. You can move or resize the Form1 window 
// while Task.Delay is running.
public async Task<string> WaitAsynchronouslyAsync()
{
    await Task.Delay(10000);
    return "Finished";
}

// The following method runs synchronously, despite the use of async.
// You cannot move or resize the Form1 window while Thread.Sleep
// is running because the UI thread is blocked.
public async Task<string> WaitSynchronously()
{
    // Add a using directive for System.Threading.
    Thread.Sleep(10000);
    return "Finished";
}

我想对此发表我的意见，如果任何其他答案包含我将解释的内容，我很抱歉，我读了大部分，但没有找到它，但我可能错过了一些东西。

我看到了很多错误的概念和很多好的解释，只是想解释一下异步与并行编程的区别，我相信这会让事情更容易理解。

当你需要做长时间的计算，处理器密集的工作，你应该选择使用并行编程，如果可能的话，以优化核心的使用。这将打开一些线程并同时处理一些事情。

假设你有一个数字数组，想要对每一个数字进行一些昂贵的长计算。平行是你的朋友。

异步编程在不同的用例中使用。

当你在等待一些不依赖于你的处理器的事情时，它用来释放你的线程，例如IO(写入和读取磁盘)，当你执行IO时，你的线程什么都不做，当你等待一个昂贵的查询结果从DB返回时也是一样。

异步方法在线程等待很长时间返回结果时释放线程。这个线程可以被应用程序的其他部分使用(例如，在web应用程序中，它可以处理其他请求)，也可以返回操作系统用于其他用途。

当您的结果完成时，相同的线程(或另一个线程)将返回给您的应用程序以继续处理。

在像。net这样的多线程环境中，异步编程不是强制性的(但是个很好的实践)，在web应用程序中，其他线程将响应新请求，但如果你是在像nodejs这样的单线程框架中，这是强制性的，因为你不能阻塞你唯一的线程，否则你将无法回答任何其他请求。

总而言之，长处理器密集型计算将从并行编程中受益更多，而不依赖于处理器的长等待时间，如IO或DB查询或对某些API的调用将从异步编程中受益更多。

这就是为什么Entity Framework有一个async api来保存、列表、查找等等…

记住async/await与wait或waitAll不同，上下文不同。Async/await释放线程，是异步编程。wait / waitAll阻塞所有线程(它们没有被释放)来强制并行上下文中的同步…不同的东西…

希望这对某些人有用…

这个答案旨在提供一些特定于ASP.NET的信息。

通过在MVC控制器中使用async/await，可以提高线程池的利用率，并实现更好的吞吐量，如下文所述。

http://www.asp.net/mvc/tutorials/mvc-4/using-asynchronous-methods-in-aspnet-mvc-4

在web应用程序中看到大量的并发请求 启动或有突发负载(并发性突然增加)， 使这些web服务调用异步将增加 应用程序的响应性。异步请求采用 处理同步请求所需的时间相同。例如, 如果一个请求进行了web服务调用，需要两秒钟才能完成 完成后，无论执行与否，请求都需要两秒钟 同步或异步。然而，在异步调用期间， 线程在运行时不会阻塞对其他请求的响应 等待第一个请求完成。因此,异步 请求阻止了请求队列和线程池的增长 调用长时间运行的操作的许多并发请求。

这里所有的答案都使用Task.Delay()或其他内置的异步函数。但下面是我的例子，没有使用这些async函数:

// Starts counting to a large number and then immediately displays message "I'm counting...". 
// Then it waits for task to finish and displays "finished, press any key".
static void asyncTest ()
{
    Console.WriteLine("Started asyncTest()");
    Task<long> task = asyncTest_count();
    Console.WriteLine("Started counting, please wait...");
    task.Wait(); // if you comment this line you will see that message "Finished counting" will be displayed before we actually finished counting.
    //Console.WriteLine("Finished counting to " + task.Result.ToString()); // using task.Result seems to also call task.Wait().
    Console.WriteLine("Finished counting.");
    Console.WriteLine("Press any key to exit program.");
    Console.ReadLine();
}

static async Task<long> asyncTest_count()
{
    long k = 0;
    Console.WriteLine("Started asyncTest_count()");
    await Task.Run(() =>
    {
        long countTo = 100000000;
        int prevPercentDone = -1;
        for (long i = 0; i <= countTo; i++)
        {
            int percentDone = (int)(100 * (i / (double)countTo));
            if (percentDone != prevPercentDone)
            {
                prevPercentDone = percentDone;
                Console.Write(percentDone.ToString() + "% ");
            }

            k = i;
        }
    });
    Console.WriteLine("");
    Console.WriteLine("Finished asyncTest_count()");
    return k;
}

根据我的理解，async和await所做的主要事情之一是使代码易于编写和阅读。

它们是为了让异步代码易于编写和阅读。

这和生成后台线程来执行长时间逻辑是一样的吗?

一点也不。

//我不明白为什么这个方法必须被标记为'async'。

async关键字启用await关键字。所以任何使用await的方法都必须被标记为async。

// DoSomethingAsync()方法在5秒休眠后到达该行。难道不应该立即到达吗?

不会，因为异步方法默认情况下不会在另一个线程上运行。

//是否在后台线程上执行?

No.

你可能会发现我的async/await介绍很有用。官方MSDN文档也非常好(尤其是TAP部分)，异步团队还发布了一个很好的FAQ。