Case 10: The Socket Exhaustion Trap - Misusing HttpClient

The Story

Imagine your ASP.NET Core application needs to call other APIs to get data. For example, it might call an inventory service to check if a product is in stock.

The application works perfectly on your computer and in testing. But when it goes live and many users start using it, the application suddenly starts failing with a strange error: SocketException.

The Problem Code (It Looks Correct)

Because HttpClient is IDisposable, many developers think they should create and destroy it for every single API call, using a using block. This is how we are taught to handle IDisposable objects like DbContext.

public class InventoryService
{
    public async Task<int> GetStockCountAsync(int productId)
    {
        // THE CLASSIC MISTAKE: Creating a new HttpClient for every request.
        using (var client = new HttpClient())
        {
            var response = await client.GetStringAsync($"https://api.inventory.com/stock/{productId}");
            return int.Parse(response);
        }
    }
}

The Real Danger: Socket Exhaustion

1. A Misunderstanding: HttpClient is designed to be reused. It is safe to share one HttpClient for many requests at the same time (it's thread-safe).

2. The Real Problem:

   • When you create a new HttpClient, it takes a network socket from the operating system to make the connection.
   • When the using block ends, the HttpClient is disposed, but the socket is not released immediately. It goes into a TIME_WAIT state for a few minutes to make sure all data was sent correctly.
   • Under high load: Your application creates and disposes HttpClients very quickly. This uses up all the available sockets on the server. This is called socket exhaustion.
   • When there are no more sockets, your application cannot make any more outgoing HTTP calls. It can't talk to other services, and it effectively crashes.

The Solution: Use IHttpClientFactory

ASP.NET Core provides a built-in service called IHttpClientFactory to solve this exact problem. It manages a pool of HttpClient handlers, allowing sockets to be reused safely and efficiently.

Here is the better code:

1. Register it in Program.cs:

   builder.Services.AddHttpClient();

2. Inject and use the factory:

   public class InventoryService
   {
       private readonly IHttpClientFactory _httpClientFactory;
   
       public InventoryService(IHttpClientFactory httpClientFactory)
       {
           _httpClientFactory = httpClientFactory;
       }
   
       public async Task<int> GetStockCountAsync(int productId)
       {
           // Get a managed HttpClient from the factory
           var client = _httpClientFactory.CreateClient();
   
           var response = await client.GetStringAsync($"https://api.inventory.com/stock/{productId}");
           return int.Parse(response);
       }
   }

What We Gained

1. No More Socket Exhaustion: The underlying network sockets are reused efficiently. Your application can handle thousands of outgoing HTTP requests without problems.
2. Centralized Management: IHttpClientFactory gives you one place to set up policies for all your HttpClients, such as timeouts, automatic retries, and more advanced patterns like circuit breakers.

The Golden Rules

1. Never create a new HttpClient in a using block for each request.
2. Always use IHttpClientFactory to create and manage HttpClient instances in modern ASP.NET Core applications.

Misusing HttpClient is one of the most serious technical mistakes that can bring down a production system.