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

Standardowa struktura projektu Blazor

Blazor WebAssembly (samodzielny, bez osobnego backendu)

MyBlazorApp/
├── wwwroot/                       ← pliki statyczne, serwowane bezpośrednio
│   ├── css/
│   │   └── app.css
│   ├── index.html                 ← jedyny "prawdziwy" plik HTML, punkt wejścia SPA
│   ├── favicon.png
│   ├── manifest.json              ← z rozmowy o PWA
│   └── service-worker.js          ← z rozmowy o PWA
├── Pages/                         ← komponenty routowalne (@page)
│   ├── Home.razor
│   ├── Counter.razor
│   ├── Orders/
│   │   ├── OrderList.razor
│   │   └── OrderDetails.razor
├── Shared/                        ← komponenty współdzielone, layouty
│   ├── MainLayout.razor
│   ├── NavMenu.razor
│   └── OrderCard.razor            ← reużywalny komponent (bez @page)
├── Models/                        ← modele/DTO używane w UI
│   └── OrderDto.cs
├── Services/                      ← logika, klienci API
│   ├── IOrderApiClient.cs
│   └── OrderApiClient.cs
├── wwwroot/appsettings.json       ← konfiguracja (adres API itp.)
├── _Imports.razor                 ← globalne "using" dla wszystkich .razor
├── App.razor                      ← korzeń routingu (<Router>)
├── Program.cs                     ← punkt startowy, konfiguracja DI
└── MyBlazorApp.csproj

Kluczowe pliki - co robią

Program.cs - punkt startowy, DI (dokładnie ten sam kontener, o którym mówiliśmy przy WPF/Web API):

var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add<App>("#app");

builder.Services.AddHttpClient<IOrderApiClient, OrderApiClient>(client =>
    client.BaseAddress = new Uri(builder.Configuration["ApiBaseUrl"]));
builder.Services.AddScoped<IOrderApiClient, OrderApiClient>();

await builder.Build().RunAsync();

App.razor - korzeń aplikacji, definiuje routing:

<Router AppAssembly="@typeof(App).Assembly">
    <Found Context="routeData">
        <RouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)" />
    </Found>
    <NotFound>
        <LayoutView Layout="@typeof(MainLayout)">
            <p>Strona nie znaleziona</p>
        </LayoutView>
    </NotFound>
</Router>

_Imports.razor - globalne using, żeby nie powtarzać w każdym komponencie:

@using System.Net.Http
@using Microsoft.AspNetCore.Components.Routing
@using MyBlazorApp.Models
@using MyBlazorApp.Services

wwwroot/index.html - punkt wejścia dla WASM (jedyny "prawdziwy" HTML):

<!DOCTYPE html>
<html>
<head>
    <link href="css/app.css" rel="stylesheet" />
</head>
<body>
    <div id="app">Ładowanie...</div>
    <script src="_framework/blazor.webassembly.js"></script>
</body>
</html>

Shared/MainLayout.razor - wspólny layout (nagłówek, menu, stopka):

@inherits LayoutComponentBase

<div class="page">
    <NavMenu />
    <main>
        @Body
    </main>
</div>

Blazor Server - struktura minimalnie inna

MyBlazorServerApp/
├── wwwroot/
│   └── css/site.css
├── Pages/
│   ├── _Host.cshtml               ← plik startowy (Razor Page, nie .razor!), serwuje pierwszą stronę
│   ├── Home.razor
│   └── Orders/
├── Shared/
│   ├── MainLayout.razor
│   └── NavMenu.razor
├── Data/                          ← często zamiast Services/ w domyślnym szablonie
│   └── OrderService.cs
├── Hubs/                          ← opcjonalnie, jeśli własne SignalR huby poza domyślnym Blazor
├── App.razor
├── Program.cs
├── appsettings.json                ← configi PO STRONIE SERWERA (connection stringi itd.)
└── MyBlazorServerApp.csproj

