Add the ability to register Refit clients as keyed services (#1981)

fubar-coder · web-flow · commit 8257b379ffd9 · 2025-05-01T05:58:14.000+01:00
* Add the ability to register Refit clients as keyed services

* Ensure that we have a HttpClient per service key

This can be achieved by adding `$";{serviceKey}"` to the `httpClientName`

* Second take to fix the HTTP client name

* Better output
diff --git a/Refit.HttpClientFactory/HttpClientFactoryExtensions.cs b/Refit.HttpClientFactory/HttpClientFactoryExtensions.cs
@@ -28,6 +28,24 @@ public static IHttpClientBuilder AddRefitClient<T>(
             return AddRefitClient<T>(services, _ => settings);
         }
 
+        /// <summary>
+        /// Adds a Refit client to the DI container
+        /// </summary>
+        /// <typeparam name="T">Type of the Refit interface</typeparam>
+        /// <param name="services">container</param>
+        /// <param name="serviceKey">An optional key to associate with the specific Refit client instance</param>
+        /// <param name="settings">Optional. Settings to configure the instance with</param>
+        /// <returns></returns>
+        public static IHttpClientBuilder AddKeyedRefitClient<T>(
+            this IServiceCollection services,
+            object? serviceKey,
+            RefitSettings? settings = null
+        )
+            where T : class
+        {
+            return AddKeyedRefitClient<T>(services, serviceKey, _ => settings);
+        }
+
         /// <summary>
         /// Adds a Refit client to the DI container
         /// </summary>
@@ -44,6 +62,24 @@ public static IHttpClientBuilder AddRefitClient(
             return AddRefitClient(services, refitInterfaceType, _ => settings);
         }
 
+        /// <summary>
+        /// Adds a Refit client to the DI container
+        /// </summary>
+        /// <param name="services">container</param>
+        /// <param name="refitInterfaceType">Type of the Refit interface</param>
+        /// <param name="serviceKey">An optional key to associate with the specific Refit client instance</param>
+        /// <param name="settings">Optional. Settings to configure the instance with</param>
+        /// <returns></returns>
+        public static IHttpClientBuilder AddKeyedRefitClient(
+            this IServiceCollection services,
+            Type refitInterfaceType,
+            object? serviceKey,
+            RefitSettings? settings = null
+        )
+        {
+            return AddKeyedRefitClient(services, refitInterfaceType, serviceKey, _ => settings);
+        }
+
         /// <summary>
         /// Adds a Refit client to the DI container
         /// </summary>
@@ -91,6 +127,60 @@ public static IHttpClientBuilder AddRefitClient<T>(
                 );
         }
 
+        /// <summary>
+        /// Adds a Refit client to the DI container with a specified service key
+        /// </summary>
+        /// <typeparam name="T">Type of the Refit interface</typeparam>
+        /// <param name="services">container</param>
+        /// <param name="serviceKey">An optional key to associate with the specific Refit client instance</param>
+        /// <param name="settingsAction">Optional. Action to configure refit settings.  This method is called once and only once, avoid using any scoped dependencies that maybe be disposed automatically.</param>
+        /// <param name="httpClientName">Optional. Allows users to change the HttpClient name as provided to IServiceCollection.AddHttpClient. Useful for logging scenarios.</param>
+        /// <returns></returns>
+        public static IHttpClientBuilder AddKeyedRefitClient<T>(
+            this IServiceCollection services,
+            object? serviceKey,
+            Func<IServiceProvider, RefitSettings?>? settingsAction,
+            string? httpClientName = null
+        )
+            where T : class
+        {
+            services.AddKeyedSingleton(serviceKey,
+                (provider, _) => new SettingsFor<T>(settingsAction?.Invoke(provider)));
+            services.AddKeyedSingleton(
+                serviceKey,
+                (provider, _) =>
+                    RequestBuilder.ForType<T>(
+                        provider.GetRequiredKeyedService<SettingsFor<T>>(serviceKey).Settings
+                    )
+            );
+
+            return services
+                .AddHttpClient(httpClientName ?? UniqueName.ForType<T>(serviceKey))
+                .ConfigurePrimaryHttpMessageHandler(serviceProvider =>
+                {
+                    var settings = serviceProvider.GetRequiredKeyedService<SettingsFor<T>>(serviceKey).Settings;
+                    return
+                        settings?.HttpMessageHandlerFactory?.Invoke()
+                        ?? new HttpClientHandler();
+                })
+                .ConfigureAdditionalHttpMessageHandlers((handlers, serviceProvider) =>
+                {
+                    var settings = serviceProvider.GetRequiredKeyedService<SettingsFor<T>>(serviceKey).Settings;
+                    if (settings?.AuthorizationHeaderValueGetter is { } getToken)
+                    {
+                        handlers.Add(new AuthenticatedHttpClientHandler(null, getToken));
+                    }
+                })
+                .AddKeyedTypedClient(
+                    serviceKey,
+                    (client, serviceProvider) =>
+                        RestService.For<T>(
+                            client,
+                            serviceProvider.GetKeyedService<IRequestBuilder<T>>(serviceKey)!
+                        )
+                );
+        }
+
         /// <summary>
         /// Adds a Refit client to the DI container
         /// </summary>
