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

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).

Postaw mi kawę