StephenCleary · April 17, 2020 03:05 · Sep 24, 2019 · Sep 24, 2019 · Sep 24, 2019 · Sep 24, 2019
diff --git a/Async WebAPI.txt → Async WebAPI b/Async WebAPI.txt → Async WebAPI
diff --git a/_Async WebAPI.txt → Async WebAPI.txt b/_Async WebAPI.txt → Async WebAPI.txt
diff --git a/Async WebAPI (Example Output) → Example Output b/Async WebAPI (Example Output) → Example Output
diff --git a/_Async WebAPI.txt b/_Async WebAPI.txt
@@ -0,0 +1 @@
+Simple WebAPI app with Console client that shows that async methods do release threads to the thread pool.
diff --git a/Example Output → Async WebAPI (Example Output) b/Example Output → Async WebAPI (Example Output)
diff --git a/Program.cs b/Program.cs
@@ -27,40 +27,37 @@ 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/";
+        int connections;
+        var syncUrl = "http://localhost:35697/api/values/";
+        var asyncUrl = "http://localhost:35697/api/values/13";
 
-        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;
+        Console.WriteLine(" Synchronous time for " + connections + " connections: " +
+            await RunTest(syncUrl, connections));
 
         connections = Environment.ProcessorCount + 1;
+        Console.WriteLine(" Synchronous time for " + connections + " connections: " +
+            await RunTest(syncUrl, connections));
 
-        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);
+        Console.WriteLine("Asynchronous time for " + connections + " connections: " +
+            await RunTest(asyncUrl, connections));
 
         connections = Environment.ProcessorCount + 1;
+        Console.WriteLine("Asynchronous time for " + connections + " connections: " +
+            await RunTest(asyncUrl, connections));
+    }
+
+    static async Task<TimeSpan> RunTest(string url, int concurrentConnections)
+    {
+        var sw = new Stopwatch();
+        var client = new HttpClient();
 
         await client.GetStringAsync(url); // warmup
-        sw.Restart();
-        await Task.WhenAll(Enumerable.Range(0, connections).Select(i => client.GetStringAsync(url)));
+        sw.Start();
+        await Task.WhenAll(Enumerable.Range(0, concurrentConnections).Select(i => client.GetStringAsync(url)));
         sw.Stop();
-        Console.WriteLine("Asynchronous time for " + connections + " connections: " + sw.Elapsed);
+
+        return sw.Elapsed;
     }
 }
diff --git a/Example Output b/Example Output
@@ -0,0 +1,4 @@
+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
diff --git a/Global.asax.cs b/Global.asax.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Web;
+using System.Web.Http;
+using System.Web.Mvc;
+using System.Web.Optimization;
+using System.Web.Routing;
+
+namespace MvcApplication2
+{
+    // Note: For instructions on enabling IIS6 or IIS7 classic mode, 
+    // visit http://go.microsoft.com/?LinkId=9394801
+
+    public class WebApiApplication : System.Web.HttpApplication
+    {
+        protected void Application_Start()
+        {
+            // Begin Changes
+            int workerThreads, ioThreads;
+            ThreadPool.GetMaxThreads(out workerThreads, out ioThreads);
+            ThreadPool.SetMaxThreads(Environment.ProcessorCount, ioThreads);
+            // End Changes
+
+            AreaRegistration.RegisterAllAreas();
+
+            WebApiConfig.Register(GlobalConfiguration.Configuration);
+            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
+            RouteConfig.RegisterRoutes(RouteTable.Routes);
+            BundleConfig.RegisterBundles(BundleTable.Bundles);
+        }
+    }
+}
diff --git a/Program.cs b/Program.cs
@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+
+class Program
+{
+    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);
+    }
+}
diff --git a/ValuesController.cs b/ValuesController.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web.Http;
+
+namespace MvcApplication2.Controllers
+{
+    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" };
+        }
+    }
+}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		Simple WebAPI app with Console client that shows that async methods do release threads to the thread pool.