ASP.NET Core Web API oraz Blazor - MVC i pokrewne wzorce
Web API to rzeczywiście implementacja wzorca MVC (a właściwie okrojonego "MC" - bez V, bo zwraca dane, nie widoki), natomiast Blazor nie jest MVC - to komponentowy model UI, bliższy React/Angular niż tradycyjnemu MVC.
Przypomnienie: MVC (Model-View-Controller)
- Model - dane i logika biznesowa
- View - warstwa prezentacji (co widzi użytkownik)
- Controller - odbiera request, koordynuje Model i View, zwraca odpowiedź
ASP.NET Core Web API jako implementacja MVC
Web API to w praktyce MVC bez V - zamiast zwracać HTML (View), zwraca dane (JSON/XML). Struktura jest bardzo podobna do WPF-owego MVVM - Controller pełni trochę rolę pośrednika, podobnie jak ViewModel.
Controller - punkt wejścia requestu
[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
private readonly IOrderService _orderService; // DI
public OrdersController(IOrderService orderService)
{
_orderService = orderService;
}
[HttpGet("{id}")]
public async Task<ActionResult<OrderDto>> GetOrder(int id)
{
var order = await _orderService.GetOrderAsync(id);
if (order == null) return NotFound();
return Ok(order);
}
[HttpPost]
public async Task<ActionResult<OrderDto>> CreateOrder(CreateOrderRequest request)
{
var order = await _orderService.CreateOrderAsync(request);
return CreatedAtAction(nameof(GetOrder), new { id = order.Id }, order);
}
}
[ApiController] - atrybut włączający konwencje specyficzne dla API: automatyczna walidacja modelu (400 Bad Request bez ręcznego if (!ModelState.IsValid)), automatyczne binowanie parametrów z route/body, lepsze komunikaty błędów.
Model - DTO zamiast encji domenowej
Ważna praktyka: nie zwracaj bezpośrednio encji EF Core z API - zwracasz DTO (Data Transfer Object).
// Encja domenowa - używana wewnętrznie, ma nawigacje, może mieć pola techniczne
public class Order
{
public int Id { get; set; }
public Customer Customer { get; set; } // nawigacja EF - ryzyko cyklicznej serializacji
public ICollection<OrderItem> Items { get; set; }
}
// DTO - dokładnie to, co ma zobaczyć klient, nic więcej
public record OrderDto(int Id, string CustomerName, decimal Total, List<OrderItemDto> Items);
Dlaczego to ważne:
- Unikasz przypadkowego wycieku danych wrażliwych (np. pole PasswordHash w encji User)
- Unikasz cyklicznych referencji przy serializacji JSON (Order.Customer.Orders.First().Customer...)
- Kontrakt API jest niezależny od struktury bazy danych - możesz zmienić model EF bez łamania API
Routing - Attribute-based (dominujący w Web API)
[HttpGet("{id}")] // GET api/orders/5
[HttpGet("search")] // GET api/orders/search
[HttpGet("{id}/items")] // GET api/orders/5/items
[HttpPost] // POST api/orders
[HttpPut("{id}")] // PUT api/orders/5
[HttpDelete("{id}")] // DELETE api/orders/5
Middleware pipeline - IoC w praktyce
var app = builder.Build();
app.UseHttpsRedirection();
app.UseAuthentication();
app.UseAuthorization();
app.MapControllers();
app.Run();
To dokładnie ten mechanizm IoC z middleware - framework sam decyduje, kiedy wywołać który middleware, w jakiej kolejności, Ty tylko rejestrujesz "co ma się stać".
Minimal APIs - alternatywa dla kontrolerów (nowsze podejście, .NET 6+)
app.MapGet("/api/orders/{id}", async (int id, IOrderService orderService) =>
{
var order = await orderService.GetOrderAsync(id);
return order != null ? Results.Ok(order) : Results.NotFound();
});
To wciąż jest MVC-podobne konceptualnie (endpoint = mini-kontroler), tylko bez klasy Controller - lżejsze, mniej boilerplate'u, popularne w mikroserwisach.
Warstwowa architektura Web API
Controller (MVC)
↓
Service (logika biznesowa)
↓
Repository (EF Core)
↓
Baza danych
[ApiController]
public class OrdersController : ControllerBase
{
private readonly IOrderService _orderService; // Controller NIE zna EF Core bezpośrednio
// ...
}
Controller nie powinien zawierać logiki biznesowej ani bezpośrednio wołać DbContext - to jest analogiczne do tego, co mówiliśmy o ViewModelu w WPF: cienka warstwa koordynująca, cała logika w serwisie.
Blazor - dlaczego to NIE jest MVC
To jest kluczowy punkt do zaznaczenia na rozmowie, bo błędne przypisanie Blazor do MVC to sygnał powierzchownej wiedzy. Blazor to framework komponentowy (podobny filozoficznie do React czy Angular), a nie MVC.
Dwa modele hostingu Blazor
Blazor Server - logika wykonuje się na serwerze, UI aktualizowane przez SignalR (WebSocket) w czasie rzeczywistym.
Blazor WebAssembly (WASM) - cały kod C# kompilowany do WebAssembly i wykonywany w przeglądarce, bez round-tripów do serwera przy każdej interakcji.
Komponent Blazor - odpowiednik "View + trochę logiki"
@page "/orders/{id:int}"
@inject IOrderService OrderService
<h3>Zamówienie #@Order?.Id</h3>
@if (Order == null)
{
<p>Ładowanie...</p>
}
else
{
<p>Klient: @Order.CustomerName</p>
<p>Suma: @Order.Total zł</p>
<button @onclick="ShipOrder">Wyślij zamówienie</button>
}
@code {
[Parameter] public int Id { get; set; }
private OrderDto Order;
protected override async Task OnInitializedAsync()
{
Order = await OrderService.GetOrderAsync(Id);
}
private async Task ShipOrder()
{
await OrderService.ShipOrderAsync(Id);
Order = await OrderService.GetOrderAsync(Id);
}
}
Dlaczego to bliżej MVVM niż MVC
To jest ciekawe spostrzeżenie do pokazania na rozmowie - komponent Blazor łączy to, co w MVC było rozdzielone na Controller + View, w jedną jednostkę:
| MVC | Blazor | MVVM (WPF) | |
|---|---|---|---|
| UI (znaczniki) | View (.cshtml) |
Sekcja HTML w .razor |
XAML |
| Logika prezentacji | Controller | Sekcja @code w tym samym pliku |
ViewModel (osobny plik) |
| Odświeżanie UI | Pełne przeładowanie strony (albo ręczny JS) | Automatyczne re-renderowanie przy zmianie stanu | Automatyczne przez INotifyPropertyChanged/binding |
| DI | Przez konstruktor kontrolera | @inject |
Przez konstruktor ViewModelu |
@inject w Blazor to DI - dokładnie ten sam kontener Microsoft.Extensions.DependencyInjection, który już znasz z Web API i WPF:
// Program.cs
builder.Services.AddScoped<IOrderService, OrderService>();
@inject IOrderService OrderService
To pokazuje spójność ekosystemu .NET - ten sam mechanizm DI działa identycznie w Web API, Blazor i (jak pokazywaliśmy) w WPF.
Component lifecycle - odpowiednik cyklu życia, o którym mówiliśmy przy WPF
protected override void OnInitialized() { } // odpowiednik konstruktora ViewModelu
protected override async Task OnInitializedAsync() { } // dla async inicjalizacji (np. pierwsze pobranie danych)
protected override void OnParametersSet() { } // gdy zmienią się [Parameter]
protected override bool ShouldRender() => true; // kontrola czy re-renderować (optymalizacja)
StateHasChanged - ręczne odświeżenie UI
private async Task LoadDataInBackground()
{
var data = await _service.GetDataAsync();
Orders = data;
StateHasChanged(); // każ Blazorowi przerenderować komponent
}
To jest koncepcyjnie bardzo bliskie temu, co robi PropertyChanged w WPF - tam framework nasłuchuje eventu i sam odświeża UI, tutaj czasem trzeba to wywołać jawnie (np. gdy zmiana stanu dzieje się poza normalnym cyklem eventów Blazora, np. w callbacku z zewnętrznego serwisu).
Blazor Server vs WASM - różnice praktyczne (częste pytanie)
| Blazor Server | Blazor WebAssembly | |
|---|---|---|
| Gdzie wykonuje się kod | Serwer | Przeglądarka (WASM) |
| Komunikacja | SignalR (stałe połączenie WebSocket) | Bezpośrednio w przeglądarce, HTTP do API gdy trzeba |
| Opóźnienie interakcji | Zależne od sieci (każdy klik = round-trip do serwera) | Natychmiastowe (kod lokalnie) |
| Rozmiar pobrania | Mały (brak runtime .NET w przeglądarce) | Duży (pobiera cały runtime .NET) |
| Offline | ❌ Nie działa bez połączenia | ✅ Może działać offline (PWA) |
| Skalowanie serwera | Każdy user = stały stan na serwerze (pamięć, SignalR connection) | Serwer tylko serwuje pliki statyczne + API |
Blazor United / Blazor Web App (.NET 8+) - warto wspomnieć, że nowsze .NET pozwala mieszać oba modele w jednej aplikacji, z tzw. render modes (Static SSR, Server, WebAssembly, Auto) wybieranymi per-komponent.
Gdzie Web API i Blazor się spotykają w architekturze
Typowy układ, analogiczny do tego, co omawialiśmy z WPF:
Blazor WASM (frontend, działa w przeglądarce)
↓ HttpClient → wywołania HTTP
ASP.NET Core Web API (backend)
↓
Service (logika biznesowa)
↓
EF Core → baza danych
// W komponencie Blazor WASM
@inject HttpClient Http
@code {
private List<OrderDto> orders;
protected override async Task OnInitializedAsync()
{
orders = await Http.GetFromJsonAsync<List<OrderDto>>("api/orders");
}
}
To jest strukturalnie identyczne do architektury WPF → API, którą omawialiśmy przy okazji async/EF Core - różni się tylko technologia frontendu (Blazor WASM w przeglądarce zamiast WPF na desktopie), ale warstwy backendowe (Controller → Service → Repository → EF) są dokładnie te same.
Blazor Server natomiast nie potrzebuje oddzielnego Web API pośrodku - komponent może bezpośrednio wstrzyknąć IOrderService przez DI i wywołać go lokalnie (bo kod i tak wykonuje się na serwerze) - to jest różnica architektoniczna, o którą czasem pytają: "Czy w Blazor Server potrzebujesz osobnego Web API?" - odpowiedź: niekoniecznie, możesz wstrzyknąć serwisy bezpośrednio, chyba że ten sam backend ma też obsługiwać inne klienty (mobile, WPF, Blazor WASM) - wtedy Web API jako wspólna warstwa ma sens.
Podsumowanie różnicy koncepcyjnej
"ASP.NET Core Web API to rzeczywiście implementacja MVC, tylko bez View - Controller zwraca dane (JSON) zamiast HTML. Blazor natomiast to framework komponentowy, konceptualnie bliższy MVVM albo React niż klasycznemu MVC - komponent łączy w jednym pliku to, co w MVC byłoby rozdzielone na View i Controller, a stan komponentu automatycznie synchronizuje się z UI, podobnie jak binding w WPF. Oba używają tego samego mechanizmu DI z Microsoft.Extensions.DependencyInjection, co pokazuje spójność całego ekosystemu ASP.NET Core."