# Blog w C# w 2026 roku: blog techniczny na ASP.NET Core i Minimal APIs > Praktyczny przewodnik budowy bloga w C# na .NET 10: wpisy w Markdown z front matter, magazyn wpisów z przeładowaniem na gorąco, strony z komponentów Razor, output caching i kanał RSS. - Published: 2026-11-17 - Updated: 2026-11-17 - Author: Anthony Fillion-Maillet - Tags: dotnet, csharp, aspnet-core, minimal-apis, output-caching, tutorial - Reading time: 13 min --- Własny blog techniczny w C# nie wymaga dziś ani systemu CMS, ani bazy danych. Wystarczy katalog z plikami Markdown, jeden serwis typu singleton, który parsuje je przy starcie, kilka endpointów Minimal API zwracających HTML oraz kanał RSS. Na .NET 10, wydaniu z długoterminowym wsparciem (LTS) opublikowanym w listopadzie 2025 roku, prawie wszystkie potrzebne elementy znajdują się w samym frameworku, a resztę uzupełniają dwa dojrzałe pakiety NuGet. > **Cały stos w skrócie** > > Projekt webowy na .NET 10, Markdig do zamiany Markdown na HTML, YamlDotNet do odczytu front matter, niemutowalny magazyn wpisów w pamięci przeładowywany po zmianie pliku, endpointy Minimal API zwracające strony przez `RazorComponentResult`, output caching z unieważnianiem po tagach oraz kanał RSS 2.0 z `System.ServiceModel.Syndication`. Cały silnik mieści się w mniej niż 300 liniach C#. ## Minimal API czy generator stron statycznych Generatory takie jak Hugo czy Jekyll tworzą pliki HTML na etapie budowania. Są szybkie i tanie w utrzymaniu, ale każda funkcja wykraczająca poza szablony, na przykład publikacja zaplanowana na konkretny dzień, API w JSON dla aplikacji mobilnej, osobne kanały dla tagów czy integracja z analityką, zamienia się we wtyczkę pisaną w języku, z którym programista .NET nie pracuje na co dzień. Blog oparty na ASP.NET Core trzyma treść w zwykłych plikach Markdown w repozytorium Git, renderuje je przy pierwszym żądaniu, a potem serwuje wynik z pamięci. Z output cachingiem na froncie koszt pojedynczego żądania jest zbliżony do serwowania pliku statycznego, a cała logika to zwykły kod C#, który można debugować, testować i rozbudowywać. Taki projekt ma też wartość szkoleniową: dotyka wstrzykiwania zależności, potoku żądań, cache'owania i współbieżności, czyli dokładnie tych tematów, które pojawiają się na rozmowach rekrutacyjnych z .NET. | Kryterium | Generator stron statycznych | Blog na ASP.NET Core Minimal API | |---|---|---| | Format treści | Markdown + front matter | Markdown + front matter | | Moment renderowania | Podczas budowania | Pierwsze żądanie, potem cache | | Własna logika | Wtyczki, szablony | Zwykłe endpointy w C# | | Hosting | Dowolny hosting statyczny lub CDN | Kontener, App Service, dowolny VPS | | Aktualizacja treści | Przebudowa i ponowne wdrożenie | Obserwator plików przeładowuje magazyn | ## Przygotowanie projektu ASP.NET Core na .NET 10 Punktem wyjścia jest pusty szablon webowy. Polecenie `dotnet new web` tworzy projekt na SDK `Microsoft.NET.Sdk.Web`, które kompiluje komponenty `.razor` bez dodatkowej konfiguracji. Resztę pokrywają trzy pakiety: [Markdig](https://github.com/xoofx/markdig) do parsowania CommonMark, YamlDotNet do metadanych oraz `System.ServiceModel.Syndication` do kanału RSS. ```bash # terminal dotnet new web -n CSharpBlog --framework net10.0 cd CSharpBlog dotnet add package Markdig dotnet add package YamlDotNet dotnet add package System.ServiceModel.Syndication mkdir posts Posts Endpoints Components ``` Plik `Program.cs` spina wszystkie elementy. Magazyn wpisów jest rejestrowany jako singleton, ponieważ sparsowane wpisy są współdzielone przez wszystkie żądania. Middleware output cachingu znajduje się w potoku przed endpointami, dzięki czemu odpowiedź z cache'u w ogóle nie uruchamia handlera. ```csharp // Program.cs var builder = WebApplication.CreateBuilder(args); // Site settings bound from the "Blog" section of appsettings.json builder.Services.Configure(builder.Configuration.GetSection("Blog")); builder.Services.AddSingleton(); // one parsed snapshot shared by all requests builder.Services.AddRazorComponents(); // enables RazorComponentResult rendering builder.Services.AddOpenApi(); // OpenAPI 3.1 document for the JSON API builder.Services.AddOutputCache(options => options.AddBasePolicy(policy => policy.Expire(TimeSpan.FromHours(1)))); var app = builder.Build(); app.MapStaticAssets(); // CSS and images from wwwroot, fingerprinted since .NET 9 app.UseOutputCache(); // must run before the endpoints it caches app.MapOpenApi(); app.MapBlogEndpoints(); app.MapFeedEndpoints(); app.Run(); public sealed class BlogOptions { public string Title { get; set; } = "C# Notes"; public string SiteUrl { get; set; } = "https://localhost:5001/"; } ``` Ustawienie `SiteUrl` będzie istotne w dalszej części: adresy kanoniczne i linki w kanale RSS budowane są z konfiguracji, nigdy z nagłówka `Host` przychodzącego żądania. ## Parsowanie wpisów Markdown z front matter w C# Każdy wpis to osobny plik, na przykład `posts/output-caching-dotnet-10.md`. Nazwa pliku staje się slugiem, a blok YAML na początku pliku zawiera metadane: ```markdown --- title: Output caching in .NET 10 summary: How tag-based eviction keeps cached pages fresh. date: 2026-11-10 tags: [aspnet-core, performance] draft: false --- Output caching stores the full response on the server... ``` Parser oddziela blok YAML od treści, deserializuje metadane do małej klasy i konwertuje resztę pliku na HTML. Najpierw normalizowane są znaki końca linii. Bez tego wpis zapisany w edytorze na Windows (z `\r\n`) psuje wyszukiwanie ogranicznika `---`. ```csharp // Posts/PostParser.cs using Markdig; using YamlDotNet.Serialization; using YamlDotNet.Serialization.NamingConventions; public sealed record Post(string Slug, string Title, string Summary, DateTime PublishedOn, IReadOnlyList Tags, bool Draft, string Html); public static class PostParser { // Built once and reused by every reload private static readonly MarkdownPipeline Pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().Build(); private static readonly IDeserializer Yaml = new DeserializerBuilder() .WithNamingConvention(CamelCaseNamingConvention.Instance) .IgnoreUnmatchedProperties() // unknown keys do not crash the reload .Build(); public static Post Parse(string slug, string text) { text = text.ReplaceLineEndings("\n"); if (!text.StartsWith("---\n")) throw new FormatException($"{slug}: missing front matter"); var end = text.IndexOf("\n---", 4, StringComparison.Ordinal); if (end < 0) throw new FormatException($"{slug}: unterminated front matter"); var meta = Yaml.Deserialize(text[4..end]); var html = Markdown.ToHtml(text[(end + 4)..], Pipeline); return new Post(slug, meta.Title, meta.Summary, meta.Date, meta.Tags, meta.Draft, html); } private sealed class FrontMatter { public string Title { get; set; } = ""; public string Summary { get; set; } = ""; public DateTime Date { get; set; } public List Tags { get; set; } = []; public bool Draft { get; set; } } } ``` Wywołanie `UseAdvancedExtensions()` włącza tabele, przypisy, listy zadań, automatyczne identyfikatory nagłówków i pozostałe rozszerzenia Markdig, których potrzebuje blog techniczny. Warto pamiętać, że Markdig domyślnie przepuszcza surowy HTML. Przy wpisach pisanych przez właściciela serwisu nie stanowi to problemu, ale każdy Markdown pochodzący od użytkowników (komentarze, wpisy gościnne) wymaga w swoim potoku wywołania `DisableHtml()`, inaczej otwiera drogę do ataku stored XSS. Statyczne pola `Pipeline` i `Yaml` nie są przypadkowe. Budowa potoku Markdig i deserializatora YamlDotNet jest kosztowna, a oba obiekty są bezpieczne do współdzielenia między wątkami, więc tworzy się je raz na cały czas życia procesu. ## Magazyn wpisów: singleton bezpieczny wątkowo z przeładowaniem na gorąco Magazyn wczytuje wszystkie pliki przy starcie i trzyma wynik w `FrozenDictionary` (dostępnym od .NET 8), czyli kolekcji zoptymalizowanej pod intensywne odczyty. Gdy plik się zmieni, magazyn buduje od zera nowy słownik i podmienia referencję jednym przypisaniem. Czytelnicy nigdy nie zakładają blokady: każde żądanie widzi albo stary, albo nowy snapshot, nigdy kolekcję w połowie budowy. ```csharp // Posts/PostStore.cs using System.Collections.Frozen; using Microsoft.AspNetCore.OutputCaching; using Microsoft.Extensions.FileProviders; using Microsoft.Extensions.Primitives; public sealed class PostStore { private readonly PhysicalFileProvider _files; private readonly IOutputCacheStore _cache; private readonly ILogger _logger; private volatile FrozenDictionary _bySlug = FrozenDictionary.Empty; public PostStore(IWebHostEnvironment env, IOutputCacheStore cache, ILogger logger) { (_cache, _logger) = (cache, logger); _files = new PhysicalFileProvider(Path.Combine(env.ContentRootPath, "posts")); Reload(); ChangeToken.OnChange(() => _files.Watch("*.md"), Reload); // re-registers after each change } public Post? Find(string slug) => _bySlug.TryGetValue(slug, out var post) ? post : null; public IReadOnlyList Latest(int count) => _bySlug.Values.OrderByDescending(p => p.PublishedOn).Take(count).ToList(); private void Reload() { try { var snapshot = _files.GetDirectoryContents("") .Where(f => !f.IsDirectory && f.Name.EndsWith(".md", StringComparison.Ordinal)) .Select(f => PostParser.Parse(Path.GetFileNameWithoutExtension(f.Name), File.ReadAllText(f.PhysicalPath!))) .Where(p => !p.Draft) .ToFrozenDictionary(p => p.Slug); _bySlug = snapshot; // atomic reference swap _ = _cache.EvictByTagAsync("posts", CancellationToken.None).AsTask(); _logger.LogInformation("Loaded {Count} posts", snapshot.Count); } catch (Exception ex) { _logger.LogError(ex, "Reload failed, keeping the previous snapshot"); // a typo never takes the site down } } } ``` O tym, że ten kod nadaje się na produkcję, decydują trzy szczegóły: - Pole oznaczone jako `volatile` gwarantuje, że pozostałe wątki odczytają aktualną referencję po podmianie. - Blok `try/catch` zachowuje ostatni poprawny snapshot, gdy któryś wpis ma uszkodzony YAML. Literówka w jednym pliku nie opróżnia całego bloga. - Wywołanie `EvictByTagAsync` usuwa z cache'u wszystkie strony oznaczone tagiem `posts`, więc nowa treść pojawia się przy następnym żądaniu, a nie dopiero po godzinie, gdy wygaśnie polityka bazowa. Metoda `ChangeToken.OnChange` zasługuje na osobną uwagę. Token zmiany z `PhysicalFileProvider` jest jednorazowy: po pierwszym wywołaniu przestaje działać. `OnChange` przyjmuje fabrykę tokenów i po każdej zmianie rejestruje obserwację od nowa, co zwalnia programistę z ręcznego zarządzania subskrypcją. > **Obserwacja plików w kontenerach** > > `FileSystemWatcher` korzysta z powiadomień systemu operacyjnego, które nie przechodzą niezawodnie przez bind mounty Dockera ani udziały sieciowe. W kontenerze z zamontowanym katalogiem `posts` należy ustawić zmienną środowiskową `DOTNET_USE_POLLING_FILE_WATCHER=true` albo `PhysicalFileProvider.UsePollingFileWatcher = true`. Edytory zapisują też pliki w kilku krokach, przez co `Reload` potrafi uruchomić się dwa lub trzy razy na jeden zapis. Tutaj nie ma to znaczenia, bo każde uruchomienie daje identyczny snapshot. ## Endpointy Minimal API z grupami tras i TypedResults Publiczne strony są zgrupowane pod `/blog` za pomocą `MapGroup`. Grupa pozwala w jednym miejscu nałożyć politykę output cachingu i tag na wszystkie endpointy. Handlery zwracają `RazorComponentResult` (dostępny od .NET 8), który renderuje komponent Razor jako pełną odpowiedź HTTP bez MVC, Razor Pages i bez routera Blazora. ```csharp // Endpoints/BlogEndpoints.cs using CSharpBlog.Components; // namespace of PostPage and PostListPage using Microsoft.AspNetCore.Http.HttpResults; public static class BlogEndpoints { public static IEndpointRouteBuilder MapBlogEndpoints(this IEndpointRouteBuilder app) { var blog = app.MapGroup("/blog").CacheOutput(p => p.Tag("posts")); blog.MapGet("/", (PostStore store) => new RazorComponentResult(new { Posts = store.Latest(20) })); blog.MapGet("/{slug:regex(^[a-z0-9-]+$)}", GetPost); // rejects odd slugs before the handler app.MapGet("/api/posts", (PostStore store) => TypedResults.Ok(store.Latest(50).Select(p => new PostSummary(p.Slug, p.Title, p.Summary, p.PublishedOn)))) .CacheOutput(p => p.Tag("posts")) .WithName("ListPosts"); return app; } // The union return type documents both outcomes for OpenAPI and for unit tests private static Results, NotFound> GetPost(string slug, PostStore store) => store.Find(slug) is { } post ? new RazorComponentResult(new { Post = post }) : TypedResults.NotFound(); } public sealed record PostSummary(string Slug, string Title, string Summary, DateTime PublishedOn); ``` Typ zwracany `Results` to właśnie to, co odróżnia `TypedResults` od starszych helperów `Results`. Kompilator pilnuje, by handler zwracał wyłącznie zadeklarowane wyniki, generator OpenAPI odczytuje oba kody statusu wprost z sygnatury, a test jednostkowy może sprawdzić `result.Result is NotFound` bez uruchamiania serwera. Endpoint JSON pozostaje poza grupą `/blog`, żeby jego adres nie kolidował ze slugami wpisów. Ograniczenie `regex(^[a-z0-9-]+$)` w szablonie trasy odrzuca nietypowe slugi, zanim żądanie dotrze do handlera. Zapytania o adresy z kropkami, ukośnikami czy wielkimi literami kończą się błędem 404 już na etapie routingu. Strona wpisu to zwykły komponent Razor. `MarkupString` informuje Razor, że wynik z Markdig ma zostać wyemitowany jako HTML, a nie zakodowany, a adres kanoniczny pochodzi z `BlogOptions`. ```razor @* Components/PostPage.razor *@ @using Microsoft.Extensions.Options @inject IOptions Options @Post.Title | @Options.Value.Title

