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.

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.
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 voor CommonMark-parsing, YamlDotNet voor de front matter en System.ServiceModel.Syndication voor de feed.
# 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 ComponentsIn 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.
var builder = WebApplication.CreateBuilder(args);
// Site settings bound from the "Blog" section of appsettings.json
builder.Services.Configure<BlogOptions>(builder.Configuration.GetSection("Blog"));
builder.Services.AddSingleton<PostStore>(); // 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:
---
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 ---.
using Markdig;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;
public sealed record Post(string Slug, string Title, string Summary,
DateTime PublishedOn, IReadOnlyList<string> 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<FrontMatter>(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<string> 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.
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<PostStore> _logger;
private volatile FrozenDictionary<string, Post> _bySlug = FrozenDictionary<string, Post>.Empty;
public PostStore(IWebHostEnvironment env, IOutputCacheStore cache, ILogger<PostStore> 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<Post> 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.
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<T> terug, beschikbaar sinds .NET 8, dat een Razor-component als volledig HTTP-antwoord rendert zonder MVC, Razor Pages of een Blazor-router.
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<PostListPage>(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<RazorComponentResult<PostPage>, NotFound> GetPost(string slug, PostStore store) =>
store.Find(slug) is { } post
? new RazorComponentResult<PostPage>(new { Post = post })
: TypedResults.NotFound();
}
public sealed record PostSummary(string Slug, string Title, string Summary, DateTime PublishedOn);Het returntype Results<T1, T2> 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.
@* Components/PostPage.razor *@
@using Microsoft.Extensions.Options
@inject IOptions<BlogOptions> Options
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<title>@Post.Title | @Options.Value.Title</title>
<meta name="description" content="@Post.Summary" />
<link rel="canonical" href="@(new Uri(new Uri(Options.Value.SiteUrl), $"blog/{Post.Slug}"))" />
<link rel="alternate" type="application/rss+xml" title="@Options.Value.Title" href="/feed.xml" />
<link rel="stylesheet" href="/site.css" />
</head>
<body>
<article>
<h1>@Post.Title</h1>
<time datetime="@(Post.PublishedOn.ToString("yyyy-MM-dd"))">@(Post.PublishedOn.ToString("d MMMM yyyy"))</time>
@((MarkupString)Post.Html)
</article>
</body>
</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.
Klaar om je .NET gesprekken te halen?
Oefen met onze interactieve simulatoren, flashcards en technische tests.
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 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 zonder dat er handmatig XML geschreven hoeft te worden.
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<BlogOptions> 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 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 behandelen ze uitgebreid, en de module over 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<T> die tijdens het herladen wordt aangepast en onder belasting midden in een enumeratie een InvalidOperationException gooit. De module over 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.
'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 webop .NET 10 en voeg alleen Markdig, YamlDotNet enSystem.ServiceModel.Syndicationtoe; een technische blog heeft geen CMS of database nodig. - Lees artikelen één keer in een onveranderlijke
FrozenDictionaryen vervang bij herladen de hele snapshot, zodat lezers nooit locken en een kapot bestand de site nooit leegmaakt. - Render HTML met
RazorComponentResult<T>vanuit Minimal API-handlers en declareer returntypen alsResults<T1, T2>, zodat OpenAPI en unittests elke uitkomst kennen. - Zet elk content-endpoint achter output caching met een gedeelde tag en roep
EvictByTagAsyncaan 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 schakelDisableHtml()in op elke pipeline die Markdown van gebruikers rendert. - Zet
DOTNET_USE_POLLING_FILE_WATCHER=truewanneer 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.
Begin met oefenen!
Test je kennis met onze gespreksimulatoren en technische tests.
Zie jij de bug in .NET?
Een echt codefragment, een verborgen bug, één poging per dag. Zonder account uit te proberen.

Geschreven door
Anthony Fillion-MailletOprichter van SharpSkill
Al meer dan 10 jaar fullstack-ontwikkelaar. Hij leidt SharpSkill en staat in voor alles wat hier verschijnt.
Bijgewerkt op 17 november 2026
Tags
Delen
Gerelateerde artikelen

.NET 10 in 2026: Nieuwe Features, Native AOT en C# 14 voor Sollicitatiepreparatie
.NET 10 verschijnt als Long-Term Support release met Native AOT-verbeteringen, C# 14 extension members, de field keyword en file-based apps. Een complete gids over nieuwe features, prestatiewinst en interview-ready kennis voor .NET-ontwikkelaars in 2026.

DbContext Levensduur in ASP.NET Core: Performance versus Thread Safety bij Async Operaties
DbContext levensduur optimaal beheren in ASP.NET Core: Scoped versus Transient, thread safety bij async operaties en performance-optimalisatie met DbContext pooling.

Clean Code Architecture C#: Complete Gids en Sollicitatievragen 2026
Uitgebreide gids over Clean Code Architecture in C# met SOLID-principes, gelaagde architectuur en de meest voorkomende technische sollicitatievragen voor .NET-ontwikkelaars.