# Membangun Blog C# di 2026: Blog Teknis dengan ASP.NET Core dan Minimal APIs > Panduan membangun blog C# di .NET 10 dengan ASP.NET Core Minimal APIs: artikel Markdown dengan front matter, post store thread-safe dengan hot reload, halaman komponen Razor, output caching, dan feed 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 --- Membangun blog C# di 2026 tidak lagi membutuhkan CMS, panel admin, atau database. Dengan ASP.NET Core Minimal APIs di .NET 10, rilis LTS yang terbit pada November 2025, sebuah blog teknis cukup terdiri dari folder berisi file Markdown, satu layanan singleton yang mem-parsing semua artikel ke memori, beberapa endpoint yang merender HTML, dan sebuah feed RSS. Seluruh mesinnya muat dalam kurang dari 300 baris kode C#. > **Ringkasan arsitektur** > > Proyek web .NET 10 kosong, Markdig untuk mengubah Markdown menjadi HTML, YamlDotNet untuk front matter, penyimpanan artikel immutable di memori yang dimuat ulang saat file berubah, endpoint Minimal API yang mengembalikan halaman `RazorComponentResult`, output caching dengan eviction berbasis tag, serta feed RSS 2.0 dari `System.ServiceModel.Syndication`. ## Mengapa memilih ASP.NET Core dibanding static site generator Hugo, Jekyll, atau Astro menghasilkan file HTML pada saat build. Pendekatan ini cepat dan murah, tetapi setiap kebutuhan di luar templat, misalnya artikel terjadwal, API JSON untuk aplikasi mobile, feed per tag, atau integrasi analitik, berubah menjadi plugin yang ditulis dalam bahasa yang jarang dipakai oleh developer .NET sehari-hari. Blog berbasis ASP.NET Core tetap menyimpan konten sebagai file Markdown biasa di Git. Bedanya, konten dirender pada permintaan pertama lalu disajikan dari memori. Dengan output caching di depannya, biaya per request hampir setara dengan menyajikan file statis, sementara logika yang berjalan adalah kode C# biasa yang bisa di-debug, diuji, dan dikembangkan. Bonusnya, proyek kecil ini menyentuh dependency injection, pipeline request, caching, dan konkurensi: empat topik yang hampir selalu muncul dalam wawancara teknis .NET. | Aspek | Static site generator | Blog Minimal API ASP.NET Core | |---|---|---| | Format konten | Markdown + front matter | Markdown + front matter | | Waktu render | Saat build | Request pertama, lalu di-cache | | Logika khusus | Plugin, templat | Endpoint C# biasa | | Hosting | Host statis atau CDN | Container, App Service, VPS | | Pembaruan konten | Build ulang dan deploy ulang | File watcher memuat ulang store | ## Menyiapkan proyek blog ASP.NET Core di .NET 10 Titik awalnya adalah templat web kosong. Perintah `dotnet new web` membuat proyek berbasis SDK `Microsoft.NET.Sdk.Web`, yang sudah mampu mengompilasi komponen `.razor` tanpa konfigurasi tambahan. Tiga paket NuGet melengkapi sisanya: [Markdig](https://github.com/xoofx/markdig) untuk parsing CommonMark, YamlDotNet untuk front matter, dan `System.ServiceModel.Syndication` untuk 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 ``` Seluruh komponen dirangkai di `Program.cs`. Post store didaftarkan sebagai singleton karena hasil parsing dibagikan ke semua request. Middleware output caching ditempatkan sebelum endpoint, sehingga respons yang sudah tersimpan langsung dikirim tanpa menjalankan handler sama sekali. ```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/"; } ``` Pengaturan `SiteUrl` akan berperan penting di bagian selanjutnya: URL canonical dan URL feed selalu dibangun dari konfigurasi, bukan dari header `Host` yang dikirim klien. ## Parsing artikel Markdown dengan front matter di C# Setiap artikel adalah satu file, contohnya `posts/output-caching-dotnet-10.md`. Nama file menjadi slug, dan blok YAML di bagian atas berisi metadata artikel: ```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 memisahkan blok YAML dari isi artikel, melakukan deserialisasi metadata ke sebuah kelas kecil, lalu mengubah isi artikel menjadi HTML. Akhir baris dinormalisasi terlebih dahulu. Tanpa langkah ini, file yang disimpan di Windows dengan `\r\n` akan menggagalkan pencarian pembatas `---`. ```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; } } } ``` Pemanggilan `UseAdvancedExtensions()` mengaktifkan tabel, catatan kaki, daftar tugas, ID otomatis pada heading, dan ekstensi Markdig lain yang lazim dibutuhkan blog teknis. Perlu dicatat bahwa secara default Markdig meneruskan HTML mentah apa adanya. Untuk artikel yang ditulis sendiri oleh pemilik situs, hal ini tidak masalah. Namun Markdown yang berasal dari pengguna, seperti komentar atau tulisan tamu, wajib dirender dengan pipeline yang memanggil `DisableHtml()` agar terhindar dari stored XSS. ## Post store singleton yang thread-safe dengan hot reload Saat aplikasi dimulai, store membaca semua file dan menyimpan hasilnya dalam `FrozenDictionary` (tersedia sejak .NET 8), struktur data yang dioptimalkan untuk pembacaan intensif. Ketika ada file yang berubah, store membangun dictionary baru secara utuh, lalu mengganti referensinya dalam satu assignment. Pembaca tidak pernah memerlukan lock: setiap request melihat snapshot lama atau snapshot baru, tidak pernah koleksi yang setengah jadi. ```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 } } } ``` Ada tiga detail yang membuat kode ini aman untuk produksi: 1. Field `volatile` memastikan thread lain membaca referensi terbaru setelah pertukaran snapshot. 2. Blok `try/catch` mempertahankan snapshot valid terakhir ketika sebuah artikel memiliki YAML yang rusak. Satu salah ketik tidak akan mengosongkan seluruh blog. 3. Pemanggilan `EvictByTagAsync` menghapus semua halaman ter-cache yang bertag `posts`, sehingga konten baru langsung tampil pada request berikutnya, bukan setelah masa kedaluwarsa satu jam. > **File watcher di dalam container** > > `FileSystemWatcher` bergantung pada notifikasi sistem operasi yang tidak selalu menembus bind mount Docker atau network share. Jika folder `posts` di-mount ke dalam container, aktifkan variabel lingkungan `DOTNET_USE_POLLING_FILE_WATCHER=true` atau set `PhysicalFileProvider.UsePollingFileWatcher = true`. Editor teks juga sering menyimpan file dalam beberapa kali penulisan, sehingga `Reload` bisa terpicu dua atau tiga kali per penyimpanan. Hal ini tidak berbahaya karena setiap eksekusi menghasilkan snapshot yang sama. ## Endpoint Minimal API dengan route group dan TypedResults Halaman publik dikelompokkan di bawah `/blog` menggunakan `MapGroup`. Dengan cara ini, kebijakan output cache beserta tag-nya diterapkan ke semua endpoint dari satu tempat. Handler mengembalikan `RazorComponentResult`, fitur yang tersedia sejak .NET 8, yang merender komponen Razor sebagai respons HTTP lengkap tanpa MVC, Razor Pages, ataupun router Blazor. ```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); ``` Tipe kembalian `Results` adalah pembeda utama antara `TypedResults` dan helper `Results` versi lama. Compiler memeriksa bahwa handler hanya mengembalikan hasil yang dideklarasikan, generator OpenAPI membaca kedua kode status langsung dari signature, dan unit test cukup memeriksa `result.Result is NotFound` tanpa menjalankan server. Endpoint JSON sengaja diletakkan di luar grup `/blog` agar URL-nya tidak bentrok dengan slug artikel. Halaman artikel sendiri adalah komponen Razor biasa. `MarkupString` memberi tahu Razor untuk menuliskan keluaran Markdig sebagai HTML alih-alih meng-encode-nya, sementara URL canonical diambil dari `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!; } ``` Komponen `PostListPage.razor` mengikuti pola yang sama dengan parameter `Posts` dan perulangan atas judul serta ringkasan. Objek anonim yang dikirim ke `RazorComponentResult` dipetakan berdasarkan nama properti ke parameter komponen, sehingga `new { Post = post }` harus sama persis dengan parameter `Post`. ## Output caching untuk halaman blog ASP.NET Core Output caching, yang hadir sejak ASP.NET Core 7, menyimpan respons lengkap di server lalu memutarnya kembali tanpa menjalankan handler atau merender ulang komponen. Mekanisme ini berbeda dengan middleware response caching yang lebih lama. Response caching mengikuti semantik HTTP `Cache-Control`, sehingga klien bisa melewati cache cukup dengan header `no-cache`. [Dokumentasi output caching di Microsoft Learn](https://learn.microsoft.com/en-us/aspnet/core/performance/caching/output) menjelaskan aturan default-nya: hanya request `GET` dan `HEAD` dengan status 200 yang disimpan, dan respons yang menyetel cookie atau berasal dari request terautentikasi akan dilewati. Tag adalah fitur yang membuat output caching cocok untuk situs konten. Setiap endpoint blog membawa tag `posts`, dan store menghapus tag tersebut setiap kali selesai memuat ulang. Kebijakan dasar satu jam hanya berfungsi sebagai jaring pengaman. Dalam praktiknya, halaman tetap tersimpan di cache sampai kontennya berubah. Pada deployment multi-instance, store in-memory bersifat per proses: eviction di satu instance membuat instance lain tetap menyajikan konten lama. ASP.NET Core menyediakan store berbasis Redis melalui paket `Microsoft.AspNetCore.OutputCaching.StackExchangeRedis` dan metode `AddStackExchangeRedisOutputCache`, yang membagikan entri cache dan eviction ke seluruh instance. Untuk satu instance kecil, Redis belum diperlukan. ## Membuat feed RSS dari C# dengan SyndicationFeed Pembaca teknis masih banyak yang berlangganan lewat feed reader, dan agregator mengambil artikel baru dari feed, bukan dari sitemap. Kelas `SyndicationFeed` dan `Rss20FeedFormatter` menghasilkan feed yang sesuai dengan [spesifikasi RSS 2.0](https://www.rssboard.org/rss-specification) tanpa perlu menulis XML secara manual. ```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; } } ``` Membangun URL absolut dari `BlogOptions.SiteUrl` alih-alih dari `HttpContext.Request.Host` menutup celah host header injection. Tanpa langkah ini, satu request dengan nilai `Host` palsu cukup untuk membuat feed berisi tautan ke domain lain tersimpan di cache dan disajikan ke semua pelanggan. Argumen `UTF8Encoding(false)` menghilangkan byte order mark yang ditolak oleh sebagian feed reader. ## Deploy blog teknis C# dan batasan Native AOT Perintah `dotnet publish -c Release` menghasilkan build framework-dependent yang bisa berjalan di host mana pun dengan runtime .NET 10. Sejak .NET 8, SDK juga mampu membuat image container tanpa Dockerfile: `dotnet publish -c Release /t:PublishContainer` menghasilkan image berbasis runtime resmi ASP.NET Core. Folder `posts` bisa dimasukkan langsung ke dalam image (setiap perubahan konten memerlukan deploy ulang) atau di-mount sebagai volume (perubahan konten terdeteksi oleh file watcher). Native AOT terlihat menarik karena waktu startup dan konsumsi memorinya, tetapi proyek ini bukan kandidat yang tepat. [Tabel kompatibilitas Native AOT ASP.NET Core](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/native-aot) mencantumkan Minimal APIs sebagai didukung sebagian dan Blazor Server sebagai tidak didukung, sementara deserializer default YamlDotNet bergantung pada reflection. Blog menyajikan halaman ter-cache dari proses yang berjalan lama, sehingga waktu startup hampir tidak berpengaruh. Beralih ke AOT berarti mengganti komponen Razor dengan templat string dan YAML dengan front matter JSON berbasis source generator, dengan manfaat yang sangat kecil. ## Pertanyaan wawancara .NET yang terkait dengan proyek ini Setiap bagian dari mesin blog ini berhubungan langsung dengan pertanyaan yang sering diajukan dalam wawancara ASP.NET Core. [Pertanyaan wawancara .NET di SharpSkill](https://sharpskill.dev/id/technologies/dotnet) membahasnya secara mendalam, dan [modul Minimal APIs](https://sharpskill.dev/id/technologies/dotnet/pertanyaan-wawancara/minimal-apis) berfokus pada sisi endpoint. **"Apakah layanan singleton aman jika dibaca banyak request secara bersamaan?"** Hanya jika state-nya immutable atau tersinkronisasi. Store di atas memakai snapshot immutable dan pertukaran referensi `volatile`, sehingga pembaca tidak pernah mengambil lock dan penulis tidak pernah menghalangi pembaca. Jebakan klasiknya adalah singleton yang menyimpan `List` lalu memodifikasinya saat reload, yang di bawah beban tinggi akan melempar `InvalidOperationException` di tengah enumerasi. [Modul dependency injection](https://sharpskill.dev/id/technologies/dotnet/pertanyaan-wawancara/dependency-injection) juga membahas masalah captive dependency: singleton yang menerima layanan scoped, misalnya `DbContext`, akan menahannya sepanjang umur aplikasi. **"Apa perbedaan output caching dan response caching?"** Output caching dikendalikan server, mendukung tag dan eviction, serta mengabaikan header cache dari klien. Response caching mengikuti semantik HTTP dan pada dasarnya hanya petunjuk untuk proxy dan browser. **"Mengapa mengembalikan `TypedResults` dan bukan `Results`?"** Tipe hasil yang konkret memberikan pemeriksaan compile-time atas semua kemungkinan hasil, metadata OpenAPI otomatis, dan handler yang dapat diuji sebagai method biasa. Perbandingan lebih lengkap dengan controller tersedia di artikel tentang [arsitektur dan performa Minimal APIs](https://sharpskill.dev/id/blog/dotnet/aspnet-core-minimal-apis-architecture-performance-interview). **"Di mana urutan middleware berpengaruh dalam aplikasi ini?"** `UseOutputCache` harus didaftarkan sebelum endpoint yang di-cache, dan setelah `UseCors` jika CORS diaktifkan. Kandidat yang juga mampu menjelaskan mengapa kebijakan default tidak pernah menyimpan request terautentikasi, serta apa yang harus diperiksa oleh `IOutputCachePolicy` kustom sebelum menyimpannya, menunjukkan pemahaman tentang pipeline, bukan sekadar hafalan urutan. ## Kesimpulan: poin penting membangun blog C# dengan ASP.NET Core - Mulai dari `dotnet new web` di .NET 10 dan tambahkan hanya Markdig, YamlDotNet, serta `System.ServiceModel.Syndication`. Blog teknis tidak memerlukan CMS maupun database. - Parsing artikel sekali ke dalam `FrozenDictionary` yang immutable dan ganti seluruh snapshot saat reload, agar pembaca tidak pernah terkunci dan file rusak tidak pernah mengosongkan situs. - Render HTML dengan `RazorComponentResult` dari handler Minimal API, dan deklarasikan tipe kembalian `Results` agar OpenAPI dan unit test melihat semua kemungkinan hasil. - Lindungi setiap endpoint konten dengan output caching bertag sama, lalu panggil `EvictByTagAsync` setelah setiap reload alih-alih mengandalkan masa kedaluwarsa yang pendek. - Bangun URL canonical dan URL feed dari konfigurasi, jangan dari header `Host`, dan aktifkan `DisableHtml()` pada pipeline yang merender Markdown dari pengguna. - Set `DOTNET_USE_POLLING_FILE_WATCHER=true` ketika folder `posts` di-mount ke dalam container. - Manfaatkan proyek ini sebagai latihan wawancara: siapkan penjelasan lisan tentang thread safety singleton, pilihan mekanisme cache, dan urutan middleware. --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/id/blog/dotnet/csharp-blog-aspnet-core-minimal-apis-2026