Как работает HttpClient и почему его нужно использовать через IHttpClientFactory?

Как работает HttpClient?

HttpClient в .NET — это высокоуровневый класс для отправки HTTP-запросов и получения HTTP-ответов от ресурсов, идентифицируемых URI. Под капотом он использует HttpMessageHandler для фактической отправки запросов.

Основные компоненты:

1. HttpRequestMessage — представляет HTTP-запрос (метод, URI, заголовки, содержимое)
2. HttpResponseMessage — представляет HTTP-ответ (статус-код, заголовки, тело)
3. HttpMessageHandler — абстракция для отправки запросов (обычно HttpClientHandler)

Базовый пример использования:

using var client = new HttpClient();
var response = await client.GetAsync("https://api.example.com/data");
if (response.IsSuccessStatusCode)
{
    var content = await response.Content.ReadAsStringAsync();
    Console.WriteLine(content);
}

Проблемы при прямом использовании HttpClient

Несмотря на простоту, прямое создание HttpClient через new имеет серьезные недостатки:

1. Проблема сокетов и исчерпания портов

Каждый HttpClient создает новый экземпляр HttpMessageHandler, который использует собственный пул соединений. При частом создании/удалении:

• Сокеты остаются в состоянии TIME_WAIT (по умолчанию 240 секунд)
• Быстро исчерпываются доступные порты (лимит ~65K на машине)
• Возникает ошибка "SocketException: Only one usage of each socket address is normally permitted"

// ПЛОХОЙ ПРИМЕР: создание нового HttpClient для каждого запроса
for (int i = 0; i < 1000; i++)
{
    using var client = new HttpClient(); // Каждый раз новый пул соединений
    await client.GetAsync("https://api.example.com");
    // Сокеты накапливаются в TIME_WAIT
}

2. Отсутствие повторного использования соединений

HttpClient поддерживает HTTP Keep-Alive, но при создании нового экземпляра:

• Теряется возможность повторного использования существующих соединений
• Увеличивается время установки TCP-соединения для каждого запроса

3. Проблемы с DNS

При длительном использовании одного экземпляра HttpClient:

• Кэшируется DNS запись при создании
• Изменения DNS не подхватываются (проблема для микросервисов в облаке)

4. Отсутствие централизованной конфигурации

Трудно управлять:

• Таймаутами
• Политиками повторов
• Цепочками обработчиков
• Аутентификацией

Решение: IHttpClientFactory

IHttpClientFactory — паттерн, представленный в .NET Core 2.1, который решает все указанные проблемы.

Преимущества использования фабрики:

1. Управление жизненным циклом HttpMessageHandler

Фабрика создает и управляет пулом HttpMessageHandler:

• Хэндлеры живут дольше, чем экземпляры HttpClient
• Сокеты эффективно переиспользуются
• Исключается исчерпание портов

// Регистрация в Startup/Program.cs
services.AddHttpClient();

// Использование через инъекцию зависимости
public class MyService
{
    private readonly HttpClient _client;
    
    public MyService(IHttpClientFactory factory)
    {
        _client = factory.CreateClient(); // Использует общий пул хэндлеров
    }
}

2. Именованные клиенты для конфигурации

services.AddHttpClient("GitHubClient", client =>
{
    client.BaseAddress = new Uri("https://api.github.com/");
    client.DefaultRequestHeaders.Add("Accept", "application/vnd.github.v3+json");
    client.Timeout = TimeSpan.FromSeconds(30);
});

// Использование именованного клиента
var client = _factory.CreateClient("GitHubClient");

3. Типизированные клиенты для лучшей инкапсуляции

public interface IGitHubService
{
    Task<User> GetUserAsync(string username);
}

public class GitHubService : IGitHubService
{
    private readonly HttpClient _client;
    
    public GitHubService(HttpClient client)
    {
        _client = client;
        _client.BaseAddress = new Uri("https://api.github.com/");
    }
    
    public async Task<User> GetUserAsync(string username)
    {
        var response = await _client.GetAsync($"/users/{username}");
        // Обработка ответа
    }
}

// Регистрация
services.AddHttpClient<IGitHubService, GitHubService>();

4. Интеграция с Polly для устойчивости

services.AddHttpClient<IGitHubService, GitHubService>()
    .AddTransientHttpErrorPolicy(policy => 
        policy.WaitAndRetryAsync(3, retryAttempt => 
            TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))))
    .AddCircuitBreakerPolicy(10, TimeSpan.FromSeconds(30));

5. Автоматическое обновление DNS

Благодаря ограниченному времени жизни хэндлеров (по умолчанию 2 минуты):

• Периодически создаются новые хэндлеры
• DNS записи обновляются
• Решается проблема для облачных развертываний

Как работает под капотом:

// Упрощенная реализация пула хэндлеров
public class HttpClientFactory
{
    private ConcurrentDictionary<string, HttpMessageHandler> _handlers;
    
    public HttpClient CreateClient(string name)
    {
        // 1. Получаем или создаем HttpMessageHandler из пула
        var handler = GetOrCreateHandler(name);
        
        // 2. Создаем HttpClient с общим handler
        var client = new HttpClient(handler, disposeHandler: false);
        
        // 3. Применяем конфигурацию
        ConfigureClient(client, name);
        
        return client;
    }
}

Рекомендации по использованию

1. Всегда используйте IHttpClientFactory в ASP.NET Core приложениях
2. Не создавайте HttpClient напрямую через конструктор
3. Используйте типизированные клиенты для сервисов API
4. Настраивайте политики повторов через Polly
5. Инжектируйте HttpClient в сервисы, а не создавайте их

// ПРАВИЛЬНЫЙ ПРИМЕР
public class WeatherService
{
    private readonly HttpClient _client;
    
    public WeatherService(IHttpClientFactory factory)
    {
        _client = factory.CreateClient("WeatherAPI");
    }
    
    public async Task<Weather> GetWeatherAsync(string city)
    {
        return await _client.GetFromJsonAsync<Weather>($"/weather/{city}");
    }
}

Использование IHttpClientFactory обеспечивает оптимальное управление сетевыми ресурсами, улучшает производительность и надежность HTTP-вызовов, а также предоставляет гибкие возможности для конфигурации и обработки ошибок.