Kluczowa różnica: Pages/_Host.cshtml (Razor Page, nie komponent Blazor) - to jest klasyczna strona ASP.NET Core, która renderuje pierwszy komponent Blazor i ładuje skrypt blazor.server.js (SignalR). Bezpośredni dostęp do bazy z Data/OrderService.cs jest tu bardziej naturalny (bo kod i tak wykonuje się na serwerze, jak omawialiśmy przy SignalR/circuit).

// Program.cs - Blazor Server
builder.Services.AddRazorPages();
builder.Services.AddServerSideBlazor();
builder.Services.AddDbContext<AppDbContext>(options => options.UseSqlServer(connectionString)); // bezpośredni EF Core

app.MapBlazorHub(); // endpoint SignalR
app.MapFallbackToPage("/_Host");

.NET 8+ Blazor Web App (połączony model, z Render Modes)

Nowy, ujednolicony szablon łączący wszystko, o czym mówiliśmy przy Render Modes:

MyBlazorWebApp/
├── Client/                        ← osobny PROJEKT dla komponentów WASM
│   ├── Program.cs
│   ├── _Imports.razor
│   └── Pages/
│       └── Counter.razor          ← komponent renderowany jako WASM
├── Components/                    ← komponenty renderowane server-side (domyślnie)
│   ├── Layout/
│   │   ├── MainLayout.razor
│   │   └── NavMenu.razor
│   ├── Pages/
│   │   ├── Home.razor
│   │   └── Weather.razor
│   ├── App.razor                  ← korzeń, teraz zawiera <html>/<head>/<body>
│   └── Routes.razor                ← wydzielony routing (osobno od App.razor)
├── wwwroot/
├── Program.cs                     ← host WSZYSTKICH render modes naraz
└── MyBlazorWebApp.csproj

Kluczowa nowość - Program.cs konfiguruje oba modele naraz:

builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents()      // Interactive Server
    .AddInteractiveWebAssemblyComponents(); // Interactive WebAssembly

app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode()
    .AddInteractiveWebAssemblyRenderMode()
    .AddAdditionalAssemblies(typeof(MyBlazorWebApp.Client._Imports).Assembly); // odwołanie do projektu Client

Client/ to osobny projekt (.csproj) w tym samym rozwiązaniu - kod tam skompilowany do WASM i faktycznie pobierany przez przeglądarkę, podczas gdy Components/ w głównym projekcie domyślnie renderuje się server-side, chyba że komponent jawnie oznaczysz @rendermode InteractiveWebAssembly.


Typowa architektura z osobnym Web API

Dla Blazor WASM komunikującego się z osobnym backendem (dokładnie architektura "WPF/Blazor → Web API → EF Core"):

MySolution/
├── MyApp.Client/              ← Blazor WASM (frontend)
│   ├── Pages/
│   ├── Services/
│   │   └── OrderApiClient.cs  ← HttpClient do wywołań API
│   └── Program.cs
├── MyApp.Api/                 ← ASP.NET Core Web API (backend)
│   ├── Controllers/
│   │   └── OrdersController.cs
│   ├── Services/
│   │   └── OrderService.cs
│   ├── Data/
│   │   └── AppDbContext.cs
│   └── Program.cs
└── MyApp.Shared/              ← WSPÓLNY projekt z DTO, używany przez OBA powyższe
    └── DTOs/
        └── OrderDto.cs

MyApp.Shared to ważny, praktyczny wzorzec - projekt z wspólnymi DTO/Command/Query, referencowany zarówno przez Client, jak i Api. Dzięki temu OrderDto w record (jak omawialiśmy) jest zdefiniowany raz, a nie duplikowany po obu stronach - zmiana kontraktu w jednym miejscu jest widoczna po obu stronach kompilacji.

Podsumowanie - jak wybrać strukturę

Scenariusz Struktura
Prosta aplikacja WASM, mały zespół Standardowy szablon blazorwasm (Pages/Shared/Services)
Blazor Server, dostęp bezpośrednio do bazy Standardowy szablon blazorserver (Data/ zamiast Services/)
.NET 8+, chcesz elastyczność Render Modes Blazor Web App (Client + Components w jednym rozwiązaniu)
WASM + osobny, reużywalny Web API (np. też dla WPF/mobile) Trzy projekty: Client, Api, Shared (DTO)
Postaw mi kawę