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.

Blog C# yang dibangun dengan ASP.NET Core Minimal APIs di .NET 10

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.

AspekStatic site generatorBlog Minimal API ASP.NET Core
Format kontenMarkdown + front matterMarkdown + front matter
Waktu renderSaat buildRequest pertama, lalu di-cache
Logika khususPlugin, templatEndpoint C# biasa
HostingHost statis atau CDNContainer, App Service, VPS
Pembaruan kontenBuild ulang dan deploy ulangFile 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 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.

Program.cscsharp
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/";
}

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 ---.

Posts/PostParser.cscsharp
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; }
    }
}

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.

Posts/PostStore.cscsharp
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
        }
    }
}

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<T>, fitur yang tersedia sejak .NET 8, yang merender komponen Razor sebagai respons HTTP lengkap tanpa MVC, Razor Pages, ataupun router Blazor.

Endpoints/BlogEndpoints.cscsharp
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);

Tipe kembalian Results<T1, T2> 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<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!;
}

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.

Siap menguasai wawancara .NET Anda?

Berlatih dengan simulator interaktif, flashcards, dan tes teknis kami.

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 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 tanpa perlu menulis XML secara manual.

Endpoints/FeedEndpoints.cscsharp
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;
    }
}

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 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 membahasnya secara mendalam, dan modul 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<T> lalu memodifikasinya saat reload, yang di bawah beban tinggi akan melempar InvalidOperationException di tengah enumerasi. Modul 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.

"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<T> dari handler Minimal API, dan deklarasikan tipe kembalian Results<T1, T2> 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.

Mulai berlatih!

Uji pengetahuan Anda dengan simulator wawancara dan tes teknis kami.

Tantangan harian

Bisakah kamu menemukan bug di .NET?

Satu potongan kode nyata, satu bug tersembunyi, satu percobaan per hari. Tanpa akun untuk mencoba.

Anthony Fillion-Maillet

Ditulis oleh

Anthony Fillion-Maillet

Pendiri SharpSkill

Developer fullstack selama lebih dari 10 tahun. Ia menjalankan SharpSkill dan bertanggung jawab atas semua yang diterbitkan di sini.

Diperbarui 17 November 2026

Tag

#dotnet
#csharp
#aspnet-core
#minimal-apis
#output-caching
#tutorial

Bagikan

Artikel terkait