DI of httpclientfactory in a backgroundservice for a console app

Question

I have a console program with a simple consuming backgroundservice which need to call function from a scopedservice that uses a HttpClientFactory to call an external API and return result to consuming backgroundservice.

I want very simple after looking at a couple example online to remove all possible complexity from the code.

public class Program
    {
        public static async Task Main(string[] args)
        {
            var host = new HostBuilder()
                .ConfigureLogging((hostContext, config) =>
                {
                    config.AddConsole();
                })
                .ConfigureAppConfiguration((hostContext, config) =>
                {
                    config.AddJsonFile("appsettings.json", optional: true);
                    config.AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Production"}.json", optional: true);
                    config.AddCommandLine(args);
                })
                .ConfigureServices((hostContext, services) =>
                {
                    services.AddHostedService<ConsumeMessageService>();
                    services.AddScoped<IScopedArcGisServices, ScopedArcGisServices>();
                })
        .UseConsoleLifetime()
        .Build();

        using (host)
        {
            // Start the host
            await host.StartAsync();

            // Wait for the host to shutdown
            await host.WaitForShutdownAsync();
        }
        }
    }

public class ConsumeMessageService : IHostedService
    {
        private readonly ILogger _logger;
        public IServiceProvider _serviceProvider { get; }

        public ConsumeMessageService(IServiceProvider services,
            ILogger<ConsumeMessageService> logger)
        {
            _serviceProvider = services;
            _logger = logger;
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation(
                "Consume message service hosted service is starting.");

            DoWork();

            return Task.CompletedTask;
        }

        private void DoWork()
        {
            _logger.LogInformation(
                "Consume message service hosted service is working.");

            using (var scope = _serviceProvider.CreateScope())
            {
                var scopedProcessingService =
                    scope.ServiceProvider
                        .GetRequiredService<IScopedServices>();

                scopedProcessingService.DoWork();
            }
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation(
                "Consume Scoped Service Hosted Service is stopping.");

            return Task.CompletedTask;
        }
    }

internal interface IScopedServices
    {
        void DoWork();
    }

    internal class ScopedServices : IScopedServices
    {
        private readonly ILogger _logger;
        private readonly IHttpClientFactory _clientFactory;
        public string JsonResult { get; private set; }

        public ScopedServices(ILogger<ScopedServices> logger, IHttpClientFactory clientFactory)
        {
            _logger = logger;
            _clientFactory = clientFactory;
        }   

        public void DoWork()
        {
            _logger.LogInformation("Scoped processing service is working.");
        }
    }

As soon as I had the scopedservice with the HttpClientFactory I get this message :

Unable to resolve service for type 'System.Net.Http.IHttpClientFactory' while attempting to activate 'Integration.BackgroundService.Services.ScopedServices'.'

Answer 1

IHttpClientFactory is not added by default.

You have to call services.AddHttpClient() when configuring services to add access to the factory and its related clients.

//...
.ConfigureServices((hostContext, services) => {
    services.AddHttpClient(); //<-- THIS IS NEEDED
    services.AddHostedService<ConsumeMessageService>();
    services.AddScoped<IScopedArcGisServices, ScopedArcGisServices>();
})
//...

For more on how to configure the clients created by the factory,

Reference Use HttpClientFactory to implement resilient HTTP requests