@Post.Title

@((MarkupString)Post.Html)
@code { [Parameter, EditorRequired] public Post Post { get; set; } = default!; } ``` Plik `PostListPage.razor` działa na tej samej zasadzie: przyjmuje parametr `Posts` i w pętli wyświetla tytuły oraz streszczenia. Obiekt anonimowy przekazany do `RazorComponentResult` mapuje nazwy swoich właściwości na parametry komponentu, dlatego `new { Post = post }` musi dokładnie odpowiadać parametrowi `Post`. Literówka w nazwie nie zostanie wykryta przy kompilacji, tylko w czasie działania. ## Output caching dla stron bloga w ASP.NET Core Output caching, dodany w ASP.NET Core 7, przechowuje całą odpowiedź po stronie serwera i odtwarza ją bez uruchamiania handlera i ponownego renderowania komponentu. To mechanizm inny niż starszy middleware response caching, który działa według semantyki nagłówka HTTP `Cache-Control` i pozwala klientowi ominąć cache nagłówkiem `no-cache`. [Dokumentacja output cachingu na Microsoft Learn](https://learn.microsoft.com/en-us/aspnet/core/performance/caching/output) opisuje domyślne reguły: cache'owane są tylko żądania `GET` i `HEAD` zakończone kodem 200, a odpowiedzi ustawiające ciasteczka lub dotyczące uwierzytelnionych żądań są pomijane. To tagi sprawiają, że output caching pasuje do serwisu z treścią. Każdy endpoint bloga ma tag `posts`, a magazyn unieważnia ten tag po każdym przeładowaniu. Godzinna polityka bazowa to tylko zabezpieczenie: w praktyce strony pozostają w cache'u aż do zmiany treści. Przy wdrożeniu na kilka instancji domyślny magazyn w pamięci jest lokalny dla procesu, więc unieważnienie na jednej instancji zostawia nieaktualne strony na pozostałych. ASP.NET Core oferuje magazyn oparty na Redisie w pakiecie `Microsoft.AspNetCore.OutputCaching.StackExchangeRedis` z metodą `AddStackExchangeRedisOutputCache`, który współdzieli wpisy i unieważnienia między instancjami. Dla jednej niewielkiej instancji nie jest potrzebny. ## Kanał RSS w C# z SyndicationFeed Czytelnicy techniczni wciąż subskrybują blogi w czytnikach kanałów, a agregatory wyłapują nowe wpisy z RSS, nie z mapy strony. `SyndicationFeed` razem z `Rss20FeedFormatter` generuje kanał zgodny ze [specyfikacją RSS 2.0](https://www.rssboard.org/rss-specification) bez ręcznego pisania XML. ```csharp // Endpoints/FeedEndpoints.cs using System.ServiceModel.Syndication; using System.Text; using System.Xml; using Microsoft.Extensions.Options; public static class FeedEndpoints { public static IEndpointRouteBuilder MapFeedEndpoints(this IEndpointRouteBuilder app) { app.MapGet("/feed.xml", (PostStore store, IOptions options) => { var site = new Uri(options.Value.SiteUrl); // never built from the Host header var items = store.Latest(20).Select(p => { var date = new DateTimeOffset(DateTime.SpecifyKind(p.PublishedOn, DateTimeKind.Utc)); return new SyndicationItem(p.Title, p.Summary, new Uri(site, $"blog/{p.Slug}"), p.Slug, date) { PublishDate = date // RSS pubDate comes from PublishDate, not LastUpdatedTime }; }); var feed = new SyndicationFeed(options.Value.Title, "Articles on C# and .NET", site, items); using var buffer = new MemoryStream(); using (var writer = XmlWriter.Create(buffer, new XmlWriterSettings { Encoding = new UTF8Encoding(false) })) new Rss20FeedFormatter(feed).WriteTo(writer); // writer flushes on dispose return TypedResults.Bytes(buffer.ToArray(), "application/rss+xml; charset=utf-8"); }).CacheOutput(p => p.Tag("posts")); return app; } } ``` Budowanie adresów bezwzględnych z `BlogOptions.SiteUrl` zamiast z `HttpContext.Request.Host` zamyka podatność typu host header injection. Bez tego jedno żądanie ze sfałszowanym nagłówkiem `Host` trafiłoby do cache'u i każdy subskrybent dostawałby linki prowadzące do obcej domeny. Argument `UTF8Encoding(false)` usuwa znacznik BOM, którego niektóre czytniki nie akceptują. Warto też zwrócić uwagę na `PublishDate`: element `pubDate` w RSS pochodzi właśnie z tej właściwości, a nie z `LastUpdatedTime` przekazanego w konstruktorze. ## Wdrożenie bloga technicznego w C# i ograniczenia Native AOT Polecenie `dotnet publish -c Release` tworzy build zależny od frameworka, który działa na każdym hoście z runtime'em .NET 10. Od .NET 8 SDK potrafi też budować obrazy kontenerów bez pliku Dockerfile: `dotnet publish -c Release /t:PublishContainer` tworzy obraz na bazie oficjalnego obrazu runtime'u ASP.NET Core. Katalog `posts` można wbudować w obraz (wtedy każda zmiana treści wymaga ponownego wdrożenia) albo zamontować jako wolumen (wtedy zmiany wyłapuje obserwator plików). Native AOT kusi krótszym czasem startu i mniejszym zużyciem pamięci, ale ten projekt nie jest dobrym kandydatem. [Tabela zgodności Native AOT w ASP.NET Core](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/native-aot) oznacza Minimal APIs jako wspierane częściowo, a Blazor Server jako niewspierany. Domyślny deserializator YamlDotNet opiera się ponadto na refleksji. Blog serwuje strony z cache'u w długo działającym procesie, więc czas startu ma marginalne znaczenie. Przejście na AOT oznaczałoby zastąpienie komponentów Razor szablonami tekstowymi, a YAML front matterem w JSON z generatorem źródeł, przy niewielkim zysku. ## Pytania rekrutacyjne z .NET, do których przygotowuje ten projekt Każdy element silnika odpowiada pytaniu, które pada na rozmowach o pracę z ASP.NET Core. [Pytania rekrutacyjne z .NET na SharpSkill](https://sharpskill.dev/pl/technologies/dotnet) omawiają je szczegółowo, a [moduł o Minimal APIs](https://sharpskill.dev/pl/technologies/dotnet/pytania-rekrutacyjne/minimal-apis) skupia się na warstwie endpointów. **„Czy serwis singleton jest bezpieczny, gdy czyta go wiele żądań jednocześnie?”** Tylko wtedy, gdy jego stan jest niemutowalny albo synchronizowany. Opisany magazyn używa niemutowalnego snapshotu i podmiany referencji `volatile`, więc czytelnicy nie blokują się nawzajem, a zapis nie blokuje odczytów. Klasyczna pułapka to singleton z `List` modyfikowaną podczas przeładowania, który pod obciążeniem rzuca `InvalidOperationException` w trakcie enumeracji. [Moduł o wstrzykiwaniu zależności](https://sharpskill.dev/pl/technologies/dotnet/pytania-rekrutacyjne/dependency-injection) omawia też problem captive dependency: singleton, który otrzymuje serwis o zasięgu scoped, na przykład `DbContext`, utrzymuje go przy życiu przez cały czas działania aplikacji. **„Czym różni się output caching od response cachingu?”** Output caching jest kontrolowany przez serwer, obsługuje tagi i unieważnianie, ignoruje nagłówki cache'u wysyłane przez klienta. Response caching podąża za semantyką HTTP i jest przede wszystkim wskazówką dla proxy i przeglądarek. **„Dlaczego zwracać `TypedResults` zamiast `Results`?”** Konkretne typy wyników dają sprawdzanie możliwych odpowiedzi w czasie kompilacji, automatyczne metadane OpenAPI i handlery, które da się testować jak zwykłe metody. Szersze porównanie z kontrolerami zawiera artykuł o [architekturze i wydajności Minimal APIs](https://sharpskill.dev/pl/blog/dotnet/aspnet-core-minimal-apis-architecture-performance-interview). **„Gdzie w tej aplikacji ma znaczenie kolejność middleware?”** `UseOutputCache` musi być zarejestrowany przed endpointami, które cache'uje, oraz po `UseCors`, jeśli CORS jest włączony. Kandydat, który potrafi też wyjaśnić, dlaczego domyślna polityka nigdy nie cache'uje żądań uwierzytelnionych i co musi sprawdzić własna implementacja `IOutputCachePolicy`, zanim zacznie je cache'ować, pokazuje zrozumienie potoku, a nie wyuczoną na pamięć kolejność. ## Blog w C# na ASP.NET Core: najważniejsze wnioski - Projekt startuje od `dotnet new web` na .NET 10 i potrzebuje jedynie Markdig, YamlDotNet oraz `System.ServiceModel.Syndication`. Blog techniczny obywa się bez CMS i bez bazy danych. - Wpisy parsuje się raz do niemutowalnego `FrozenDictionary` i przy przeładowaniu podmienia cały snapshot, więc odczyty nie wymagają blokad, a uszkodzony plik nie opróżnia serwisu. - HTML renderuje się przez `RazorComponentResult` z handlerów Minimal API, a typy zwracane `Results` pozwalają OpenAPI i testom jednostkowym widzieć każdy możliwy wynik. - Wszystkie endpointy z treścią działają za output cachingiem ze wspólnym tagiem, a `EvictByTagAsync` po każdym przeładowaniu zastępuje krótkie czasy wygasania. - Adresy kanoniczne i linki w RSS buduje się z konfiguracji, nigdy z nagłówka `Host`. Każdy potok renderujący Markdown od użytkowników wymaga `DisableHtml()`. - Gdy katalog z wpisami jest montowany do kontenera, potrzebna jest zmienna `DOTNET_USE_POLLING_FILE_WATCHER=true`. - Projekt sprawdza się jako trening przed rozmową rekrutacyjną: warto umieć na głos wyjaśnić bezpieczeństwo wątkowe singletona, wybór mechanizmu cache'owania i kolejność middleware. --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/pl/blog/dotnet/csharp-blog-aspnet-core-minimal-apis-2026