## Wstęp merytoryczny: Fundamenty nowoczesnej architektury webowej

W niniejszym rozdziale przeanalizujemy fundamenty architektury **ASP.NET Core**, które stanowią niezbędną infrastrukturę dla frameworka **Blazor** oraz nowoczesnych interfejsów API. Przejście z aplikacji desktopowych opartych o **.NET Framework 4.8** na nowoczesny ekosystem sieciowy wymusza odrzucenie paradygmatu aplikacji stanowych (Stateful), w których system operacyjny zarządzał cyklem życia okna, na rzecz architektury bezstanowej (Stateless) opartej o rurociąg przetwarzania żądań HTTP. 

Środowisko uruchomieniowe w .NET 10 jest budowane w oparciu o modułowy mechanizm **Generic Host**, który integruje wbudowane wstrzykiwanie zależności (DI), konfigurację środowiskową oraz potok oprogramowania pośredniczącego (Middleware). Zrozumienie tych filarów jest krytyczne dla inżynierów migrujących systemy desktopowe, ponieważ w nowym modelu to infrastruktura serwerowa odpowiada za orkiestrację żądań, a UI jest jedynie odseparowaną warstwą prezentacji.

## Analiza Porównawcza: Desktop (4.8) vs ASP.NET Core (.NET 10)

| **Koncepcja Desktop (.NET 4.8)** | **Odpowiednik w ASP.NET Core (Blazor/.NET 10)** | **Charakter zmiany architektonicznej** |
| --- | --- | --- |
| **App.xaml.cs / Program.cs (Statyczne metody startowe)** | **Minimal API / WebApplicationBuilder (`Program.cs`)** | Inicjalizacja aplikacji została ujednolicona w jednym pliku używającym wzorca *Builder*, inicjalizującym Host, DI i rurociąg żądań. |
| **Globalne instancje (Wzorce Singleton / Zmienne statyczne)** | **Wbudowane Wstrzykiwanie Zależności (DI)** | Fundamentem współdzielenia stanu jest kontener DI wstrzykujący obiekty o zdefiniowanym cyklu życia (Transient, Scoped, Singleton) prosto do konstruktorów lub komponentów. |
| **Pliki App.config / Web.config (XML)** | **appsettings.json oraz Zmienne Środowiskowe** | Zastąpienie ciężkich plików XML elastyczną, hierarchiczną konfiguracją JSON, która automatycznie reaguje na zmianę środowiska wykonawczego. |
| **Ścisłe powiązanie z systemem Windows / IIS** | **Serwer Kestrel** | Aplikacja webowa uruchamia własny, wydajny i wieloplatformowy serwer Kestrel, uwalniając proces od konieczności hostowania przez systemowy IIS. |
| **Zdarzenia UI (Click, Load) w kodzie głównym** | **Modułowe Middleware** | Zamiast monolitycznej obsługi cyklu życia używa się filtrów i *Middleware*, w którym każde żądanie przechodzi przez kaskadowy potok (np. autoryzacja, routing, logowanie). |

## Głębokie Nurkowanie (Deep Dive): Kluczowe filary architektury

### Middleware (Rurociąg żądań HTTP)
Zamiast korzystać ze zmonolityzowanej biblioteki `System.Web`, na której w dużej mierze opierał się dawny ASP.NET, ASP.NET Core przetwarza żądania za pomocą sekwencji **Middleware**. Każdy komponent rurociągu analizuje przychodzący obiekt `HttpContext` i może podjąć decyzję o modyfikacji żądania, obsłużeniu go i zakończeniu procesu (tzw. zwarcie rurociągu - np. odesłanie pliku statycznego), lub przekazaniu wykonania do kolejnego modułu za pomocą asynchronicznego delegata.
Właściwa kolejność rejestracji oprogramowania pośredniczącego determinuje całe zachowanie aplikacji; na przykład middleware obsługujący wyjątki musi zostać dodany jako pierwszy, aby mógł przechwycić błędy z każdego kolejnego poziomu wykonania.

### Wstrzykiwanie Zależności (Dependency Injection)
W .NET 4.8 wstrzykiwanie zależności było opcjonalne i wymagało użycia zewnętrznych bibliotek. W środowisku ASP.NET Core DI jest pierwszoplanowym, wbudowanym rozwiązaniem strukturalnym, udostępniającym instancje na terenie całej aplikacji. Komponenty i kontrolery otrzymują wymagane serwisy (np. dostęp do bazy danych, mechanizmy uwierzytelniania) wyłącznie poprzez swoje konstruktory. Ten wzorzec radykalnie zwiększa testowalność oraz egzekwuje luźne powiązanie (loose coupling) klas.

