fix: HttpClients created by HttpClientFactory.CreateHttpClient (including the shared static clients) now replace pooled connections every 2 minutes, so long-running processes pick up DNS changes

Author: anthonyreilly

CHANGELOG.md

@@ -4,6 +4,10 @@
 
 * fix: ForceClient, JsonClient and AuthenticationClient no longer dispose an HttpClient passed in by the caller - the caller owns it
 * fix: AuthenticationClient now uses a shared static HttpClient by default, like ForceClient and JsonClient, instead of creating a new HttpClient (and connection pool) per instance - repeated logins no longer leak sockets
+* fix: HttpClients created by HttpClientFactory.CreateHttpClient (including the shared static clients) now replace pooled connections every 2 minutes, so long-running processes pick up DNS changes
+    - .NET 8+: uses SocketsHttpHandler with PooledConnectionLifetime (except on browser and mobile platforms, which keep their native handler)
+    - .NET Framework: sets ServicePoint.ConnectionLeaseTimeout for each request's host
+    - .NET Standard builds are unchanged
 
 ### 2026-10-06 v6.0.0
 

docs/auth.md

@@ -123,7 +123,7 @@ HttpClient proxyClient = HttpClientFactory.CreateHttpClient(true, "http://your-p
 ForceClient client = new ForceClient("your-client-id", "your-client-secret", "your-username", "your-password", "https://login.salesforce.com/services/oauth2/token", httpClient: proxyClient);
 ```
 
-The caller owns an `HttpClient` passed in this way - disposing `ForceClient`, `JsonClient` or `AuthenticationClient` does not dispose it, so a single long-lived instance can be shared across clients.
+The caller owns an `HttpClient` passed in this way - disposing `ForceClient`, `JsonClient` or `AuthenticationClient` does not dispose it, so a single long-lived instance can be shared across clients. Clients built by `HttpClientFactory.CreateHttpClient` periodically replace their pooled connections so DNS changes are picked up; if you build your own `HttpClient`, configure that yourself (e.g. `SocketsHttpHandler.PooledConnectionLifetime`).
 
 ---
 

src/NetCoreForce.Client.Tests/HttpClientFactoryTests.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Threading.Tasks;
+using NetCoreForce.Client;
+using Xunit;
+
+namespace NetCoreForce.Client.Tests
+{
+    public class HttpClientFactoryTests
+    {
+        [Fact]
+        public void CreateHttpClientRequestsCompression()
+        {
+            HttpClient httpClient = HttpClientFactory.CreateHttpClient();
+
+            Assert.Contains(httpClient.DefaultRequestHeaders.AcceptEncoding, e => e.Value == "gzip");
+            Assert.Contains(httpClient.DefaultRequestHeaders.AcceptEncoding, e => e.Value == "deflate");
+        }
+
+#if NET
+        [Fact]
+        public void CreateHandlerSetsPooledConnectionLifetime()
+        {
+            // without a connection lifetime, a long-lived HttpClient never picks up DNS changes
+            bool decompress;
+            HttpMessageHandler handler = HttpClientFactory.CreateHandler(true, null, out decompress);
+
+            SocketsHttpHandler socketsHandler = Assert.IsType<SocketsHttpHandler>(handler);
+            Assert.Equal(HttpClientFactory.ConnectionLifetime, socketsHandler.PooledConnectionLifetime);
+            Assert.Equal(DecompressionMethods.GZip | DecompressionMethods.Deflate, socketsHandler.AutomaticDecompression);
+            Assert.True(decompress);
+        }
+
+        [Fact]
+        public void CreateHandlerSetsProxy()
+        {
+            bool decompress;
+            HttpMessageHandler handler = HttpClientFactory.CreateHandler(false, "http://proxy.example.org:8080", out decompress);
+
+            SocketsHttpHandler socketsHandler = Assert.IsType<SocketsHttpHandler>(handler);
+            Assert.IsType<CustomProxy>(socketsHandler.Proxy);
+            Assert.Equal(DecompressionMethods.None, socketsHandler.AutomaticDecompression);
+            Assert.False(decompress);
+        }
+#endif
+
+#if NETFRAMEWORK
+        [Fact]
+        public void CreateHandlerWrapsWithConnectionLeaseHandler()
+        {
+            bool decompress;
+            HttpMessageHandler handler = HttpClientFactory.CreateHandler(true, null, out decompress);
+
+            Assert.IsType<HttpClientFactory.ConnectionLeaseHandler>(handler);
+        }
+
+        [Fact]
+        public async Task ConnectionLeaseHandlerSetsServicePointLeaseTimeout()
+        {
+            // without a lease timeout, ServicePoint keeps connections open indefinitely and never picks up DNS changes
+            Uri uri = new Uri("http://lease.example.org/test");
+
+            var mockHandler = new MockHttpClientHandler();
+            mockHandler.AddMockResponse(uri, new HttpResponseMessage(HttpStatusCode.OK));
+
+            HttpClient httpClient = new HttpClient(new HttpClientFactory.ConnectionLeaseHandler(mockHandler));
+            await httpClient.GetAsync(uri);
+
+            Assert.Equal((int)HttpClientFactory.ConnectionLifetime.TotalMilliseconds, ServicePointManager.FindServicePoint(uri).ConnectionLeaseTimeout);
+        }
+#endif
+    }
+}

src/NetCoreForce.Client/HttpClientFactory.cs

@@ -21,28 +21,110 @@ public class HttpClientFactory
         private const string GZipEncoding = "gzip";
         private const string DeflateEncoding = "deflate";
 
+        /// <summary>
+        /// How long a pooled connection is reused before being replaced.
+        /// <para>HttpClient instances are long-lived, so without this, connections are kept open indefinitely and DNS changes are never picked up.</para>
+        /// </summary>
+        internal static readonly TimeSpan ConnectionLifetime = TimeSpan.FromMinutes(2);
+
+        /// <summary>
+        /// Create an HttpClient, intended to be long-lived and shared.
+        /// <para>On .NET 8+ and .NET Framework, pooled connections are periodically replaced so DNS changes are picked up.</para>
+        /// </summary>
+        /// <param name="useCompression">Request gzip/deflate compressed responses</param>
+        /// <param name="proxyUrl">Proxy URL (Optional)</param>
         public static HttpClient CreateHttpClient(bool useCompression = true, string proxyUrl = null)
         {
+            bool decompress;
+            HttpMessageHandler handler = CreateHandler(useCompression, proxyUrl, out decompress);
+
+            HttpClient httpClient = new HttpClient(handler);
+
+            if (decompress)
+            {
+                httpClient.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue(GZipEncoding));
+                httpClient.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue(DeflateEncoding));
+            }
+
+            return httpClient;
+        }
+
+        internal static HttpMessageHandler CreateHandler(bool useCompression, string proxyUrl, out bool decompress)
+        {
+#if NET
+            if (UseSocketsHttpHandler())
+            {
+                var socketsHandler = new SocketsHttpHandler
+                {
+                    PooledConnectionLifetime = ConnectionLifetime
+                };
+
+                decompress = useCompression;
+                if (decompress)
+                {
+                    socketsHandler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
+                }
+
+                if (!string.IsNullOrEmpty(proxyUrl))
+                {
+                    socketsHandler.Proxy = new CustomProxy(proxyUrl);
+                }
+
+                return socketsHandler;
+            }
+#endif
+
             var handler = new HttpClientHandler();
-            if (useCompression && handler.SupportsAutomaticDecompression)
+
+            decompress = useCompression && handler.SupportsAutomaticDecompression;
+            if (decompress)
             {
                 handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
             }
 
-            if(!string.IsNullOrEmpty(proxyUrl))
+            if (!string.IsNullOrEmpty(proxyUrl))
             {
                 handler.Proxy = new CustomProxy(proxyUrl);
             }
 
-            HttpClient httpClient = new HttpClient(handler);
+#if NETFRAMEWORK
+            return new ConnectionLeaseHandler(handler);
+#else
+            return handler;
+#endif
+        }
+
+#if NET
+        /// <summary>
+        /// On browser and mobile platforms HttpClientHandler wraps the platform's native handler, which manages its own connections - keep it there.
+        /// </summary>
+        private static bool UseSocketsHttpHandler()
+        {
+            return SocketsHttpHandler.IsSupported
+                && !OperatingSystem.IsAndroid()
+                && !OperatingSystem.IsIOS()
+                && !OperatingSystem.IsTvOS()
+                && !OperatingSystem.IsMacCatalyst();
+        }
+#endif
+
+#if NETFRAMEWORK
+        /// <summary>
+        /// On .NET Framework, HttpClientHandler connections are managed by ServicePoint, which keeps them open indefinitely by default.
+        /// <para>Sets a connection lease timeout on the ServicePoint for each request's host, so connections are periodically replaced and DNS changes are picked up.</para>
+        /// </summary>
+        internal class ConnectionLeaseHandler : DelegatingHandler
+        {
+            public ConnectionLeaseHandler(HttpMessageHandler innerHandler) : base(innerHandler) { }
 
-            if (useCompression && handler.SupportsAutomaticDecompression)
+            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
             {
-                httpClient.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue(GZipEncoding));
-                httpClient.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue(DeflateEncoding));
-            }
+                //set on every request, since an idle ServicePoint is discarded and recreated with the default timeout
+                ServicePointManager.FindServicePoint(request.RequestUri).ConnectionLeaseTimeout = (int)ConnectionLifetime.TotalMilliseconds;
 
-            return httpClient;
+                return base.SendAsync(request, cancellationToken);
+            }
         }
+#endif
     }
-}
+}

src/NetCoreForce.Client/NetCoreForce.Client.csproj

@@ -18,6 +18,10 @@
     <None Include="README.md" Pack="true" PackagePath="\" />
   </ItemGroup>
 
+  <ItemGroup>
+    <InternalsVisibleTo Include="NetCoreForce.Client.Tests" />
+  </ItemGroup>
+
   <PropertyGroup>
     <!-- Documentation -->
     <GenerateDocumentationFile>true</GenerateDocumentationFile>