C# / .NET Kompendium PLEN
.NET / C# / Web API, Blazor

Wykorzystanie ActionResult po stronie klienta (WPF/Blazor konsumujące Web API)

Kluczowe rozróżnienie na start

ActionResult<T> to typ zwracany przez kontroler po stronie serwera - klient (WPF, Blazor WASM, konsola) nigdy go nie widzi bezpośrednio. Klient dostaje tylko surową odpowiedź HTTP - kod statusu (200, 404, 400...) i ewentualnie JSON w body. Zadanie klienta to zinterpretować tę odpowiedź HTTP i przełożyć ją z powrotem na coś sensownego w Twoim kodzie (sukces + dane, albo błąd + komunikat).

Podstawowe podejście - HttpClient + sprawdzanie StatusCode

public class OrderApiClient : IOrderApiClient
{
    private readonly HttpClient _httpClient;
    public OrderApiClient(HttpClient httpClient) => _httpClient = httpClient;

    public async Task<OrderDto> GetOrderAsync(int id)
    {
        var response = await _httpClient.GetAsync($"api/orders/{id}");

        if (response.StatusCode == HttpStatusCode.NotFound)
            return null; // serwer zwrócił NotFound() -> tu interpretujemy to jako "brak zamówienia"

        response.EnsureSuccessStatusCode(); // rzuci wyjątek dla innych błędów (4xx/5xx)

        return await response.Content.ReadFromJsonAsync<OrderDto>(); // deserializacja JSON -> OrderDto
    }
}

Wzorzec Result<T> po stronie klienta - odzwierciedlenie tego, co serwer zwraca

public class ApiResult<T>
{
    public bool IsSuccess { get; private set; }
    public T Value { get; private set; }
    public string ErrorMessage { get; private set; }
    public HttpStatusCode StatusCode { get; private set; }

    public static ApiResult<T> Success(T value, HttpStatusCode statusCode)
        => new() { IsSuccess = true, Value = value, StatusCode = statusCode };

    public static ApiResult<T> Failure(string error, HttpStatusCode statusCode)
        => new() { IsSuccess = false, ErrorMessage = error, StatusCode = statusCode };
}
public class OrderApiClient : IOrderApiClient
{
    private readonly HttpClient _httpClient;

    public async Task<ApiResult<OrderDto>> GetOrderAsync(int id)
    {
        var response = await _httpClient.GetAsync($"api/orders/{id}");

        if (response.IsSuccessStatusCode)
        {
            var order = await response.Content.ReadFromJsonAsync<OrderDto>();
            return ApiResult<OrderDto>.Success(order, response.StatusCode);
        }

        // Próba odczytania ProblemDetails, jeśli serwer go zwrócił
        var problem = await response.Content.ReadFromJsonAsync<ProblemDetails>();
        var errorMessage = problem?.Detail ?? "Wystąpił nieoczekiwany błąd";

        return ApiResult<OrderDto>.Failure(errorMessage, response.StatusCode);
    }
}

Użycie w WPF ViewModel

public class OrderDetailsViewModel : ViewModelBase
{
    private readonly IOrderApiClient _apiClient;

    private OrderDto _order;
    public OrderDto Order
    {
        get => _order;
        set => SetProperty(ref _order, value);
    }

    private string _errorMessage;
    public string ErrorMessage
    {
        get => _errorMessage;
        set => SetProperty(ref _errorMessage, value);
    }

    private bool _isLoading;
    public bool IsLoading
    {
        get => _isLoading;
        set => SetProperty(ref _isLoading, value);
    }

    public ICommand LoadOrderCommand { get; }

    public OrderDetailsViewModel(IOrderApiClient apiClient)
    {
        _apiClient = apiClient;
        LoadOrderCommand = new AsyncRelayCommand(LoadOrderAsync);
    }

    private async Task LoadOrderAsync()
    {
        IsLoading = true;
        ErrorMessage = null;

        var result = await _apiClient.GetOrderAsync(orderId: 5);

        if (result.IsSuccess)
        {
            Order = result.Value;
        }
        else if (result.StatusCode == HttpStatusCode.NotFound)
        {
            ErrorMessage = "Zamówienie nie istnieje.";
        }
        else
        {
            ErrorMessage = result.ErrorMessage; // pokazujesz błąd w UI, binding automatycznie odświeży
        }

        IsLoading = false;
    }
}
<StackPanel>
    <TextBlock Text="{Binding ErrorMessage}" Foreground="Red"
               Visibility="{Binding ErrorMessage, Converter={StaticResource StringToVisibilityConverter}}" />
    <ProgressBar IsIndeterminate="{Binding IsLoading}" />
    <TextBlock Text="{Binding Order.CustomerName}" />
</StackPanel>

Obsługa operacji zapisu (POST) - CreatedAtAction po stronie klienta

Serwer:

