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
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:
// Program.cs
builder.Services.AddScoped<IOrderService, OrderService>();
@inject IOrderService OrderService
Component lifecycle
protected override void OnInitialized() { } // odpowiednik konstruktora ViewModelu
protected override async Task OnInitializedAsync() { } // dla async inicjalizacji
protected override void OnParametersSet() { } // gdy zmienią się [Parameter]
protected override bool ShouldRender() => true; // kontrola czy re-renderować
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.
Blazor Server vs WASM - różnice praktyczne
| 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 | Natychmiastowe (kod lokalnie) |
| Rozmiar pobrania | Mały | Duży (pobiera cały runtime .NET) |
| Offline | ❌ Nie | ✅ Może działać offline (PWA) |
| Skalowanie serwera | Każdy user = stały stan na serwerze | Serwer tylko serwuje pliki statyczne + API |
Gdzie Web API i Blazor się spotykają w architekturze
Blazor WASM (frontend) → HttpClient → ASP.NET Core Web API (backend) → Service → EF Core → baza
@inject HttpClient Http
@code {
private List<OrderDto> orders;
protected override async Task OnInitializedAsync()
{
orders = await Http.GetFromJsonAsync<List<OrderDto>>("api/orders");
}
}
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).