Httpclient Factory

builder.Services.AddHttpClient("github", client =>{    client.BaseAddress = new Uri("https://api.github.com/");    client.DefaultRequestHeaders.UserAgent.ParseAdd("MyApp/1.0");    client.DefaultRequestHeaders.Accept.Add(        new MediaTypeWithQualityHeaderValue("application/json"));}).AddStandardResilienceHandler();
// Usage via factorypublic sealed class GitHubService(IHttpClientFactory factory){    public async Task<Repo?> GetRepoAsync(string owner, string name, CancellationToken ct)    {        var client = factory.CreateClient("github");        return await client.GetFromJsonAsync<Repo>($"repos/{owner}/{name}", ct);    }}

builder.Services.AddHttpClient("payments", client =>{    client.BaseAddress = new Uri("https://api.payments.example.com/");}).AddStandardResilienceHandler().AddAsKeyed();  // Register as keyed scoped service
// Inject directly — no IHttpClientFactory neededapp.MapPost("/charge", async (    [FromKeyedServices("payments")] HttpClient httpClient,    ChargeRequest request,    CancellationToken ct) =>{    var response = await httpClient.PostAsJsonAsync("charges", request, ct);    return response.IsSuccessStatusCode        ? TypedResults.Ok()        : TypedResults.Problem("Payment failed");});

builder.Services.AddHttpClient("api")    .AddStandardResilienceHandler(options =>    {        options.Retry.MaxRetryAttempts = 5;        options.Retry.Delay = TimeSpan.FromSeconds(1);        options.TotalRequestTimeout.Timeout = TimeSpan.FromSeconds(60);        options.AttemptTimeout.Timeout = TimeSpan.FromSeconds(15);
        // Disable retries for non-idempotent methods        options.Retry.DisableForUnsafeHttpMethods();    });

public sealed class AuthenticationHandler(ITokenService tokenService)    : DelegatingHandler{    protected override async Task<HttpResponseMessage> SendAsync(        HttpRequestMessage request, CancellationToken cancellationToken)    {        var token = await tokenService.GetAccessTokenAsync(cancellationToken);        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);        return await base.SendAsync(request, cancellationToken);    }}
// Registrationbuilder.Services.AddTransient<AuthenticationHandler>();builder.Services.AddHttpClient("api")    .AddHttpMessageHandler<AuthenticationHandler>()    .AddStandardResilienceHandler();

public sealed class CorrelationIdHandler(IHttpContextAccessor httpContextAccessor)    : DelegatingHandler{    protected override Task<HttpResponseMessage> SendAsync(        HttpRequestMessage request, CancellationToken cancellationToken)    {        if (httpContextAccessor.HttpContext?.Request.Headers                .TryGetValue("X-Correlation-Id", out var correlationId) is true)        {            request.Headers.Add("X-Correlation-Id", correlationId.ToString());        }        return base.SendAsync(request, cancellationToken);    }}

builder.Services.AddHttpClient("advanced")    .UseSocketsHttpHandler((handler, _) =>    {        handler.PooledConnectionLifetime = TimeSpan.FromMinutes(2);        handler.PooledConnectionIdleTimeout = TimeSpan.FromMinutes(1);        handler.MaxConnectionsPerServer = 100;        handler.AutomaticDecompression =            DecompressionMethods.GZip | DecompressionMethods.Brotli;    });

public sealed class MockHttpHandler(    HttpStatusCode statusCode,    string content) : HttpMessageHandler{    protected override Task<HttpResponseMessage> SendAsync(        HttpRequestMessage request, CancellationToken cancellationToken)    {        return Task.FromResult(new HttpResponseMessage(statusCode)        {            Content = new StringContent(content, Encoding.UTF8, "application/json")        });    }}
// In testvar handler = new MockHttpHandler(HttpStatusCode.OK, """{"id":1}""");var client = new HttpClient(handler) { BaseAddress = new Uri("https://api.test/") };var service = new MyService(client);

// BAD — socket exhaustion under load, ignores DNS changespublic async Task<string> GetDataAsync(){    using var client = new HttpClient();    return await client.GetStringAsync("https://api.example.com/data");}
// GOOD — factory-managedpublic async Task<string> GetDataAsync(CancellationToken ct){    var client = factory.CreateClient("api");    return await client.GetStringAsync("https://api.example.com/data", ct);}

// BAD — transient HttpClient captured by singleton defeats handler rotationservices.AddSingleton<MySingletonService>();services.AddHttpClient<MySingletonService>();
// GOOD — use keyed client or IHttpClientFactory in singletonsservices.AddSingleton<MySingletonService>();services.AddHttpClient("myservice").AddAsKeyed(ServiceLifetime.Singleton);

// BAD — not thread-safehttpClient.DefaultRequestHeaders.Authorization =    new AuthenticationHeaderValue("Bearer", token);
// GOOD — use DelegatingHandler or per-request HttpRequestMessageusing var request = new HttpRequestMessage(HttpMethod.Get, "/api/data");request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);await httpClient.SendAsync(request, ct);

// BAD — no cancellation supportvar result = await httpClient.GetFromJsonAsync<Order>("/orders/1");
// GOOD — always pass CancellationTokenvar result = await httpClient.GetFromJsonAsync<Order>("/orders/1", cancellationToken);

// BAD — conflicting resilience strategiesbuilder.AddStandardResilienceHandler();builder.AddStandardHedgingHandler();
// GOOD — one standard handler, or a custom pipelinebuilder.AddStandardResilienceHandler();