# Een C#-blog bouwen in 2026: technisch bloggen met ASP.NET Core en Minimal APIs > Een C#-blog op .NET 10 met ASP.NET Core Minimal APIs: Markdown-artikelen met front matter, een thread-safe store met hot reload, Razor-componenten, output caching en een RSS-feed. - Published: 2026-11-17 - Updated: 2026-11-17 - Author: Anthony Fillion-Maillet - Tags: dotnet, csharp, aspnet-core, minimal-apis, output-caching, tutorial - Reading time: 14 min --- Een C#-blog op basis van ASP.NET Core Minimal APIs past in een handvol bestanden: Markdown-artikelen op schijf, een singleton-store die ze één keer inleest, een paar endpoints die HTML teruggeven en een RSS-feed. Op .NET 10, de long-term-supportversie die in november 2025 verscheen, zit vrijwel elk onderdeel van die stack in het framework zelf. De rest komt uit drie goed onderhouden NuGet-pakketten. Een CMS of database is niet nodig. > **De stack in één alinea** > > Een leeg .NET 10-webproject, Markdig voor de omzetting van Markdown naar HTML, YamlDotNet voor de front matter, een onveranderlijke in-memory store die herlaadt zodra een bestand wijzigt, Minimal API-endpoints die `RazorComponentResult`-pagina's teruggeven, output caching met invalidatie per tag en een RSS 2.0-feed via `System.ServiceModel.Syndication`. De volledige engine blijft onder de 300 regels C#. ## Waarom een blogengine met Minimal APIs en geen static site generator Static site generators zoals Hugo en Jekyll genereren HTML-bestanden tijdens de build. Dat is snel en goedkoop te hosten, maar zodra er gedrag nodig is dat verder gaat dan templates (ingeplande publicaties, een JSON-API voor een mobiele app, feeds per tag, koppelingen met analytics), belandt die logica in plugins in een taal waarin een .NET-ontwikkelaar niet dagelijks werkt. Een ASP.NET Core-blog bewaart de inhoud als gewone Markdown-bestanden in Git, rendert ze bij de eerste aanvraag en levert het resultaat daarna uit het geheugen. Met output caching ervoor ligt de kostprijs per aanvraag dicht bij die van een statisch bestand, en de code die draait is gewoon C# die zich laat debuggen, testen en uitbreiden. Bovendien is het een compact project dat dependency injection, de request-pipeline, caching en concurrency raakt: precies de onderwerpen die in een technisch .NET-sollicitatiegesprek aan bod komen. | Aspect | Static site generator | Blog met ASP.NET Core Minimal APIs | |---|---|---| | Contentformaat | Markdown + front matter | Markdown + front matter | | Moment van renderen | Tijdens de build | Bij de eerste aanvraag, daarna gecachet | | Eigen logica | Plugins, templates | Gewone C#-endpoints | | Hosting | Elke statische host of CDN | Container, App Service, elke VPS | | Content live bijwerken | Opnieuw bouwen en deployen | Een file watcher herlaadt de store | ## Het ASP.NET Core-blogproject opzetten op .NET 10 Het vertrekpunt is de lege webtemplate. `dotnet new web` maakt een project aan op de `Microsoft.NET.Sdk.Web`-SDK, die `.razor`-componenten zonder extra configuratie compileert. Drie pakketten dekken de rest af: [Markdig](https://github.com/xoofx/markdig) voor CommonMark-parsing, YamlDotNet voor de front matter en `System.ServiceModel.Syndication` voor de feed. ```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 ``` In `Program.cs` komt alles samen. De post-store is een singleton omdat de geparste artikelen door alle aanvragen gedeeld worden, en output caching staat in de pipeline vóór de endpoints, zodat gecachete antwoorden de handler helemaal overslaan. ```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/"; } ``` De instelling `SiteUrl` wordt verderop belangrijk: canonieke links en feed-URL's worden opgebouwd uit de configuratie, nooit uit de binnenkomende `Host`-header. ## Markdown-artikelen met front matter parsen in C# Elk artikel is een bestand zoals `posts/output-caching-dotnet-10.md`. De bestandsnaam wordt de slug, en een YAML-blok bovenaan bevat de metadata: ```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... ``` De parser scheidt het YAML-blok van de tekst, deserialiseert de metadata naar een kleine klasse en zet de body om naar HTML. Eerst worden de regeleinden genormaliseerd; anders breekt een artikel dat onder Windows is opgeslagen de zoektocht naar het scheidingsteken `---`. ```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; } } } ``` `UseAdvancedExtensions()` schakelt tabellen, voetnoten, takenlijsten, automatische id's op koppen en de andere Markdig-extensies in die een technische blog nodig heeft. Standaard laat Markdig ruwe HTML ongewijzigd door. Voor artikelen van de site-eigenaar is dat aanvaardbaar, maar elke Markdown die van gebruikers komt (reacties, gastartikelen) heeft `DisableHtml()` op de eigen pipeline nodig om stored XSS te voorkomen. ## Een thread-safe singleton-store met hot reload De store leest bij het opstarten alle bestanden in en bewaart het resultaat in een `FrozenDictionary` (beschikbaar sinds .NET 8), dat geoptimaliseerd is voor veelvuldige leesacties. Wanneer een bestand wijzigt, bouwt de store een volledig nieuwe dictionary op en vervangt de referentie in één toewijzing. Lezers nemen nooit een lock: elke aanvraag ziet de oude snapshot of de nieuwe, nooit een half opgebouwde collectie. ```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 } } } ``` Drie details maken deze code geschikt voor productie. Het `volatile`-veld garandeert dat andere threads na de wissel de nieuwste referentie lezen. Het `try/catch`-blok behoudt de laatste geldige snapshot wanneer een artikel ongeldige YAML bevat, zodat een tikfout in één bestand de blog niet leegmaakt. En de aanroep van `EvictByTagAsync` verwijdert elke gecachete pagina met de tag `posts`, waardoor nieuwe inhoud al bij de volgende aanvraag verschijnt in plaats van na het verlopen van het uur. > **Bestanden bewaken in containers** > > `FileSystemWatcher` steunt op meldingen van het besturingssysteem, die Docker-bind-mounts en netwerkshares niet betrouwbaar passeren. In een container die de map `posts` mount, hoort de omgevingsvariabele `DOTNET_USE_POLLING_FILE_WATCHER=true` of `PhysicalFileProvider.UsePollingFileWatcher = true` gezet te worden. Editors slaan een bestand bovendien vaak in meerdere schrijfacties op, waardoor `Reload` twee of drie keer per opslag kan afgaan. Hier is dat onschuldig, want elke run levert dezelfde snapshot op. ## Minimal API-endpoints met route groups en TypedResults De publieke pagina's worden met `MapGroup` gegroepeerd onder `/blog`, zodat de output-cachepolicy en de bijbehorende tag op één plek voor alle endpoints gelden. Handlers geven `RazorComponentResult` terug, beschikbaar sinds .NET 8, dat een Razor-component als volledig HTTP-antwoord rendert zonder MVC, Razor Pages of een Blazor-router. ```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); ``` Het returntype `Results` is wat `TypedResults` onderscheidt van de oudere `Results`-helpers. De compiler controleert dat de handler alleen de gedeclareerde uitkomsten teruggeeft, de OpenAPI-generator leest beide statuscodes uit de signatuur, en een unittest kan `result.Result is NotFound` controleren zonder een server op te starten. Het JSON-endpoint blijft buiten de groep `/blog`, zodat de URL nooit botst met een artikelslug. De artikelpagina is een gewone Razor-component. `MarkupString` vertelt Razor dat de uitvoer van Markdig als HTML moet worden uitgegeven in plaats van gecodeerd, en de canonieke URL komt uit `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!; } ``` `PostListPage.razor` volgt hetzelfde patroon met een parameter `Posts` en een lus over titels en samenvattingen. Het anonieme object dat aan `RazorComponentResult` wordt meegegeven, koppelt zijn propertynamen aan componentparameters. `new { Post = post }` moet dus exact overeenkomen met de parameter `Post`; een tikfout komt pas tijdens runtime aan het licht. ## Output caching voor de pagina's van de ASP.NET Core-blog Output caching, geïntroduceerd in ASP.NET Core 7, slaat het volledige antwoord op de server op en speelt het opnieuw af zonder de handler uit te voeren of de component opnieuw te renderen. Daarin verschilt het van de oudere response-caching-middleware, die de HTTP-semantiek van `Cache-Control` volgt en een client toestaat de cache te omzeilen met een `no-cache`-header. De [documentatie over output caching op Microsoft Learn](https://learn.microsoft.com/nl-nl/aspnet/core/performance/caching/output) beschrijft de standaardregels: alleen `GET`- en `HEAD`-aanvragen met status 200 worden gecachet, en antwoorden die cookies zetten of uit geauthenticeerde aanvragen komen, worden overgeslagen. Tags maken output caching pas echt geschikt voor een contentsite. Elk blog-endpoint draagt de tag `posts`, en de store invalideert die tag na elke herlaadbeurt. De basispolicy van een uur is slechts een vangnet: in de praktijk blijven pagina's gecachet tot de inhoud daadwerkelijk verandert. Bij een deployment met meerdere instanties is de in-memory store per proces: invalidatie op de ene instantie laat de andere met verouderde pagina's achter. ASP.NET Core biedt een store op basis van Redis via het pakket `Microsoft.AspNetCore.OutputCaching.StackExchangeRedis` en `AddStackExchangeRedisOutputCache`, die cache-items en invalidaties over alle instanties deelt. Eén kleine instantie heeft dat niet nodig. ## Een RSS-feed genereren in C# met SyndicationFeed Technische lezers volgen blogs nog steeds via feedreaders, en aggregators pikken nieuwe artikelen eerder op uit de feed dan uit de sitemap. `SyndicationFeed` en `Rss20FeedFormatter` leveren een feed volgens de [RSS 2.0-specificatie](https://www.rssboard.org/rss-specification) zonder dat er handmatig XML geschreven hoeft te worden. ```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; } } ``` Absolute URL's opbouwen uit `BlogOptions.SiteUrl` in plaats van uit `HttpContext.Request.Host` sluit een host-header-injectie uit: anders zou één aanvraag met een vervalste `Host`-waarde gecachet worden en aan elke abonnee geserveerd worden met links naar een ander domein. Het argument `UTF8Encoding(false)` verwijdert de byte order mark, die sommige feedreaders weigeren. ## De C#-techblog deployen en de grenzen van Native AOT `dotnet publish -c Release` levert een framework-afhankelijke build op die draait op elke host met de .NET 10-runtime. Sinds .NET 8 bouwt de SDK ook containerimages zonder Dockerfile: `dotnet publish -c Release /t:PublishContainer` maakt een image op basis van de officiële ASP.NET Core-runtime-image. De map `posts` kan in de image worden meegebakken (contentwijzigingen vereisen dan een nieuwe deploy) of als volume worden gemount (wijzigingen worden dan door de file watcher opgepikt). Native AOT is aantrekkelijk vanwege opstarttijd en geheugengebruik, maar dit project is geen goede kandidaat. De [compatibiliteitstabel van Native AOT voor ASP.NET Core](https://learn.microsoft.com/nl-nl/aspnet/core/fundamentals/native-aot) vermeldt Minimal APIs als gedeeltelijk ondersteund en Blazor Server als niet ondersteund, en de standaard-deserializer van YamlDotNet leunt op reflection. Een blog serveert gecachete pagina's vanuit een langlopend proces, dus de opstarttijd doet er nauwelijks toe. Overstappen op AOT zou betekenen dat Razor-componenten plaatsmaken voor string-templates en YAML voor een JSON-front matter met source generation, voor weinig winst. ## Welke .NET-sollicitatievragen dit blogproject voorbereidt Elk onderdeel van de engine sluit aan bij een vraag die in ASP.NET Core-gesprekken terugkomt. De [.NET-sollicitatievragen op SharpSkill](https://sharpskill.dev/nl/technologies/dotnet) behandelen ze uitgebreid, en de [module over Minimal APIs](https://sharpskill.dev/nl/technologies/dotnet/sollicitatievragen/minimal-apis) richt zich op de kant van de endpoints. **'Is een singleton-service veilig als veel aanvragen hem tegelijk lezen?'** Alleen als de toestand onveranderlijk of gesynchroniseerd is. De store hierboven gebruikt een onveranderlijke snapshot en een `volatile`-referentiewissel, zodat lezers nooit locken en schrijvers lezers nooit blokkeren. De klassieke valkuil is een singleton met een `List` die tijdens het herladen wordt aangepast en onder belasting midden in een enumeratie een `InvalidOperationException` gooit. De [module over dependency injection](https://sharpskill.dev/nl/technologies/dotnet/sollicitatievragen/dependency-injection) behandelt ook het captive-dependency-probleem: een singleton die een scoped service ontvangt, zoals een `DbContext`, houdt die in leven zolang de applicatie draait. **'Wat is het verschil tussen output caching en response caching?'** Output caching wordt door de server aangestuurd, ondersteunt tags en invalidatie en negeert cacheheaders van de client. Response caching volgt de HTTP-semantiek en is vooral een hint voor proxy's en browsers. **'Waarom `TypedResults` teruggeven in plaats van `Results`?'** Concrete resultaattypen bieden controle van de mogelijke uitkomsten tijdens het compileren, automatische OpenAPI-metadata en handlers die als gewone methoden te testen zijn. De uitgebreide vergelijking met controllers staat in het artikel over [architectuur en performance van Minimal APIs](https://sharpskill.dev/nl/blog/dotnet/aspnet-core-minimal-apis-architecture-performance-interview). **'Waar doet de volgorde van middleware ertoe in deze app?'** `UseOutputCache` moet vóór de endpoints worden geregistreerd die het cachet, en na `UseCors` wanneer CORS actief is. Een kandidaat die daarnaast kan uitleggen waarom de standaardpolicy geauthenticeerde aanvragen nooit cachet, en wat een eigen `IOutputCachePolicy` moet controleren voordat het dat wel doet, toont inzicht in de pipeline in plaats van een uit het hoofd geleerde volgorde. ## Een C#-blog bouwen met ASP.NET Core: de kernpunten - Begin met `dotnet new web` op .NET 10 en voeg alleen Markdig, YamlDotNet en `System.ServiceModel.Syndication` toe; een technische blog heeft geen CMS of database nodig. - Lees artikelen één keer in een onveranderlijke `FrozenDictionary` en vervang bij herladen de hele snapshot, zodat lezers nooit locken en een kapot bestand de site nooit leegmaakt. - Render HTML met `RazorComponentResult` vanuit Minimal API-handlers en declareer returntypen als `Results`, zodat OpenAPI en unittests elke uitkomst kennen. - Zet elk content-endpoint achter output caching met een gedeelde tag en roep `EvictByTagAsync` aan na elke herlaadbeurt, in plaats van te vertrouwen op korte vervaltijden. - Bouw canonieke URL's en feed-URL's op uit de configuratie, nooit uit de `Host`-header, en schakel `DisableHtml()` in op elke pipeline die Markdown van gebruikers rendert. - Zet `DOTNET_USE_POLLING_FILE_WATCHER=true` wanneer de map met artikelen in een container wordt gemount. - Gebruik het project als oefening voor sollicitatiegesprekken: de thread safety van de singleton, de keuze voor de cache en de volgorde van de middleware moeten hardop uit te leggen zijn. --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/nl/blog/dotnet/csharp-blog-aspnet-core-minimal-apis-2026