When working with HttpClient in ASP.NET Core, developers often fall into common traps that can lead to poor performance, resource exhaustion, and unreliable applications. These aren't just theoretical problems—they're the kind of issues that bring down production systems at 2 AM.

In this post, we'll explore five critical anti-patterns and their recommended solutions. Trust me, if you're using HttpClient, you're probably making at least one of these mistakes right now.

Anti-Pattern #1: Not Handling HTTP Errors Properly

❌ The Problem

var response = await httpClient.GetAsync("posts/1");
response.EnsureSuccessStatusCode(); // Throws exception on non-success status codes

Why it's bad:

• EnsureSuccessStatusCode() throws an HttpRequestException for any non-2xx status code
• This treats business logic errors (like 404 Not Found) the same as infrastructure failures
• You lose the ability to handle different HTTP status codes differently
• Exception handling is expensive and should be reserved for exceptional cases

✅ The Solution

var response = await httpClient.GetAsync("posts/1");

if (response.IsSuccessStatusCode)
{
    var post = await response.Content.ReadFromJsonAsync<JsonElement>();
    // Process successful response
}
else
{
    // Handle different status codes appropriately
    switch (response.StatusCode)
    {
        case System.Net.HttpStatusCode.NotFound:
            // Handle 404
            break;
        case System.Net.HttpStatusCode.Unauthorized:
            // Handle 401
            break;
        default:
            // Handle other errors
            break;
    }
}

Anti-Pattern #2: Reading Response Content Twice

❌ The Problem

var content = await response.Content.ReadAsStringAsync();
var post = JsonSerializer.Deserialize<JsonElement>(content);

Why it's bad:

• Creates an unnecessary intermediate string allocation
• Wastes memory by holding the entire response as a string
• Additional deserialization step is redundant
• Poor performance, especially with large payloads

✅ The Solution

var post = await response.Content.ReadFromJsonAsync<JsonElement>();

Anti-Pattern #3: Creating New HttpClient Instances (Socket Exhaustion)

This is the big one. The mistake that literally brings down production systems.

❌ The Problem

using (var httpClient = new HttpClient())
{
    var response = await httpClient.GetAsync("https://api.example.com/posts/1");
    // Process response
}

Why it's bad:

• Each HttpClient instance creates new TCP connections
• Connections aren't immediately released when HttpClient is disposed
• Leads to socket exhaustion under load
• TIME_WAIT state can keep sockets occupied for minutes
• Can cause "Cannot assign requested address" errors in production

🤔 The Initial Solution (That Creates Another Problem)

You might think: "I'll just use a static HttpClient to reuse the same instance!"

private static readonly HttpClient _httpClient = new HttpClient();