@@ -158,6 +248,78 @@ public static IHttpClientBuilder AddRefitClient(
                 );
         }
 
+        /// <summary>
+        /// Adds a Refit client to the DI container with a specified service key
+        /// </summary>
+        /// <param name="services">container</param>
+        /// <param name="refitInterfaceType">Type of the Refit interface</param>
+        /// <param name="serviceKey">An optional key to associate with the specific Refit client instance</param>
+        /// <param name="settingsAction">Optional. Action to configure refit settings.  This method is called once and only once, avoid using any scoped dependencies that maybe be disposed automatically.</param>
+        /// <param name="httpClientName">Optional. Allows users to change the HttpClient name as provided to IServiceCollection.AddHttpClient. Useful for logging scenarios.</param>
+        /// <returns></returns>
+        public static IHttpClientBuilder AddKeyedRefitClient(
+            this IServiceCollection services,
+            Type refitInterfaceType,
+            object? serviceKey,
+            Func<IServiceProvider, RefitSettings?>? settingsAction,
+            string? httpClientName = null
+        )
+        {
+            var settingsType = typeof(SettingsFor<>).MakeGenericType(refitInterfaceType);
+            var requestBuilderType = typeof(IRequestBuilder<>).MakeGenericType(refitInterfaceType);
+            services.AddKeyedSingleton(
+                settingsType,
+                serviceKey,
+                (provider, _) =>
+                    Activator.CreateInstance(
+                        typeof(SettingsFor<>).MakeGenericType(refitInterfaceType)!,
+                        settingsAction?.Invoke(provider)
+                    )!
+            );
+            services.AddKeyedSingleton(
+                requestBuilderType,
+                serviceKey,
+                (provider, _) =>
+                    RequestBuilderGenericForTypeMethod
+                        .MakeGenericMethod(refitInterfaceType)
+                        .Invoke(
+                            null,
+                            new object?[]
+                            {
+                                ((ISettingsFor)provider.GetRequiredKeyedService(settingsType, serviceKey)).Settings
+                            }
+                        )!
+            );
+
+            return services
+                .AddHttpClient(httpClientName ?? UniqueName.ForType(refitInterfaceType, serviceKey))
+                .ConfigurePrimaryHttpMessageHandler(serviceProvider =>
+                {
+                    var settings = (ISettingsFor)serviceProvider.GetRequiredKeyedService(settingsType, serviceKey);
+                    return
+                        settings.Settings?.HttpMessageHandlerFactory?.Invoke()
+                        ?? new HttpClientHandler();
+                })
+                .ConfigureAdditionalHttpMessageHandlers((handlers, serviceProvider) =>
+                {
+                    var settings = (ISettingsFor)serviceProvider.GetRequiredKeyedService(settingsType, serviceKey);
+                    if (settings.Settings?.AuthorizationHeaderValueGetter is { } getToken)
+                    {
+                        handlers.Add(new AuthenticatedHttpClientHandler(null, getToken));
+                    }
+                })
+                .AddKeyedTypedClient(
+                    refitInterfaceType,
+                    serviceKey,
+                    (client, serviceProvider) =>
+                        RestService.For(
+                            refitInterfaceType,
+                            client,
+                            (IRequestBuilder)serviceProvider.GetRequiredKeyedService(requestBuilderType, serviceKey)
+                        )
+                );
+        }
+
         private static readonly MethodInfo RequestBuilderGenericForTypeMethod =
             typeof(RequestBuilder)
                 .GetMethods(BindingFlags.Public | BindingFlags.Static)
