Is it safe to inject a typed HTTP client inside an hosted service ? Does it create a captive dependency ?

[EnricoMassone]

Hi,

I have a doubt related to the ASP.NET core dependency injection container. This question refers specifically to ASP.NET core 3.1.

I'm basically asking myself whether injecting a typed HTTP client inside an hosted service creates a so called captive dependency in terms of dependency injection.

The scenario I'm trying to depict is the following:

public interface IStudentsApiClient  
{
  Task<IEnumerable<Student>> GetAll(CancellationToken cancellationToken);
}

public class StudentsApiClient: IStudentsApiClient 
{
  private readonly HttpClient _httpClient;
  
  public StudentsApiClient(HttpClient httpClient)
  {
    _httpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
  }
  
  public async Task<IEnumerable<Student>> GetAll(CancellationToken cancellationToken)
  {
	  // call a GET endpoint to retrieve all the students from a third party api...
  }
}

public class StudentsPollingHostedService: BackgroundService 
{
	private readonly IStudentsApiClient _apiClient;
	
	public StudentsPollingHostedService(IStudentsApiClient apiClient) 
	{
		_apiClient = apiClient ?? throw new ArgumentNullException(nameof(apiClient));
	}
	
	protected override async Task ExecuteAsync(CancellationToken stoppingToken)
	{
		// do something using the IStudentsApiClient service 
	}
}

// code from Startup.cs
services.AddHttpClient<IStudentsApiClient, StudentsApiClient>(); // the service IStudentsApiClient is registered as transient
services.AddHostedService<StudentsPollingHostedService>(); // the hosted service is registered as a singleton

In the above code I'm injecting a transient dependency (IStudentsApiClient), inside a singleton (StudentsPollingHostedService), thereby creating a captive dependency.

Based on my understanding, this could totally harm the whole purpose of the ASP.NET core HTTP client factory implementation, which is aimed to return a new HTTP client each time one is requested by the consumer. In the code above we basically have an instance of HTTP client captured inside the hosted service for the whole application lifetime.

Do you agree that this is an actual issue ?

My idea to fix the above code is changing the StudentsApiClient so that the IHttpClientFactory is used to create a new instance of HttpClient each time GetAll is called:

public interface IStudentsApiClient  
{
  Task<IEnumerable<Student>> GetAll(CancellationToken cancellationToken);
}

public class StudentsApiClient: IStudentsApiClient 
{
  private readonly IHttpClientFactory _factory;
  
  public StudentsApiClient(IHttpClientFactory factory)
  {
    _factory = factory ?? throw new ArgumentNullException(nameof(factory));
  }
  
  public async Task<IEnumerable<Student>> GetAll(CancellationToken cancellationToken)
  {
	  var httpClient = _factory.CreateClient("students");
	  
	  // call a GET endpoint to retrieve all the students from a third party api...
  }
}

public class StudentsPollingHostedService: BackgroundService 
{
	private readonly IStudentsApiClient _apiClient;
	
	public StudentsPollingHostedService(IStudentsApiClient apiClient) 
	{
		_apiClient = apiClient ?? throw new ArgumentNullException(nameof(apiClient));
	}
	
	protected override async Task ExecuteAsync(CancellationToken stoppingToken)
	{
		// do something using the IStudentsApiClient service 
	}
}

// code from Startup.cs
services.AddHostedService<StudentsPollingHostedService>(); // the hosted service is registered as a singleton

services.AddHttpClient("students", c => 
{
  // students HTTP client configuration goes here...
});

services.AddSingleton<IStudentsApiClient, StudentsApiClient>(); // IStudentsApiClient is now registered as a singleton 

Does this solve the issue of the first version of the code (if any) ?

Thanks for helping.

[EnricoMassone]

My question is very much in line with this other one dotnet/runtime#36067