Make SocketsHttpHandler the default primary handler from HttpClientFactory

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);
         }