Make SocketsHttpHandler the default primary handler from HttpClientFactory (#101808)

Today the default handler is HttpClientHandler, which is just a wrapper around SocketsHttpHandler on platforms where SocketsHttpHandler is supported. This means that the configuration possible on SocketsHttpHandler isn't available as part of the default handling, which means consumers get the default PooledConnectionLifetime of infinite. The lack of that was one of the main motivations behind HttpClientFactory's handler lifetime and handler recycling. Instead of constructing an HttpClientHandler as the default handler, we can construct a SocketsHttpHandler as the default handler, and we can set its PooledConnectionLifetime to match the HttpClientFactoryOptions.HandlerLifetime, whether its default of 2 minutes or whatever a user configured it to be. This in turn means that if code gets and holds on to a handler/client from the factory for a prolonged period of time, it's still getting the connection recycling according to its configured options.

Author: stephentoub

src/libraries/Microsoft.Extensions.Http/src/DefaultHttpMessageHandlerBuilder.cs

@@ -5,18 +5,22 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Net.Http;
+using System.Threading;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 
 namespace Microsoft.Extensions.Http
 {
     internal sealed class DefaultHttpMessageHandlerBuilder : HttpMessageHandlerBuilder
     {
+        private HttpMessageHandler? _primaryHandler;
+        private string? _name;
+
         public DefaultHttpMessageHandlerBuilder(IServiceProvider services)
         {
             Services = services;
         }
 
-        private string? _name;
-
         [DisallowNull]
         public override string? Name
         {
@@ -28,7 +32,11 @@ public override string? Name
             }
         }
 
-        public override HttpMessageHandler PrimaryHandler { get; set; } = new HttpClientHandler();
+        public override HttpMessageHandler PrimaryHandler
+        {
+            get => _primaryHandler ??= CreatePrimaryHandler();
+            set => _primaryHandler = value;
+        }
 
         public override IList<DelegatingHandler> AdditionalHandlers { get; } = new List<DelegatingHandler>();
 
@@ -44,5 +52,36 @@ public override HttpMessageHandler Build()
 
             return CreateHandlerPipeline(PrimaryHandler, AdditionalHandlers);
         }
+
+#pragma warning disable CA1822, CA1859 // Mark members as static, Use concrete types when possible for improved performance
+        private HttpMessageHandler CreatePrimaryHandler()
+#pragma warning restore CA1822, CA1859
+        {
+#if NET
+            // On platforms where SocketsHttpHandler is supported, HttpClientHandler is a thin wrapper
+            // around it. By using SocketsHttpHandler directly, we can avoid the overhead of the wrapper,
+            // but more importantly, we can configure it to limit the lifetime of its pooled connections
+            // to match the requested lifetime of the handler itself. That way, if/when someone holds on
+            // to a resulting HttpClient for a prolonged period of time, it'll still benefit from connection
+            // recycling, and without needing to tear down and reconstitute the rest of the handler pipeline.
+            if (SocketsHttpHandler.IsSupported)
+            {
+                SocketsHttpHandler handler = new();
+
+                if (Services.GetService<IOptionsMonitor<HttpClientFactoryOptions>>() is IOptionsMonitor<HttpClientFactoryOptions> optionsMonitor)
+                {
+                    TimeSpan lifetime = optionsMonitor.Get(_name).HandlerLifetime;
+                    if (lifetime >= TimeSpan.Zero)
+                    {
+                        handler.PooledConnectionLifetime = lifetime;
+                    }
+                }
+
+                return handler;
+            }
+#endif
+
+            return new HttpClientHandler();
+        }
     }
 }

src/libraries/Microsoft.Extensions.Http/tests/Microsoft.Extensions.Http.Tests/DefaultHttpMessageHandlerBuilderTest.cs

@@ -28,7 +28,16 @@ public void Ctor_SetsPrimaryHandler()
             var builder = new DefaultHttpMessageHandlerBuilder(Services);
 
             // Act
-            Assert.IsType<HttpClientHandler>(builder.PrimaryHandler);
+#if NET
+            if (SocketsHttpHandler.IsSupported)
+            {
+                Assert.IsType<SocketsHttpHandler>(builder.PrimaryHandler);
+            }
+            else
+#endif
+            {
+                Assert.IsType<HttpClientHandler>(builder.PrimaryHandler);
+            }
         }
 
         // Moq heavily utilizes RefEmit, which does not work on most aot workloads
@@ -78,7 +87,7 @@ public void Build_SomeAdditionalHandlers_PutsTogetherDelegatingHandlers()
 
         [Fact]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/50873", TestPlatforms.Android)]
