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 tylkoresponse.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 typuApiResult<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ą.