C# / .NET Kompendium PLEN
.NET / C# / Przypomnienie / wzorce web

Code Review - przykład z antywzorcami HttpClientFactory

Kod poddany review

public class WeatherApiClient
{
    private readonly HttpClient _httpClient;

    // ❌ PROBLEM 1: publiczny konstruktor bezparametrowy tworzący WŁASNY HttpClient
    public WeatherApiClient()
    {
        _httpClient = new HttpClient();
        _httpClient.BaseAddress = new Uri("https://api.weather.com/");
    }

    public async Task<WeatherDto> GetWeatherAsync(string city)
    {
        try
        {
            var response = await _httpClient.GetAsync($"weather?city={city}");
            var json = await response.Content.ReadAsStringAsync();
            return JsonSerializer.Deserialize<WeatherDto>(json);
        }
        catch (Exception ex) // ❌ PROBLEM 2: łapanie WSZYSTKICH wyjątków, myląca obsługa błędów
        {
            Console.WriteLine("Błąd: " + ex.Message);
            return null; // ❌ PROBLEM 3: ukrywa błąd, wywołujący nie wie CO się nie udało
        }
    }
}

Problem #1: Socket Exhaustion - new HttpClient() w konstruktorze

To jest najbardziej krytyczny i najczęściej pytany problem na rozmowach o .NET/Web API. HttpClient implementuje IDisposable, więc intuicyjnie ktoś mógłby pomyśleć, że trzeba go using-ować przy każdym użyciu:

// ❌ JESZCZE GORZEJ - jeśli ktoś "naprawi" to przez using
public async Task<WeatherDto> GetWeatherAsync(string city)
{
    using var httpClient = new HttpClient(); // NOWY klient przy KAŻDYM wywołaniu!
    // ...
}

Dlaczego to jest katastrofalne: każde utworzenie HttpClient tworzy nowe gniazdo sieciowe (socket). System operacyjny nie zwalnia natychmiast socketów po zamknięciu połączenia - wchodzą w stan TIME_WAIT (typowo 240 sekund w Windows). Przy dużym ruchu (setki/tysiące requestów na minutę), aplikacja wyczerpuje dostępne porty/sockety systemu operacyjnego, co prowadzi do SocketException: Address already in use albo ogólnego zawieszenia aplikacji pod obciążeniem.

To jest dokładnie ten problem, o którym mówiliśmy przy Singleton/thread-safety - HttpClient jest zaprojektowany, żeby być reużywalny i thread-safe dla wielu równoczesnych requestów - tworzenie nowej instancji przy każdym wywołaniu niweluje tę zaletę.

Poprawne rozwiązanie - IHttpClientFactory

// Program.cs - rejestracja
builder.Services.AddHttpClient<IWeatherApiClient, WeatherApiClient>(client =>
{
    client.BaseAddress = new Uri("https://api.weather.com/");
});
public class WeatherApiClient : IWeatherApiClient
{
    private readonly HttpClient _httpClient;

