AddHttpClient should still work even if called before AddSingleton

[joshlangs]

	class Program
	{
		//<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.1.1" />
		//<PackageReference Include = "Microsoft.Extensions.Http" Version="2.1.1" />
		class Blarg
		{
			public Blarg(HttpClient c) { }
		}
		static void Main(string[] args)
		{
			ServiceCollection sc = new ServiceCollection();
			sc.AddSingleton<Blarg>();
			sc.AddHttpClient<Blarg>();
			sc.BuildServiceProvider().GetRequiredService<Blarg>(); // OK

			sc = new ServiceCollection();
			sc.AddHttpClient<Blarg>();
			sc.AddSingleton<Blarg>();
			sc.BuildServiceProvider().GetRequiredService<Blarg>(); // System.InvalidOperationException: 'Unable to resolve service for type 'System.Net.Http.HttpClient' while attempting to activate 'ConsoleApp3.Program+Blarg'.'
		}
	}

In the project above, the first service provider works without any problem. But the second one crashes with an exception.

I got trapped by this. I didn't realize that I needed to call AddSingleton before I called AddHttpClient or else I would get an exception. Took me a while to figure it out.

I don't know why it makes a difference. Maybe there's a reason? But if not, it would probably better to make it work either way.

[khellang]

Maybe there's a reason?

The reason is that the order you register stuff in the container matters 😉

When resolving a service, the last registration is used. In the latter case, that's a regular singleton registration, which doesn't know how to resolve System.Net.Http.HttpClient, unlike the AddHttpClient registration.

Why are you registering the service twice?

[joshlangs]

Oi!!

I didn't realize I was registering it twice. I thought AddHttpClient was registering the HttpClient which is depended on by the Blarg class.

It seems rather that AddHttpClient registers Blarg too. Makes me wonder what happens with other dependencies if there were some.

Maybe that's a job for IHttpClientFactory instead!

But ok. I understand for now. Thanks!

[khellang]

Right, there are a couple of overloads for AddHttpClient. One non-generic overload that just adds the infrastructure services, like IHttpClientFactory:

HttpClientFactory/src/Microsoft.Extensions.Http/DependencyInjection/HttpClientFactoryServiceCollectionExtensions.cs

Lines 22 to 52 in 6fae77b

	public static IServiceCollection AddHttpClient(this IServiceCollection services)
	{
	if (services == null)
	{
	throw new ArgumentNullException(nameof(services));
	}
	services.AddLogging();
	services.AddOptions();
	//
	// Core abstractions
	//
	services.TryAddTransient<HttpMessageHandlerBuilder, DefaultHttpMessageHandlerBuilder>();
	services.AddSingleton<DefaultHttpClientFactory>();
	services.TryAddSingleton<IHttpClientFactory>(serviceProvider => serviceProvider.GetRequiredService<DefaultHttpClientFactory>());
	services.TryAddSingleton<IHttpMessageHandlerFactory>(serviceProvider => serviceProvider.GetRequiredService<DefaultHttpClientFactory>());
	//
	// Typed Clients
	//
	services.TryAdd(ServiceDescriptor.Transient(typeof(ITypedHttpClientFactory<>), typeof(DefaultTypedHttpClientFactory<>)));
	services.TryAdd(ServiceDescriptor.Transient(typeof(DefaultTypedHttpClientFactory<>.Cache), typeof(DefaultTypedHttpClientFactory<>.Cache)));
	//
	// Misc infrastructure
	//
	services.TryAddEnumerable(ServiceDescriptor.Singleton<IHttpMessageHandlerBuilderFilter, LoggingHttpMessageHandlerBuilderFilter>());
	return services;
	}

And the generic overload that you're calling:

HttpClientFactory/src/Microsoft.Extensions.Http/DependencyInjection/HttpClientFactoryServiceCollectionExtensions.cs

Lines 191 to 205 in 6fae77b

	public static IHttpClientBuilder AddHttpClient<TClient>(this IServiceCollection services)
	where TClient : class
	{
	if (services == null)
	{
	throw new ArgumentNullException(nameof(services));
	}
	AddHttpClient(services);
	var name = TypeNameHelper.GetTypeDisplayName(typeof(TClient), fullName: false);
	var builder = new DefaultHttpClientBuilder(services, name);
	builder.AddTypedClient<TClient>();
	return builder;
	}

As the XML docs say:

The type of the typed client. They type specified will be registered in the service collection as a transient service. See ITypedHttpClientFactory<TClient> for more details about authoring typed clients.

[joshlangs]

Got it.

I'll close this. Thanks for clearing it up.