### Serwer Kestrel i Hosting
Silnik ASP.NET Core tworzy instancję *Host*, hermetyzując implementację serwera HTTP, rurociąg middleware oraz mechanizmy takie jak logowanie i wstrzykiwanie konfiguracji. Odrzucono uzależnienie od ciężkiego oprogramowania OS, a głównym mechanizmem odbierania ruchu sieciowego stał się **Kestrel** – lekki, wieloplatformowy serwer sieciowy, optymalizowany pod kątem ogromnej przepustowości.

## Dobre Praktyki i Antywzorce

Proces adaptacji inżynierów desktopowych do technologii webowych często wiąże się z nawykami, które w ASP.NET Core są krytycznymi błędami.

*   **Antywzorzec: Przechowywanie tajemnic w kodzie:** Praktyka kodowania parametrów połączeń (connection strings) czy kluczy prywatnych w plikach z kodem źródłowym (bądź w lokalnym konfiguratorze dystrybuowanym z repozytorium) jest poważną luką bezpieczeństwa. W ASP.NET Core niejawne dane developerskie powiny być przetrzymywane przy użyciu narzędzia Secret Manager w środowisku programistycznym, a na produkcji w usługach typu Azure Key Vault.
*   **Dobra Praktyka: Hierarchiczna Konfiguracja `appsettings.json`:** Prawidłowo zaprojektowany system używa silnie typowanych klas dla ustawień konfiguracyjnych poprzez "Options Pattern", co integruje strukturę pliku konfiguracyjnego `appsettings.json` wprost do kontenera wstrzykiwania zależności.

## Laboratorium kodu: Architektura Punktu Wejścia (Program.cs)

Poniższy kod przedstawia ewolucję logiki inicjalizacji z monolitycznego pliku znanego z dawnego desktopu (czy WebForms), do minimalistycznego i deklaratywnego API w nowoczesnym środowisku .NET. Prezentuje powołanie instancji `WebApplicationBuilder`, rejestrację serwisów do kontenera DI, a ostatecznie skonfigurowanie asynchronicznego rurociągu Middleware.

```csharp
using Microsoft.EntityFrameworkCore;
using ModernApp.Data;

// Inicjalizacja budowniczego Host'a ze wbudowaną obsługą appsettings.json
var builder = WebApplication.CreateBuilder(args);

// --- REJESTRACJA SERWISÓW (DEPENDENCY INJECTION) ---
// Rejestracja bazy danych ze ścisłym wstrzykiwaniem parametru z konfiguracji
builder.Services.AddDbContextFactory<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

// Rejestracja obsługi środowiska Blazor
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

// Budowa instancji aplikacji
var app = builder.Build();

// --- KONFIGURACJA RUROCIĄGU (MIDDLEWARE PIPELINE) ---
// Kolejność wywołań determinuje cykl przetwarzania HTTP

// 1. Obsługa wyjątków - na samym początku rurociągu
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

// 2. Przekierowanie ruchu na protokół szyfrowany HTTPS
app.UseHttpsRedirection();

// 3. Obsługa plików statycznych (np. CSS/JS) z katalogu wwwroot
// Jeśli żądanie dotyczy pliku, rurociąg ulega zwarciu (short-circuit)
app.UseStaticFiles();

// 4. Mechanizmy zabezpieczeń przed atakami
app.UseAntiforgery();

// 5. Mapowanie tras i renderowanie interfejsu (Ostatni punkt węzłowy Middleware)
app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();

// Uruchomienie pętli nasłuchującej (Kestrel Server)
app.Run();
```


## Wnioski architektoniczne

Architektura ASP.NET Core oferuje modularność na poziomie wcześniej niedostępnym dla aplikacji desktopowych korzystających ze sztywnego ekosystemu Windows. Dzięki przejściu na jednolity standard `Generic Host`, elastycznemu strumieniowi `Middleware` i potężnemu wstrzykiwaniu zależności, programiści tworzący nowoczesne rozwiązania za pomocą **Blazor** otrzymują aplikacje maksymalnie skalowalne.

Zrozumienie fundamentów takich jak bezstanowość żądań HTTP, cykl życia wstrzykiwanych instancji oraz separacja warstwy konfiguracji pozwala inżynierom .NET 4.8 uniknąć kopiowania złych wzorców technicznych do nowego ekosystemu, otwierając drogę nie tylko dla zaawansowanego front-endu serwowanego w przeglądarce, ale i wieloplatformowych mikrouUsług rozwijanych ramię w ramię z logiką UI.