Caching handlers

Author: soenneker

src/HandlerKey.cs

@@ -0,0 +1,4 @@
+namespace Soenneker.Utils.HttpClientCache
+{
+    internal readonly record struct HandlerKey(double LifetimeSeconds, int MaxConnections, bool UseCookies);
+}

src/HttpClientCache.cs

@@ -1,14 +1,17 @@
-using System;
+using Soenneker.Dtos.HttpClientOptions;
+using Soenneker.Extensions.Enumerable;
+using Soenneker.Extensions.ValueTask;
+using Soenneker.Utils.HttpClientCache.Abstract;
+using Soenneker.Utils.Runtime;
+using Soenneker.Utils.SingletonDictionary;
+using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Net;
 using System.Net.Http;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
-using Soenneker.Dtos.HttpClientOptions;
-using Soenneker.Extensions.ValueTask;
-using Soenneker.Utils.HttpClientCache.Abstract;
-using Soenneker.Utils.Runtime;
-using Soenneker.Utils.SingletonDictionary;
 
 namespace Soenneker.Utils.HttpClientCache;
 
@@ -17,6 +20,8 @@ public class HttpClientCache : IHttpClientCache
 {
     private readonly SingletonDictionary<HttpClient> _httpClients;
 
+    private readonly ConcurrentDictionary<HandlerKey, SocketsHttpHandler> _handlers = new();
+
     public HttpClientCache()
     {
         _httpClients = new SingletonDictionary<HttpClient>(async args =>
@@ -43,14 +48,14 @@ public HttpClientCache()
         });
     }
 
-    private static HttpClient CreateHttpClient(HttpClientOptions? options)
+    private HttpClient CreateHttpClient(HttpClientOptions? options)
     {
         if (RuntimeUtil.IsBrowser())
         {
             return options?.HttpClientHandler != null ? new HttpClient(options.HttpClientHandler) : new HttpClient();
         }
 
-        return options?.HttpClientHandler != null ? new HttpClient(options.HttpClientHandler) : new HttpClient(CreateSocketsHttpHandler(options));
+        return options?.HttpClientHandler != null ? new HttpClient(options.HttpClientHandler) : new HttpClient(GetOrCreateHandler(options));
     }
 
     public ValueTask<HttpClient> Get(string id, HttpClientOptions? options = null, CancellationToken cancellationToken = default)
@@ -85,38 +90,53 @@ public HttpClient GetSync(string id, Func<HttpClientOptions?> optionsFactory, Ca
         return _httpClients.GetSync(id, cancellationToken, options);
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static async ValueTask ConfigureHttpClient(HttpClient httpClient, HttpClientOptions? options)
     {
         httpClient.Timeout = options?.Timeout ?? TimeSpan.FromSeconds(100);
 
         if (options?.BaseAddress != null)
-            httpClient.BaseAddress = new Uri(options.BaseAddress);
+        {
+            Uri baseUri = new(options.BaseAddress);
+
+            if (!Equals(httpClient.BaseAddress, baseUri))
+                httpClient.BaseAddress = baseUri;
+        }
 
         AddDefaultRequestHeaders(httpClient, options?.DefaultRequestHeaders);
 
-        if (options?.ModifyClient != null)
-            await options.ModifyClient.Invoke(httpClient).NoSync();
+        Func<HttpClient, ValueTask>? modifyClient = options?.ModifyClient;
+
+        if (modifyClient is not null)
+            await modifyClient(httpClient).NoSync();
     }
 
-    private static SocketsHttpHandler CreateSocketsHttpHandler(HttpClientOptions? options)
+    private SocketsHttpHandler GetOrCreateHandler(HttpClientOptions? options)
     {
-        var handler = new SocketsHttpHandler
-        {
-            PooledConnectionLifetime = options?.PooledConnectionLifetime ?? TimeSpan.FromMinutes(10),
-            MaxConnectionsPerServer = options?.MaxConnectionsPerServer ?? 40
-        };
+        var key = new HandlerKey(
+            options?.PooledConnectionLifetime?.TotalSeconds ?? 600,
+            options?.MaxConnectionsPerServer ?? 40,
+            options?.UseCookieContainer == true
+        );
 
-        if (options?.UseCookieContainer == true)
+        return _handlers.GetOrAdd(key, _ =>
         {
-            handler.CookieContainer = new CookieContainer();
-        }
+            var handler = new SocketsHttpHandler
+            {
+                PooledConnectionLifetime = TimeSpan.FromSeconds(key.LifetimeSeconds),
+                MaxConnectionsPerServer = key.MaxConnections
+            };
+
+            if (key.UseCookies)
+                handler.CookieContainer = new CookieContainer();
 
-        return handler;
+            return handler;
+        });
     }
 
     private static void AddDefaultRequestHeaders(HttpClient httpClient, Dictionary<string, string>? headers)
     {
-        if (headers == null)
+        if (headers.IsNullOrEmpty())
             return;
 
         foreach (KeyValuePair<string, string> header in headers)
@@ -138,12 +158,26 @@ public void RemoveSync(string id)
     public ValueTask DisposeAsync()
     {
         GC.SuppressFinalize(this);
+
+        foreach (KeyValuePair<HandlerKey, SocketsHttpHandler> kvp in _handlers.ToArray())
+        {
+            if (_handlers.TryRemove(kvp.Key, out SocketsHttpHandler? handler))
+                handler.Dispose();
+        }
+
         return _httpClients.DisposeAsync();
     }
 
     public void Dispose()
     {
         GC.SuppressFinalize(this);
+
+        foreach (KeyValuePair<HandlerKey, SocketsHttpHandler> kvp in _handlers.ToArray())
+        {
+            if (_handlers.TryRemove(kvp.Key, out SocketsHttpHandler? handler))
+                handler.Dispose();
+        }
+
         _httpClients.Dispose();
     }
 }