This does solve the socket exhaustion issue, but it introduces a new problem: DNS staleness (see Anti-Pattern #4 below).

✅ The Real Solution: IHttpClientFactory

// In Program.cs
builder.Services.AddHttpClient("MyAPI", client =>
{
    client.BaseAddress = new Uri("https://jsonplaceholder.typicode.com/");
    client.Timeout = TimeSpan.FromSeconds(30);
    client.DefaultRequestHeaders.Add("Accept", "application/json");
});

// In Controller
public class HomeController : Controller
{
    private readonly IHttpClientFactory _httpClientFactory;
    
    public HomeController(IHttpClientFactory httpClientFactory)
    {
        _httpClientFactory = httpClientFactory;
    }
    
    public async Task<IActionResult> GetData()
    {
        var httpClient = _httpClientFactory.CreateClient("MyAPI");
        var response = await httpClient.GetAsync("posts/1");
        // Process response
    }
}

Anti-Pattern #4: Using Static HttpClient Without Consideration

❌ The Problem (From Anti-Pattern #3's "Solution")

private static readonly HttpClient _staticHttpClient = new HttpClient();

While this solves socket exhaustion, it creates new issues:

Why it's problematic:

• Static HttpClient doesn't respect DNS changes
• The underlying HttpMessageHandler caches DNS results indefinitely
• Can cause issues in cloud environments with load balancers
• If a service IP changes, your app might keep using the old (stale) IP for the lifetime of the application
• No built-in support for resilience patterns
• In Kubernetes or container environments, this can route traffic to terminated pods

When it might be acceptable:

• Simple applications with a single HTTP endpoint that never changes
• Services that don't change their DNS
• Non-production/demo scenarios
• Very simple console applications

✅ The Solution

Use IHttpClientFactory as shown in Anti-Pattern #3. It gives you the best of both worlds:

Anti-Pattern #5: Setting HttpClient Properties Per Request

❌ The Problem

var httpClient = _httpClientFactory.CreateClient("MyAPI");
httpClient.BaseAddress = new Uri("https://jsonplaceholder.typicode.com/");
httpClient.Timeout = TimeSpan.FromSeconds(30);
httpClient.DefaultRequestHeaders.Add("Accept", "application/json");

Why it's bad:

• IHttpClientFactory returns clients from a pool
• Modifying default properties affects the pooled instance
• Can cause race conditions and unpredictable behavior
• Headers accumulate if the same instance is reused
• Thread-safety issues in concurrent scenarios

✅ The Solution

Configure named clients in Program.cs:

builder.Services.AddHttpClient("MyAPI", client =>
{
    client.BaseAddress = new Uri("https://jsonplaceholder.typicode.com/");
    client.Timeout = TimeSpan.FromSeconds(30);
    client.DefaultRequestHeaders.Add("Accept", "application/json");
});

For per-request headers, use HttpRequestMessage:

var httpClient = _httpClientFactory.CreateClient("MyAPI");
var request = new HttpRequestMessage(HttpMethod.Get, "posts/1");
request.Headers.Add("Authorization", $"Bearer {token}");
var response = await httpClient.SendAsync(request);

Complete Example: Best Practices Implementation

Here's a complete example showing all the fixes applied:

Program.cs Configuration

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();

// Named client configuration
builder.Services.AddHttpClient("MyAPI", client =>
{
    client.BaseAddress = new Uri("https://jsonplaceholder.typicode.com/");
    client.Timeout = TimeSpan.FromSeconds(30);
    client.DefaultRequestHeaders.Add("Accept", "application/json");
});

// Typed client configuration (recommended)
builder.Services.AddHttpClient<IPostService, PostService>(client =>
{
    client.BaseAddress = new Uri("https://jsonplaceholder.typicode.com/");
    client.Timeout = TimeSpan.FromSeconds(30);
    client.DefaultRequestHeaders.Add("Accept", "application/json");
});

var app = builder.Build();
// ... rest of configuration

Controller with Best Practices

public class HomeController : Controller
{
    private readonly IHttpClientFactory _httpClientFactory;
    
    public HomeController(IHttpClientFactory httpClientFactory)
    {
        _httpClientFactory = httpClientFactory;
    }
    
    public async Task<IActionResult> BestPractice()
    {
        try
        {
            var httpClient = _httpClientFactory.CreateClient("MyAPI");
            var response = await httpClient.GetAsync("posts/1");
            
            if (response.IsSuccessStatusCode)
            {
                var post = await response.Content.ReadFromJsonAsync<JsonElement>();
                ViewBag.Method = "Best Practice";
                ViewBag.Title = post.GetProperty("title").GetString();
                ViewBag.Body = post.GetProperty("body").GetString();
            }
            else
            {
                ViewBag.Error = $"HTTP Error: {response.StatusCode}";
            }
        }
        catch (HttpRequestException httpEx)
        {
            // Handle network-level errors
            ViewBag.Error = $"Network Error: {httpEx.Message}";
        }
        catch (TaskCanceledException)
        {
            // Handle timeout
            ViewBag.Error = "Request timed out";
        }
        catch (Exception ex)
        {
            // Handle unexpected errors
            ViewBag.Error = $"Error: {ex.Message}";
        }
        
        return View("Index");
    }
}

Summary: Quick Reference

Conclusion

Proper HttpClient usage is critical for building scalable, reliable ASP.NET Core applications. By avoiding these common anti-patterns and following the recommended practices:

Now go forth and make HTTP requests the right way! Your production servers will thank you. 🚀