@@ -214,5 +376,68 @@ Func<HttpClient, IServiceProvider, object> factory
 
             return builder;
         }
+
+        static IHttpClientBuilder AddKeyedTypedClient(
+            this IHttpClientBuilder builder,
+            Type type,
+            object? serviceKey,
+            Func<HttpClient, IServiceProvider, object> factory
+        )
+        {
+            if (builder == null)
+            {
+                throw new ArgumentNullException(nameof(builder));
+            }
+
+            if (factory == null)
+            {
+                throw new ArgumentNullException(nameof(factory));
+            }
+
+            builder.Services.AddKeyedTransient(
+                type,
+                serviceKey,
+                (s, _) =>
+                {
+                    var httpClientFactory = s.GetRequiredService<IHttpClientFactory>();
+                    var httpClient = httpClientFactory.CreateClient(builder.Name);
+
+                    return factory(httpClient, s);
+                }
+            );
+
+            return builder;
+        }
+
+        static IHttpClientBuilder AddKeyedTypedClient<T>(
+            this IHttpClientBuilder builder,
+            object? serviceKey,
+            Func<HttpClient, IServiceProvider, T> factory
+        )
+            where T : class
+        {
+            if (builder == null)
+            {
+                throw new ArgumentNullException(nameof(builder));
+            }
+
+            if (factory == null)
+            {
+                throw new ArgumentNullException(nameof(factory));
+            }
+
+            builder.Services.AddKeyedTransient(
+                serviceKey,
+                (s, _) =>
+                {
+                    var httpClientFactory = s.GetRequiredService<IHttpClientFactory>();
+                    var httpClient = httpClientFactory.CreateClient(builder.Name);
+
+                    return factory(httpClient, s);
+                }
+            );
+
+            return builder;
+        }
     }
 }
diff --git a/Refit.Tests/AuthenticatedClientHandlerTests.cs b/Refit.Tests/AuthenticatedClientHandlerTests.cs
@@ -73,6 +73,14 @@ public void DefaultHandlerIsHttpClientHandler()
         Assert.IsType<HttpClientHandler>(handler.InnerHandler);
     }
 
+    [Fact]
+    public void DefaultHandlerIsNull()
+    {
+        var handler = new AuthenticatedHttpClientHandler(null, ((_, _) => Task.FromResult(string.Empty)));
+
+        Assert.Null(handler.InnerHandler);
+    }
+
     [Fact]
     public void NullTokenGetterThrows()
     {
diff --git a/Refit.Tests/HttpClientFactoryExtensionsTests.cs b/Refit.Tests/HttpClientFactoryExtensionsTests.cs
@@ -29,6 +29,30 @@ public void GenericHttpClientsAreAssignedUniqueNames()
         Assert.NotEqual(userClientName, roleClientName);
     }
 
