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