-        public void Build_PrimaryHandlerIsNull_ThrowsException()
+        public void Build_PrimaryHandlerIsNull_UsesDefault()
         {
             // Arrange
             var builder = new DefaultHttpMessageHandlerBuilder(Services)
@@ -87,8 +96,8 @@ public void Build_PrimaryHandlerIsNull_ThrowsException()
             };
 
             // Act & Assert
-            var exception = Assert.Throws<InvalidOperationException>(() => builder.Build());
-            Assert.Equal("The 'PrimaryHandler' must not be null.", exception.Message);
+            var handler = builder.Build();
+            Assert.NotNull(handler);
         }
 
         [Fact]

src/libraries/Microsoft.Extensions.Http/tests/Microsoft.Extensions.Http.Tests/SocketsHttpHandlerConfigurationTest.cs

@@ -42,10 +42,41 @@ public void UseSocketsHttpHandler_Parameterless_Success()
             var defaultPrimaryHandlerChain = messageHandlerFactory.CreateHandler("DefaultPrimaryHandler");
             var socketsHttpHandlerChain = messageHandlerFactory.CreateHandler("SocketsHttpHandler");
 
-            Assert.IsType<HttpClientHandler>(GetPrimaryHandler(defaultPrimaryHandlerChain));
+            Assert.IsType<SocketsHttpHandler>(GetPrimaryHandler(defaultPrimaryHandlerChain));
             Assert.IsType<SocketsHttpHandler>(GetPrimaryHandler(socketsHttpHandlerChain));
         }
 
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+        public void DefaultPrimaryHandler_RespectsHandlerLifetime()
+        {
+            var serviceCollection = new ServiceCollection();
+            serviceCollection.AddHttpClient();
+            serviceCollection.Configure<HttpClientFactoryOptions>(options => options.HandlerLifetime = TimeSpan.FromMinutes(42));
+
+            var services = serviceCollection.BuildServiceProvider();
+            var messageHandlerFactory = services.GetRequiredService<IHttpMessageHandlerFactory>();
+            var defaultPrimaryHandlerChain = messageHandlerFactory.CreateHandler();
+
+            SocketsHttpHandler handler = Assert.IsType<SocketsHttpHandler>(GetPrimaryHandler(defaultPrimaryHandlerChain));
+            Assert.Equal(TimeSpan.FromMinutes(42), handler.PooledConnectionLifetime);
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+        public void DefaultPrimaryHandler_NamedClient_RespectsHandlerLifetime()
+        {
+            var serviceCollection = new ServiceCollection();
+            serviceCollection.AddHttpClient("Configured");
+            serviceCollection.Configure<HttpClientFactoryOptions>("Configured1", options => options.HandlerLifetime = TimeSpan.FromMinutes(42));
+            serviceCollection.Configure<HttpClientFactoryOptions>("Configured2", options => options.HandlerLifetime = TimeSpan.FromMinutes(84));
+
+            var services = serviceCollection.BuildServiceProvider();
+            var messageHandlerFactory = services.GetRequiredService<IHttpMessageHandlerFactory>();
+
+            Assert.Equal(TimeSpan.FromMinutes(42), Assert.IsType<SocketsHttpHandler>(GetPrimaryHandler(messageHandlerFactory.CreateHandler("Configured1"))).PooledConnectionLifetime);
+            Assert.Equal(TimeSpan.FromMinutes(84), Assert.IsType<SocketsHttpHandler>(GetPrimaryHandler(messageHandlerFactory.CreateHandler("Configured2"))).PooledConnectionLifetime);
+            Assert.Equal(TimeSpan.FromMinutes(2), Assert.IsType<SocketsHttpHandler>(GetPrimaryHandler(messageHandlerFactory.CreateHandler())).PooledConnectionLifetime);
+        }
+
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
         public void UseSocketsHttpHandler_ConfiguredByAction_Success()
         {
@@ -66,7 +97,7 @@ public void UseSocketsHttpHandler_ConfiguredByAction_Success()
             var unconfiguredHandler = (SocketsHttpHandler)GetPrimaryHandler(unconfiguredHandlerChain);
             var configuredHandler = (SocketsHttpHandler)GetPrimaryHandler(configuredHandlerChain);
 
-            Assert.Equal(Timeout.InfiniteTimeSpan, unconfiguredHandler.PooledConnectionLifetime);
+            Assert.Equal(TimeSpan.FromMinutes(2), unconfiguredHandler.PooledConnectionLifetime);
             Assert.Equal(TimeSpan.FromMinutes(1), configuredHandler.PooledConnectionLifetime);
         }