So, I've registered a named client with the services collection in my Startup.cs:
services.AddHttpClient(someServiceName,
client => client.BaseAddress = baseAddress);
and now can inject an IHttpClientFactory
from my service provider.
Using this IHttpClientFactory
, I conjure up a client instance:
var client = httpClientFactory.CreateClient(someServiceName)
Once upon a time, it was necessary to be very careful about the disposing of HttpClient
instances, as it was rarely the right thing to do.
However, now we have HttpClientFactory
, does this matter any more? Should/Can this client
be disposed without worry? e.g.
using (var httpClient = httpClientFactory.CreateClient(someServiceName))
using (var response = await httpClient.PostAsync(somePath, someData))
{
var content = await response.Content.ReadAsAsync<SomeResponse>();
//...
}
Calling the Dispose
method is not required but you can still call it if you need for some reasons.
Proof: HttpClient and lifetime management
Disposal of the client isn't required. Disposal cancels outgoing requests and guarantees the given HttpClient instance can't be used after calling Dispose. IHttpClientFactory tracks and disposes resources used by HttpClient instances. The HttpClient instances can generally be treated as .NET objects not requiring disposal.
Let's check the source of DefaultHttpClientFactory
:
public HttpClient CreateClient(string name)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
var handler = CreateHandler(name);
var client = new HttpClient(handler, disposeHandler: false);
var options = _optionsMonitor.Get(name);
for (var i = 0; i < options.HttpClientActions.Count; i++)
{
options.HttpClientActions[i](client);
}
return client;
}
The instance of HttpMessageHandler
stores unmanaged resources of the HttpClient
. In the classical scenario the HttpClient
creates the instance of HttpMessageHandler
and disposes it while itself disposing.
You can see in the above code that different instances of HttpClient
shares single instance of HttpMessageHandler
and doesn't dispose it (disposeHandler: false
).
So, the call of the HttpClient.Dispose
does nothing. But it's not dangerous.