使用 Async 和 Await 的 ASP.NET C#5 异步 Web 应用程序

研究了异步 Web 开发的概念，特别是来自this来源，我创建了一个示例应用程序来证明这个概念。

该解决方案由 2 个 ASP.NET Web API 应用程序组成。第一个是模拟的慢端点；它等待 1000 毫秒，然后返回一个名为 Student 的自定义类列表：

 public IEnumerable<Student> Get()
    {
        Thread.Sleep(1000);
        return new List<Student> { new Student { Name = @"Paul" }, new Student { Name = @"Steve" }, new Student { Name = @"Dave" }, new Student { Name = @"Sue" } };
    }

这是学生班级：

public class Student
{
    public string Name { get; set; }
}

此端点托管在 localhost:4002 上的 IIS 7 中。

第二个应用程序使用 2 个端点来联系第一个应用程序，一个是同步的，另一个是异步的：

public IEnumerable<Student> Get() {
        var proxy = WebRequest.Create(@"http://localhost:4002/api/values");

        var response = proxy.GetResponse();
        var reader = new StreamReader(response.GetResponseStream());

        return JsonConvert.DeserializeObject<IEnumerable<Student>>(reader.ReadToEnd());
    }

    public async Task<IEnumerable<Student>> Get(int id) {
        var proxy = new HttpClient();
        var getStudents = proxy.GetStreamAsync(@"http://localhost:4002/api/values");

        var stream = await getStudents;
        var reader = new StreamReader(stream);

        return JsonConvert.DeserializeObject<IEnumerable<Student>>(reader.ReadToEnd());
    }

它托管在 localhost:4001 上的 IIS 7 中。

两个端点均按预期工作，并在大约时间内返回。 1秒。根据上面链接中 13:25 的视频，异步方法应该释放其线程，从而最大限度地减少争用。

我正在使用 Apache Bench 对应用程序运行性能测试。以下是具有 10 个并发请求的同步方法的响应时间：

这正如我所期望的那样；更多并发连接会增加争用并延长响应时间。但是，以下是异步响应时间：

正如您所看到的，似乎仍然存在一些争论。我原本期望平均响应时间会更加平衡。如果我在两个端点上运行 50 个并发请求的测试，我仍然会得到类似的结果。

基于此，异步和同步方法似乎都以或多或少相同的速度运行（预期），没有考虑异步方法的开销，而且异步方法似乎没有释放回线程到线程池。我欢迎任何评论或澄清，谢谢。

我认为您很有可能没有测试您认为正在测试的内容。据我所知，您正在尝试通过比较时间并推断线程注入来检测返回线程池的释放。

一方面，.NET 4.5 上线程池的默认设置非常高。您不会仅通过 10 或 100 个同时请求来击中他们。

退一步想想你想要测试什么：异步方法是否将其线程返回到线程池？

我有一个演示来演示这一点。我不想为我的演示创建重负载测试（在我的演示笔记本电脑上运行），因此我使用了一个小技巧：我人为地将线程池限制为更合理的值。

一旦你这样做了，你的测试就非常简单：执行那么多的并发连接，然后执行那么多的连接plus one。同步实现必须等待其中一个完成才能启动最后一个，而异步实现将能够启动所有这些。

在服务器端，首先将线程池线程限制为系统中处理器的数量：

protected void Application_Start()
{
    int workerThreads, ioThreads;
    ThreadPool.GetMaxThreads(out workerThreads, out ioThreads);
    ThreadPool.SetMaxThreads(Environment.ProcessorCount, ioThreads);
    ...
}

然后进行同步和异步实现：

public class ValuesController : ApiController
{
    // Synchronous
    public IEnumerable<string> Get()
    {
        Thread.Sleep(1000);
        return new string[] { "value1", "value2" };
    }

    // Asynchronous
    public async Task<IEnumerable<string>> Get(int id)
    {
        await Task.Delay(1000);
        return new string[] { "value1", "value2" };
    }
}

最后是客户端测试代码：

static void Main(string[] args)
{
    try
    {
        MainAsync().Wait();
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex);
    }

    Console.ReadKey();
}

static async Task MainAsync()
{
    ServicePointManager.DefaultConnectionLimit = int.MaxValue;

    var sw = new Stopwatch();
    var client = new HttpClient();
    var connections = Environment.ProcessorCount;
    var url = "http://localhost:35697/api/values/";

    await client.GetStringAsync(url); // warmup
    sw.Start();
    await Task.WhenAll(Enumerable.Range(0, connections).Select(i => client.GetStringAsync(url)));
    sw.Stop();
    Console.WriteLine("Synchronous time for " + connections + " connections: " + sw.Elapsed);

    connections = Environment.ProcessorCount + 1;

    await client.GetStringAsync(url); // warmup
    sw.Restart();
    await Task.WhenAll(Enumerable.Range(0, connections).Select(i => client.GetStringAsync(url)));
    sw.Stop();
    Console.WriteLine("Synchronous time for " + connections + " connections: " + sw.Elapsed);

    url += "13";
    connections = Environment.ProcessorCount;

    await client.GetStringAsync(url); // warmup
    sw.Restart();
    await Task.WhenAll(Enumerable.Range(0, connections).Select(i => client.GetStringAsync(url)));
    sw.Stop();
    Console.WriteLine("Asynchronous time for " + connections + " connections: " + sw.Elapsed);

    connections = Environment.ProcessorCount + 1;

    await client.GetStringAsync(url); // warmup
    sw.Restart();
    await Task.WhenAll(Enumerable.Range(0, connections).Select(i => client.GetStringAsync(url)));
    sw.Stop();
    Console.WriteLine("Asynchronous time for " + connections + " connections: " + sw.Elapsed);
}

在我的（8 个逻辑核心）机器上，我看到如下输出：

Synchronous time for 8 connections: 00:00:01.0194025
Synchronous time for 9 connections: 00:00:02.0362007
Asynchronous time for 8 connections: 00:00:01.0413737
Asynchronous time for 9 connections: 00:00:01.0238674

这清楚地表明异步方法正在将其线程返回到线程池。