[HttpPost]
public async Task<ActionResult<OrderDto>> CreateOrder(CreateOrderRequest request)
{
    var order = await _orderService.CreateOrderAsync(request);
    return CreatedAtAction(nameof(GetOrder), new { id = order.Id }, order); // 201 + Location header
}

Klient:

public async Task<ApiResult<OrderDto>> CreateOrderAsync(CreateOrderRequest request)
{
    var response = await _httpClient.PostAsJsonAsync("api/orders", request);

    if (response.StatusCode == HttpStatusCode.Created) // 201
    {
        var order = await response.Content.ReadFromJsonAsync<OrderDto>();
        return ApiResult<OrderDto>.Success(order, response.StatusCode);
    }

    if (response.StatusCode == HttpStatusCode.BadRequest) // 400 - błędy walidacji
    {
        var validationErrors = await response.Content.ReadFromJsonAsync<ValidationProblemDetails>();
        var messages = string.Join(", ", validationErrors.Errors.SelectMany(e => e.Value));
        return ApiResult<OrderDto>.Failure(messages, response.StatusCode);
    }

    return ApiResult<OrderDto>.Failure("Nieznany błąd", response.StatusCode);
}

Blazor - identyczny mechanizm, inny kontekst

@inject IOrderApiClient ApiClient

<button @onclick="LoadOrder">Załaduj zamówienie</button>
@if (isLoading) { <p>Ładowanie...</p> }
@if (errorMessage != null) { <p class="text-danger">@errorMessage</p> }
@if (order != null) { <p>@order.CustomerName</p> }

@code {
    private OrderDto order;
    private string errorMessage;
    private bool isLoading;

    private async Task LoadOrder()
    {
        isLoading = true;
        var result = await ApiClient.GetOrderAsync(5);

        if (result.IsSuccess) order = result.Value;
        else errorMessage = result.ErrorMessage;

        isLoading = false;
        StateHasChanged(); // ręczne odświeżenie, jeśli poza normalnym cyklem eventów
    }
}

Obsługa wyjątków sieciowych (osobna kategoria od błędów HTTP)

To jest inna kategoria problemów niż "serwer zwrócił 404" - tu chodzi o sytuacje, gdy w ogóle nie udało się dotrzeć do serwera:

public async Task<ApiResult<OrderDto>> GetOrderAsync(int id)
{
    try
    {
        var response = await _httpClient.GetAsync($"api/orders/{id}");
        // ... obsługa jak wyżej
    }
    catch (HttpRequestException ex)
    {
        // Brak połączenia, DNS się nie rozwiązał, serwer offline itd.
        return ApiResult<OrderDto>.Failure("Brak połączenia z serwerem", HttpStatusCode.ServiceUnavailable);
    }
    catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
    {
        // Timeout - HttpClient.Timeout został przekroczony
        return ApiResult<OrderDto>.Failure("Przekroczono czas oczekiwania", HttpStatusCode.RequestTimeout);
    }
}

To jest ważne, żeby WPF/Blazor nigdy nie crashowało przy zerwanym połączeniu internetowym - zamiast tego pokazuje sensowny komunikat użytkownikowi.

Typowany klient generowany automatycznie - alternatywa (Refit/OpenAPI)

Warto wspomnieć jako ciekawostkę - zamiast ręcznie pisać OrderApiClient z HttpClient, biblioteki jak Refit pozwalają zdefiniować kontrakt jako interfejs:

public interface IOrderApi
{
    [Get("/api/orders/{id}")]
    Task<ApiResponse<OrderDto>> GetOrderAsync(int id); // ApiResponse<T> z Refit - opakowuje HttpResponseMessage + dane

    [Post("/api/orders")]
    Task<ApiResponse<OrderDto>> CreateOrderAsync([Body] CreateOrderRequest request);
}

ApiResponse<T> z Refit ma podobną rolę do mojego ręcznego ApiResult<T> - opakowuje zarówno StatusCode, jak i zdeserializowaną wartość, żeby nie trzeba było ręcznie pisać HttpClient.GetAsync + sprawdzania statusu za każdym razem.

Podsumowanie - most między serwerem a klientem

Serwerowy ActionResult<T> (Ok(order), NotFound(), BadRequest(...)) tłumaczy się wyłącznie na kod statusu HTTP + opcjonalne body JSON - klient nie ma dostępu do tego, że serwer "zwrócił NotFound()", widzi tylko response.StatusCode == HttpStatusCode.NotFound. Dlatego kluczowe jest symetryczne zaprojektowanie obu stron: serwer konsekwentnie zwraca odpowiednie kody statusu dla różnych sytuacji, a klient (przez własny wrapper typu ApiResult<T>, albo bibliotekę jak Refit) konsekwentnie je interpretuje z powrotem na coś, co ViewModel/komponent Blazor może pokazać użytkownikowi - błąd, brak danych, albo sukces z wartością.

Postaw mi kawę