What is HttpClient (C#)Factory and how is it used?

HttpClientFactory in C# is a way to create and manage HttpClient instances in a .NET application. It was introduced in .NET Core 2.1 to address some of the common issues with HttpClient when used improperly, such as socket exhaustion due to the mishandling of HttpClient lifetimes.

Why Use HttpClientFactory?

1. HttpClient Lifespan Management: It provides a central location for naming and configuring logical HttpClient instances. For example, you might have a client that's configured to access the GitHub API, and another one that's configured to access a different API. HttpClientFactory can manage each distinct instance.

2. Pooled Connection Management: It manages the pooling of HttpClientHandler instances to reduce resource consumption, which is a common problem when manually instantiating HttpClient objects.

3. Improved Resilience and Stability: It integrates with Polly, a third-party library for transient fault handling, allowing you to easily implement retry policies, circuit breakers, and other resilience features.

4. Centralized Configuration: It allows you to centrally configure all HttpClient instances in one location, making it easy to apply consistent settings across your application.

How to Use HttpClientFactory

To use HttpClientFactory, you need to first set it up in your service container during the startup of your application, and then you can inject it wherever you need to create HttpClient instances.

Setting up HttpClientFactory

In your Startup.cs file, you would typically add the HttpClientFactory in the ConfigureServices method:

public void ConfigureServices(IServiceCollection services)
{
    // ...

    // Register HttpClientFactory
    services.AddHttpClient();

    // Register named client
    services.AddHttpClient("GitHubClient", client =>
    {
        client.BaseAddress = new Uri("https://api.github.com/");
        client.DefaultRequestHeaders.Add("Accept", "application/vnd.github.v3+json");
        client.DefaultRequestHeaders.Add("User-Agent", "HttpClientFactory-Sample");
    });

    // ...
}

Using HttpClientFactory

Once you have registered HttpClientFactory, you can use dependency injection to obtain an HttpClient instance. Here's an example in a controller:

public class MyController : ControllerBase
{
    private readonly IHttpClientFactory _clientFactory;

    public MyController(IHttpClientFactory clientFactory)
    {
        _clientFactory = clientFactory;
    }

    public async Task<IActionResult> GetGitHubData()
    {
        var client = _clientFactory.CreateClient("GitHubClient");
        var response = await client.GetAsync("/");

        if (response.IsSuccessStatusCode)
        {
            var data = await response.Content.ReadAsStringAsync();
            // Use data
        }

        // Handle failure
    }
}

In the above example, CreateClient is called with the name of the client we set up earlier ("GitHubClient"). This will return a configured HttpClient instance ready to use.

HttpClientFactory with Typed Clients

You can also define a typed client which encapsulates the logic of interacting with a specific API. Here's an example of how to define and use a typed client:

public class GitHubService
{
    private readonly HttpClient _client;

    public GitHubService(HttpClient client)
    {
        _client = client;
    }

    public async Task<string> GetUserDataAsync(string userName)
    {
        var response = await _client.GetAsync($"/users/{userName}");
        response.EnsureSuccessStatusCode();

        return await response.Content.ReadAsStringAsync();
    }
}

// In Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    // ...

    services.AddHttpClient<GitHubService>(client =>
    {
        client.BaseAddress = new Uri("https://api.github.com/");
        client.DefaultRequestHeaders.Add("Accept", "application/vnd.github.v3+json");
        client.DefaultRequestHeaders.Add("User-Agent", "HttpClientFactory-Sample");
    });

    // ...
}

And you would inject and use your GitHubService where needed:

public class MyController : ControllerBase
{
    private readonly GitHubService _gitHubService;

    public MyController(GitHubService gitHubService)
    {
        _gitHubService = gitHubService;
    }

    public async Task<IActionResult> GetUserData(string userName)
    {
        var data = await _gitHubService.GetUserDataAsync(userName);
        // Use data
    }
}

By using HttpClientFactory, you can avoid common pitfalls of managing HttpClient instances and more easily manage their lifetimes and configurations in a .NET application.