+    [Fact]
+    public void HttpClientServicesAreDifferentThanKeyedServices()
+    {
+        var serviceCollection = new ServiceCollection();
+        serviceCollection.AddRefitClient<IFooWithOtherAttribute>();
+        serviceCollection.AddKeyedRefitClient<IFooWithOtherAttribute>("keyed");
+
+        var serviceProvider = serviceCollection.BuildServiceProvider();
+        var nonKeyedService = serviceProvider.GetService<IFooWithOtherAttribute>();
+        var keyedService = serviceProvider.GetKeyedService<IFooWithOtherAttribute>("keyed");
+
+        Assert.NotNull(nonKeyedService);
+        Assert.NotNull(keyedService);
+        Assert.NotSame(nonKeyedService, keyedService);
+
+        var nonKeyedSettings = serviceProvider.GetService<SettingsFor<IFooWithOtherAttribute>>();
+        var keyedSettings = serviceProvider.GetKeyedService<SettingsFor<IFooWithOtherAttribute>>("keyed");
+        Assert.NotSame(nonKeyedSettings, keyedSettings);
+
+        var nonKeyedRequestBuilder = serviceProvider.GetService<IRequestBuilder<IFooWithOtherAttribute>>();
+        var keyedRequestBuilder = serviceProvider.GetKeyedService<IRequestBuilder<IFooWithOtherAttribute>>("keyed");
+        Assert.NotSame(nonKeyedRequestBuilder, keyedRequestBuilder);
+    }
+
     [Fact]
     public void HttpClientServicesAreAddedCorrectlyGivenGenericArgument()
     {
diff --git a/Refit/AuthenticatedHttpClientHandler.cs b/Refit/AuthenticatedHttpClientHandler.cs
@@ -7,6 +7,17 @@ class AuthenticatedHttpClientHandler : DelegatingHandler
     {
         readonly Func<HttpRequestMessage, CancellationToken, Task<string>> getToken;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AuthenticatedHttpClientHandler"/> class.
+        /// </summary>
+        /// <param name="getToken">The function to get the authentication token.</param>
+        /// <param name="innerHandler">The optional inner handler.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="getToken"/> must not be null.</exception>
+        /// <remarks>
+        /// Warning: This constructor sets the <see cref="DelegatingHandler.InnerHandler"/> to an instance
+        /// of <see cref="HttpClientHandler"/>, when <paramref name="innerHandler"/> is <c>null</c>. This is
+        /// a behavior which is incompatible with the <code>IHttpClientBuilder</code>.
+        /// </remarks>
         public AuthenticatedHttpClientHandler(
             Func<HttpRequestMessage, CancellationToken, Task<string>> getToken,
             HttpMessageHandler? innerHandler = null
@@ -16,6 +27,28 @@ public AuthenticatedHttpClientHandler(
             this.getToken = getToken ?? throw new ArgumentNullException(nameof(getToken));
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AuthenticatedHttpClientHandler"/> class.
+        /// </summary>
+        /// <param name="innerHandler">The optional inner handler.</param>
+        /// <param name="getToken">The function to get the authentication token.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="getToken"/> must not be null.</exception>
+        /// <remarks>
+        /// This function doesn't set the <see cref="DelegatingHandler.InnerHandler"/> automatically to an
+        /// instance of <see cref="HttpClientHandler"/> when <paramref name="innerHandler"/> is null,
+        /// which is different from the old (legacy) constructor, and compliant with the behavior expected
+        /// by the <code>IHttpClientBuilder</code>.
+        /// </remarks>
+        public AuthenticatedHttpClientHandler(
+            HttpMessageHandler? innerHandler,
+            Func<HttpRequestMessage, CancellationToken, Task<string>> getToken
+        )
+        {
+            this.getToken = getToken ?? throw new ArgumentNullException(nameof(getToken));
+            if (innerHandler != null)
+                InnerHandler = innerHandler;
+        }
+
         protected override async Task<HttpResponseMessage> SendAsync(
             HttpRequestMessage request,
             CancellationToken cancellationToken
diff --git a/Refit/UniqueName.cs b/Refit/UniqueName.cs
@@ -7,6 +7,16 @@ public static string ForType<T>()
             return ForType(typeof(T));
         }
 
+        public static string ForType<T>(object? serviceKey)
+        {
+            return ForType(typeof(T), serviceKey);
+        }
+
+        public static string ForType(Type refitInterfaceType, object? serviceKey)
+        {
+            return ForType(refitInterfaceType) + GetServiceKeySuffix(serviceKey);
+        }
+
         public static string ForType(Type refitInterfaceType)
         {
             var interfaceTypeName = refitInterfaceType.FullName!;
@@ -52,5 +62,15 @@ public static string ForType(Type refitInterfaceType)
 
             return assmQualified;
         }
+
+        /// <summary>
+        /// Returns the suffix for the service key to be added to the unique name for a given type.
+        /// </summary>
+        /// <param name="serviceKey">The service key to create the suffix from.</param>
+        /// <returns>The suffix to be added to the unique name of a given type.</returns>
+        static string GetServiceKeySuffix(object? serviceKey)
+        {
+            return serviceKey is null or "" ? string.Empty : $", ServiceKey={serviceKey}";
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -73,6 +73,14 @@ public void DefaultHandlerIsHttpClientHandler()`
`73`	`73`	`Assert.IsType<HttpClientHandler>(handler.InnerHandler);`
`74`	`74`	`}`
`75`	`75`
	`76`	`+ [Fact]`
	`77`	`+ public void DefaultHandlerIsNull()`
	`78`	`+ {`
	`79`	`+ var handler = new AuthenticatedHttpClientHandler(null, ((_, _) => Task.FromResult(string.Empty)));`
	`80`	`+`
	`81`	`+ Assert.Null(handler.InnerHandler);`
	`82`	`+ }`
	`83`	`+`
`76`	`84`	`[Fact]`
`77`	`85`	`public void NullTokenGetterThrows()`
`78`	`86`	`{`