    // ✅ Konstruktor injection - HttpClient WSTRZYKNIĘTY, nie tworzony ręcznie
    public WeatherApiClient(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    public async Task<WeatherDto> GetWeatherAsync(string city)
    {
        var response = await _httpClient.GetAsync($"weather?city={city}");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadFromJsonAsync<WeatherDto>();
    }
}

IHttpClientFactory (rejestrowane przez AddHttpClient<TInterface, TImplementation>) zarządza poolem handlerów HTTP pod spodem - reużywa połączenia TCP między requestami, a jednocześnie automatycznie odświeża handlery po pewnym czasie (domyślnie 2 minuty), żeby respektować zmiany DNS (co jest problemem, gdyby HttpClient był czystym Singletonem żyjącym wiecznie bez odświeżania).

Problem #2: Zbyt ogólne catch (Exception) - myląca obsługa błędów

catch (Exception ex) // łapie WSZYSTKO - włącznie z OutOfMemoryException, StackOverflowException...
{
    Console.WriteLine("Błąd: " + ex.Message);
    return null;
}

Dlaczego to jest problematyczne: 1. Łapanie zbyt szerokiej kategorii wyjątków - catch (Exception) przechwytuje wszystko, w tym błędy programistyczne (NullReferenceException, ArgumentException), które powinny wywalić się głośno w developmencie, a nie zostać "połknięte" 2. Console.WriteLine jako "logowanie" - w prawdziwej aplikacji serwerowej to jest bezużyteczne (nikt nie czyta konsoli produkcyjnego serwera) - powinno być ILogger<T> (wstrzykiwane przez DI, jak omawialiśmy) 3. Zwrócenie null przy błędzie - to jest Problem #3, patrz niżej

Poprawione podejście - selektywna obsługa błędów

public async Task<WeatherDto> GetWeatherAsync(string city)
{
    try
    {
        var response = await _httpClient.GetAsync($"weather?city={city}");
        response.EnsureSuccessStatusCode(); // rzuci HttpRequestException dla 4xx/5xx
        return await response.Content.ReadFromJsonAsync<WeatherDto>();
    }
    catch (HttpRequestException ex) // ✅ KONKRETNY typ wyjątku, oczekiwany scenariusz
    {
        _logger.LogWarning(ex, "Nie udało się pobrać pogody dla miasta {City}", city);
        throw new WeatherServiceUnavailableException(city, ex); // przetłumaczony na wyjątek DOMENOWY
    }
    // Wyjątki NIEoczekiwane (NullReferenceException itp.) LECĄ DALEJ, nie są "połknięte"
}

Problem #3: Zwracanie null przy błędzie - ukrywanie informacji o awarii

return null; // wywołujący NIE WIE, czy: (a) miasto nie istnieje, (b) API padło, (c) błąd sieci

Konsekwencja dla wywołującego kodu:

var weather = await _weatherApiClient.GetWeatherAsync("Warszawa");
Console.WriteLine(weather.Temperature); // ❌ NullReferenceException, jeśli GetWeatherAsync zwróciło null!

Wywołujący musi pamiętać o sprawdzeniu null wszędzie, gdzie używa tej metody - a nie wie, dlaczego dostał null (miasto nie istnieje? serwis padł? błąd sieci?) - to utrudnia odpowiednią reakcję (np. "spróbuj ponownie" dla błędu sieci vs "pokaż błąd użytkownikowi" dla nieistniejącego miasta).

Lepsze podejście - Result<T> (nawiązanie do wcześniejszej rozmowy o ActionResult po stronie klienta)

public async Task<ApiResult<WeatherDto>> GetWeatherAsync(string city)
{
    try
    {
        var response = await _httpClient.GetAsync($"weather?city={city}");

        if (response.StatusCode == HttpStatusCode.NotFound)
            return ApiResult<WeatherDto>.Failure($"Miasto '{city}' nie zostało znalezione", response.StatusCode);

        response.EnsureSuccessStatusCode();
        var weather = await response.Content.ReadFromJsonAsync<WeatherDto>();
        return ApiResult<WeatherDto>.Success(weather, response.StatusCode);
    }
    catch (HttpRequestException ex)
    {
        _logger.LogWarning(ex, "Błąd połączenia przy pobieraniu pogody dla {City}", city);
        return ApiResult<WeatherDto>.Failure("Serwis pogodowy niedostępny", HttpStatusCode.ServiceUnavailable);
    }
}

Wywołujący jawnie dostaje informację o rodzaju niepowodzenia, dokładnie jak w przykładzie ApiResult<T>, który omawialiśmy przy konsumpcji ActionResult po stronie klienta.

Podsumowanie zbiorcze problemów i poprawek

Problem Konsekwencja Rozwiązanie
new HttpClient() w konstruktorze Socket exhaustion pod obciążeniem IHttpClientFactory przez AddHttpClient<T>(), wstrzykiwany HttpClient
catch (Exception) ogólny Łapie błędy programistyczne, utrudnia debugowanie Łap konkretne typy wyjątków (HttpRequestException), reszta leci dalej
Console.WriteLine jako logowanie Bezużyteczne na produkcji ILogger<T> przez DI
return null przy błędzie Ukrywa przyczynę, wymusza sprawdzanie null wszędzie Result<T>/wyjątek domenowy z jasną informacją o przyczynie

Dlaczego ten typ pytania jest częsty na rozmowach SE III

Code review to praktyczny test integrujący wiele tematów naraz - ten jeden fragment kodu dotyka: zarządzania zasobami (HttpClient/DI), dobrych praktyk obsługi wyjątków, jakości logowania, i projektowania API zwracanych wartości (null vs Result<T>). Dobra odpowiedź na rozmowie nie kończy się na "HttpClient powinien być z DI" - pokazuje zrozumienie wszystkich warstw problemu i dlaczego każda poprawka ma znaczenie w kontekście produkcyjnej aplikacji pod obciążeniem.

Postaw mi kawę