สร้างบล็อก C# ในปี 2026: บล็อกเชิงเทคนิคด้วย ASP.NET Core และ Minimal APIs

สร้างบล็อก C# บน .NET 10 ด้วย ASP.NET Core Minimal APIs: บทความ Markdown พร้อม front matter ที่เก็บบทความที่ปลอดภัยต่อเธรดพร้อม hot reload หน้าคอมโพเนนต์ Razor, output caching และฟีด RSS

บล็อก C# ที่สร้างด้วย ASP.NET Core Minimal APIs บน .NET 10

บล็อก C# ที่สร้างด้วย ASP.NET Core Minimal APIs ใช้ไฟล์เพียงไม่กี่ไฟล์ ได้แก่ บทความ Markdown ที่เก็บบนดิสก์ บริการแบบ singleton ที่แยกวิเคราะห์บทความเพียงครั้งเดียว endpoint จำนวนหนึ่งที่เรนเดอร์ HTML และฟีด RSS บน .NET 10 ซึ่งเป็นรุ่นสนับสนุนระยะยาว (LTS) ที่เปิดตัวในเดือนพฤศจิกายน 2025 ทุกส่วนของระบบนี้มีอยู่แล้วในเฟรมเวิร์กหรือในแพ็กเกจ NuGet ที่ได้รับการดูแลอย่างดีเพียงสองตัว โดยไม่ต้องพึ่ง CMS หรือฐานข้อมูลแต่อย่างใด

สรุปสถาปัตยกรรมในย่อหน้าเดียว

โปรเจกต์เว็บ .NET 10 แบบว่าง ใช้ Markdig แปลง Markdown เป็น HTML ใช้ YamlDotNet อ่าน front matter มีที่เก็บบทความแบบ immutable ในหน่วยความจำที่โหลดใหม่เมื่อไฟล์เปลี่ยน มี endpoint แบบ Minimal API ที่คืนหน้า RazorComponentResult ใช้ output caching ร่วมกับการล้างแคชตามแท็ก และสร้างฟีด RSS 2.0 ด้วย System.ServiceModel.Syndication เอนจินทั้งหมดมีโค้ด C# ไม่ถึง 300 บรรทัด

ทำไมจึงเลือกเอนจินบล็อกแบบ Minimal API แทน static site generator

static site generator อย่าง Hugo หรือ Jekyll สร้างไฟล์ HTML ตั้งแต่ขั้นตอน build ซึ่งรวดเร็วและประหยัด แต่ความสามารถใดก็ตามที่เกินกว่าเทมเพลต เช่น การตั้งเวลาเผยแพร่บทความ API แบบ JSON สำหรับแอปมือถือ ฟีดแยกตามแท็ก หรือการเชื่อมต่อระบบวิเคราะห์ข้อมูล ล้วนต้องทำเป็นปลั๊กอินด้วยภาษาที่นักพัฒนา .NET ไม่ได้ใช้เป็นประจำ

บล็อกที่สร้างด้วย ASP.NET Core ยังคงเก็บเนื้อหาเป็นไฟล์ Markdown ธรรมดาใน Git แต่จะเรนเดอร์เมื่อมีคำขอครั้งแรก แล้วส่งผลลัพธ์จากหน่วยความจำในครั้งต่อ ๆ ไป เมื่อมี output caching อยู่ด้านหน้า ต้นทุนต่อคำขอแทบไม่ต่างจากการส่งไฟล์สแตติก ขณะที่โค้ดที่ทำงานอยู่คือ C# ปกติที่ดีบัก ทดสอบ และต่อยอดได้ อีกทั้งยังเป็นโปรเจกต์ขนาดกะทัดรัดที่ครอบคลุม dependency injection, request pipeline, การแคช และการทำงานพร้อมกัน ซึ่งเป็นหัวข้อหลักของการสัมภาษณ์งานสาย .NET

ประเด็นStatic site generatorบล็อก ASP.NET Core Minimal API
รูปแบบเนื้อหาMarkdown + front matterMarkdown + front matter
ช่วงเวลาเรนเดอร์ขณะ buildคำขอแรก จากนั้นเก็บในแคช
ตรรกะเฉพาะปลั๊กอิน เทมเพลตendpoint C# ทั่วไป
การโฮสต์โฮสต์สแตติกหรือ CDNคอนเทนเนอร์ App Service หรือ VPS ใดก็ได้
การอัปเดตเนื้อหาbuild และ deploy ใหม่file watcher โหลดที่เก็บบทความใหม่

ตั้งค่าโปรเจกต์บล็อก ASP.NET Core บน .NET 10

โปรเจกต์เริ่มจากเทมเพลตเว็บแบบว่าง คำสั่ง dotnet new web สร้างโปรเจกต์บน SDK Microsoft.NET.Sdk.Web ซึ่งคอมไพล์คอมโพเนนต์ .razor ได้ทันทีโดยไม่ต้องตั้งค่าเพิ่มเติม ส่วนที่เหลือใช้แพ็กเกจสามตัว ได้แก่ Markdig สำหรับแยกวิเคราะห์ CommonMark, YamlDotNet สำหรับ front matter และ System.ServiceModel.Syndication สำหรับฟีด

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

ไฟล์ Program.cs ทำหน้าที่เชื่อมทุกส่วนเข้าด้วยกัน ที่เก็บบทความลงทะเบียนเป็น singleton เพราะบทความที่แยกวิเคราะห์แล้วถูกใช้ร่วมกันในทุกคำขอ และ output caching ถูกวางไว้ใน pipeline ก่อน endpoint เพื่อให้คำตอบที่อยู่ในแคชข้ามการทำงานของ handler ไปทั้งหมด

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

ค่า SiteUrl จะมีความสำคัญในส่วนถัดไป เพราะลิงก์ canonical และ URL ของฟีดต้องสร้างจากการตั้งค่าเสมอ ไม่ใช่จาก header Host ของคำขอที่เข้ามา

แยกวิเคราะห์บทความ Markdown ที่มี front matter ด้วย C#

บทความแต่ละชิ้นคือไฟล์หนึ่งไฟล์ เช่น posts/output-caching-dotnet-10.md ชื่อไฟล์จะกลายเป็น slug และบล็อก YAML ที่อยู่ด้านบนสุดเก็บข้อมูลเมตาของบทความ

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

ตัวแยกวิเคราะห์จะแยกบล็อก YAML ออกจากเนื้อหา แปลงข้อมูลเมตาเป็นคลาสขนาดเล็ก แล้วแปลงเนื้อหาเป็น HTML โดยต้องปรับรูปแบบการขึ้นบรรทัดใหม่ให้เป็นมาตรฐานก่อน มิฉะนั้นบทความที่บันทึกบน Windows จะทำให้การค้นหาตัวคั่น --- ล้มเหลว

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; }
    }
}

UseAdvancedExtensions() เปิดใช้ตาราง เชิงอรรถ รายการงาน ID อัตโนมัติบนหัวข้อ และส่วนขยายอื่น ๆ ของ Markdig ที่บล็อกเชิงเทคนิคต้องการ โดยค่าเริ่มต้น Markdig จะส่ง HTML ดิบผ่านไปตามเดิม ซึ่งยอมรับได้สำหรับบทความที่เจ้าของเว็บเขียนเอง แต่ Markdown ใดก็ตามที่มาจากผู้ใช้ เช่น ความคิดเห็นหรือบทความจากผู้เขียนรับเชิญ จำเป็นต้องใช้ pipeline ที่เรียก DisableHtml() เพื่อป้องกัน stored XSS

ที่เก็บบทความแบบ singleton ที่ปลอดภัยต่อเธรดพร้อม hot reload

ที่เก็บบทความจะอ่านไฟล์ทั้งหมดตอนเริ่มระบบ และเก็บผลลัพธ์ไว้ใน FrozenDictionary (มีให้ใช้ตั้งแต่ .NET 8) ซึ่งออกแบบมาให้ค้นหาได้เร็วในงานที่อ่านเป็นหลัก เมื่อไฟล์ใดเปลี่ยนแปลง ที่เก็บจะสร้าง dictionary ใหม่ทั้งชุดแล้วสลับการอ้างอิงด้วยการกำหนดค่าเพียงครั้งเดียว ฝั่งผู้อ่านจึงไม่ต้องใช้ lock เลย ทุกคำขอจะเห็นเพียง snapshot เก่าหรือ snapshot ใหม่ ไม่มีทางเห็นคอลเลกชันที่สร้างไม่เสร็จ

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

รายละเอียดสามข้อทำให้โค้ดนี้พร้อมใช้งานจริงในระบบ production ข้อแรก ฟิลด์ volatile รับประกันว่าเธรดอื่นจะอ่านการอ้างอิงล่าสุดหลังการสลับ ข้อสอง บล็อก try/catch เก็บ snapshot ที่ถูกต้องล่าสุดไว้เมื่อบทความใดมี YAML ผิดรูปแบบ การพิมพ์ผิดในไฟล์เดียวจึงไม่ทำให้บล็อกว่างเปล่า ข้อสาม การเรียก EvictByTagAsync จะล้างหน้าที่แคชไว้ทั้งหมดซึ่งติดแท็ก posts เนื้อหาใหม่จึงปรากฏในคำขอถัดไปทันที ไม่ต้องรอให้แคชหมดอายุในหนึ่งชั่วโมง

การเฝ้าดูไฟล์ภายในคอนเทนเนอร์

FileSystemWatcher อาศัยการแจ้งเตือนจากระบบปฏิบัติการ ซึ่งส่งผ่าน bind mount ของ Docker หรือโฟลเดอร์แชร์บนเครือข่ายได้ไม่สม่ำเสมอ ในคอนเทนเนอร์ที่ mount โฟลเดอร์ posts ควรตั้งตัวแปรสภาพแวดล้อม DOTNET_USE_POLLING_FILE_WATCHER=true หรือ PhysicalFileProvider.UsePollingFileWatcher = true นอกจากนี้โปรแกรมแก้ไขข้อความมักบันทึกไฟล์ด้วยการเขียนหลายครั้ง Reload จึงอาจทำงานสองถึงสามครั้งต่อการบันทึกหนึ่งครั้ง ซึ่งไม่เป็นปัญหาในกรณีนี้ เพราะทุกรอบให้ snapshot เดียวกัน

endpoint แบบ Minimal API ด้วย route group และ TypedResults

หน้าสาธารณะทั้งหมดถูกจัดกลุ่มไว้ใต้ /blog ด้วย MapGroup ซึ่งช่วยกำหนดนโยบาย output cache และแท็กให้ทุก endpoint ได้จากจุดเดียว handler คืนค่าเป็น RazorComponentResult<T> ที่มีให้ใช้ตั้งแต่ .NET 8 ซึ่งเรนเดอร์คอมโพเนนต์ Razor เป็นคำตอบ HTTP ที่สมบูรณ์ โดยไม่ต้องใช้ MVC, Razor Pages หรือ 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);

ชนิดค่าคืน Results<T1, T2> คือสิ่งที่ทำให้ TypedResults แตกต่างจาก helper Results รุ่นเก่า คอมไพเลอร์จะตรวจว่า handler คืนค่าได้เฉพาะผลลัพธ์ที่ประกาศไว้ ตัวสร้าง OpenAPI อ่านรหัสสถานะทั้งสองจาก signature ได้โดยตรง และ unit test สามารถตรวจ result.Result is NotFound ได้โดยไม่ต้องเปิดเซิร์ฟเวอร์ ส่วน endpoint แบบ JSON ถูกวางไว้นอกกลุ่ม /blog เพื่อไม่ให้ URL ชนกับ slug ของบทความ

หน้าบทความเป็นคอมโพเนนต์ Razor ธรรมดา MarkupString บอกให้ Razor แสดงผลลัพธ์จาก Markdig เป็น HTML แทนการเข้ารหัส และ URL canonical ดึงมาจาก 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!;
}

PostListPage.razor ใช้รูปแบบเดียวกัน โดยมีพารามิเตอร์ Posts และวนลูปแสดงชื่อเรื่องพร้อมบทสรุป ออบเจกต์นิรนามที่ส่งให้ RazorComponentResult จะจับคู่ชื่อพร็อพเพอร์ตีกับพารามิเตอร์ของคอมโพเนนต์ ดังนั้น new { Post = post } ต้องตรงกับพารามิเตอร์ Post ทุกตัวอักษร

พร้อมที่จะพิชิตการสัมภาษณ์ .NET แล้วหรือยังครับ?

ฝึกฝนด้วยตัวจำลองแบบโต้ตอบ, flashcards และแบบทดสอบเทคนิคครับ

output caching สำหรับหน้าบล็อก ASP.NET Core

output caching ซึ่งเพิ่มเข้ามาใน ASP.NET Core 7 จะเก็บคำตอบทั้งหมดไว้บนเซิร์ฟเวอร์ แล้วส่งซ้ำโดยไม่ต้องรัน handler หรือเรนเดอร์คอมโพเนนต์ใหม่ กลไกนี้ต่างจาก middleware response caching รุ่นเก่า ที่ทำงานตามความหมายของ HTTP Cache-Control และเปิดให้ไคลเอนต์ข้ามแคชได้ด้วย header no-cache เอกสาร output caching บน Microsoft Learn อธิบายกฎเริ่มต้นไว้ว่า จะแคชเฉพาะคำขอ GET และ HEAD ที่ได้สถานะ 200 และจะข้ามคำตอบที่มีการตั้งคุกกี้หรือมาจากคำขอที่ยืนยันตัวตนแล้ว

แท็กคือสิ่งที่ทำให้ output caching เหมาะกับเว็บไซต์เนื้อหา ทุก endpoint ของบล็อกติดแท็ก posts และที่เก็บบทความจะล้างแท็กนี้หลังการโหลดใหม่ทุกครั้ง นโยบายพื้นฐานหนึ่งชั่วโมงเป็นเพียงตาข่ายนิรภัย ในทางปฏิบัติหน้าต่าง ๆ จะอยู่ในแคชจนกว่าเนื้อหาจะเปลี่ยน

สำหรับการ deploy หลายอินสแตนซ์ ที่เก็บแคชในหน่วยความจำจะแยกตามโพรเซส การล้างแคชบนอินสแตนซ์หนึ่งจึงทำให้อินสแตนซ์อื่นยังเก็บข้อมูลเก่าอยู่ ASP.NET Core มีที่เก็บแคชบน Redis ผ่านแพ็กเกจ Microsoft.AspNetCore.OutputCaching.StackExchangeRedis และเมธอด AddStackExchangeRedisOutputCache ซึ่งแชร์รายการแคชและการล้างแคชระหว่างอินสแตนซ์ หากมีอินสแตนซ์ขนาดเล็กเพียงตัวเดียวก็ไม่จำเป็นต้องใช้

สร้างฟีด RSS ด้วย C# และ SyndicationFeed

ผู้อ่านสายเทคนิคยังคงติดตามผ่านโปรแกรมอ่านฟีด และเว็บรวบรวมเนื้อหาก็ดึงบทความใหม่จากฟีด ไม่ใช่จาก sitemap คลาส SyndicationFeed และ Rss20FeedFormatter สร้างฟีดที่เป็นไปตาม ข้อกำหนด RSS 2.0 โดยไม่ต้องเขียน XML เอง

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;
    }
}

การสร้าง URL แบบสมบูรณ์จาก BlogOptions.SiteUrl แทน HttpContext.Request.Host ช่วยปิดช่องโหว่ host header injection หากไม่ทำเช่นนี้ คำขอเพียงครั้งเดียวที่ปลอมค่า Host จะถูกเก็บในแคชและส่งให้ผู้ติดตามทุกคน พร้อมลิงก์ที่ชี้ไปยังโดเมนอื่น ส่วนอาร์กิวเมนต์ UTF8Encoding(false) จะตัด byte order mark ออก เนื่องจากโปรแกรมอ่านฟีดบางตัวไม่ยอมรับ

การ deploy บล็อกเทคนิค C# และข้อจำกัดของ Native AOT

คำสั่ง dotnet publish -c Release สร้าง build แบบ framework-dependent ที่รันได้บนทุกโฮสต์ที่มี runtime .NET 10 ตั้งแต่ .NET 8 เป็นต้นมา SDK ยังสร้างอิมเมจคอนเทนเนอร์ได้โดยไม่ต้องมี Dockerfile คำสั่ง dotnet publish -c Release /t:PublishContainer จะสร้างอิมเมจจาก runtime image อย่างเป็นทางการของ ASP.NET Core โฟลเดอร์ posts สามารถรวมไว้ในอิมเมจ (การเปลี่ยนเนื้อหาต้อง deploy ใหม่) หรือ mount เป็น volume (file watcher จะตรวจพบการเปลี่ยนแปลงเนื้อหา)

Native AOT น่าสนใจในแง่เวลาเริ่มระบบและการใช้หน่วยความจำ แต่โปรเจกต์นี้ไม่เหมาะ ตารางความเข้ากันได้ของ Native AOT ใน ASP.NET Core ระบุว่า Minimal APIs รองรับเพียงบางส่วน และ Blazor Server ไม่รองรับ อีกทั้งตัวแปลงข้อมูลเริ่มต้นของ YamlDotNet ยังพึ่งพา reflection บล็อกส่งหน้าที่แคชไว้จากโพรเซสที่ทำงานต่อเนื่องยาวนาน เวลาเริ่มระบบจึงแทบไม่มีผล การเปลี่ยนไปใช้ AOT หมายถึงต้องแทนคอมโพเนนต์ Razor ด้วยเทมเพลตสตริง และแทน YAML ด้วย front matter แบบ JSON ที่ใช้ source generator ซึ่งได้ประโยชน์น้อยมาก

คำถามสัมภาษณ์ .NET ที่โปรเจกต์บล็อกนี้ช่วยเตรียมตัว

ทุกส่วนของเอนจินเชื่อมโยงกับคำถามที่พบบ่อยในการสัมภาษณ์งาน ASP.NET Core คำถามสัมภาษณ์ .NET บน SharpSkill อธิบายหัวข้อเหล่านี้อย่างละเอียด และ โมดูล Minimal APIs เน้นที่ฝั่ง endpoint

"บริการแบบ singleton ปลอดภัยหรือไม่ เมื่อมีหลายคำขออ่านพร้อมกัน" ปลอดภัยก็ต่อเมื่อสถานะของบริการเป็น immutable หรือมีการซิงโครไนซ์ ที่เก็บบทความข้างต้นใช้ snapshot แบบ immutable และการสลับการอ้างอิงแบบ volatile ผู้อ่านจึงไม่ต้อง lock และผู้เขียนไม่ขวางผู้อ่าน กับดักคลาสสิกคือ singleton ที่ถือ List<T> แล้วแก้ไขระหว่างการโหลดใหม่ ซึ่งจะโยน InvalidOperationException กลางการวนลูปเมื่อมีโหลดสูง โมดูล dependency injection ยังครอบคลุมปัญหา captive dependency คือ singleton ที่รับบริการแบบ scoped เช่น DbContext เข้ามา จะทำให้บริการนั้นมีชีวิตอยู่ตลอดอายุของแอป

"output caching กับ response caching ต่างกันอย่างไร" output caching ควบคุมโดยเซิร์ฟเวอร์ รองรับแท็กและการล้างแคช และไม่สนใจ header แคชจากไคลเอนต์ ส่วน response caching ทำงานตามความหมายของ HTTP และส่วนใหญ่เป็นเพียงคำแนะนำสำหรับพร็อกซีและเบราว์เซอร์

"ทำไมจึงคืนค่า TypedResults แทน Results" ชนิดผลลัพธ์ที่ชัดเจนช่วยให้ตรวจสอบผลลัพธ์ที่เป็นไปได้ตั้งแต่ตอนคอมไพล์ สร้างข้อมูลเมตา OpenAPI ได้อัตโนมัติ และทำให้ทดสอบ handler ได้เหมือนเมธอดทั่วไป การเปรียบเทียบเชิงลึกกับ controller อยู่ในบทความเรื่อง สถาปัตยกรรมและประสิทธิภาพของ Minimal APIs

"ลำดับของ middleware มีผลตรงไหนในแอปนี้" UseOutputCache ต้องลงทะเบียนก่อน endpoint ที่ต้องการแคช และหลัง UseCors เมื่อเปิดใช้ CORS ผู้สมัครที่อธิบายได้เพิ่มเติมว่าทำไมนโยบายเริ่มต้นจึงไม่แคชคำขอที่ยืนยันตัวตนแล้ว และ IOutputCachePolicy ที่เขียนเองต้องตรวจสอบอะไรก่อนแคชคำขอเหล่านั้น จะแสดงให้เห็นความเข้าใจใน pipeline อย่างแท้จริง ไม่ใช่เพียงการท่องจำลำดับ

สรุปประเด็นสำคัญของการสร้างบล็อก C# ด้วย ASP.NET Core

  • เริ่มจาก dotnet new web บน .NET 10 และเพิ่มเพียง Markdig, YamlDotNet และ System.ServiceModel.Syndication บล็อกเชิงเทคนิคไม่จำเป็นต้องมี CMS หรือฐานข้อมูล
  • แยกวิเคราะห์บทความเพียงครั้งเดียวลงใน FrozenDictionary แบบ immutable และสลับ snapshot ทั้งชุดเมื่อโหลดใหม่ ผู้อ่านจึงไม่ต้อง lock และไฟล์ที่เสียจะไม่ทำให้เว็บไซต์ว่างเปล่า
  • เรนเดอร์ HTML ด้วย RazorComponentResult<T> จาก handler แบบ Minimal API และประกาศชนิดค่าคืน Results<T1, T2> เพื่อให้ OpenAPI และ unit test เห็นผลลัพธ์ทุกกรณี
  • วาง endpoint เนื้อหาทุกตัวไว้หลัง output caching ที่ใช้แท็กร่วมกัน และเรียก EvictByTagAsync หลังการโหลดใหม่ทุกครั้ง แทนการพึ่งพาเวลาหมดอายุที่สั้น
  • สร้าง URL canonical และ URL ของฟีดจากการตั้งค่า ห้ามสร้างจาก header Host และเปิด DisableHtml() ใน pipeline ใดก็ตามที่เรนเดอร์ Markdown จากผู้ใช้
  • ตั้งค่า DOTNET_USE_POLLING_FILE_WATCHER=true เมื่อ mount โฟลเดอร์บทความเข้าไปในคอนเทนเนอร์
  • ใช้โปรเจกต์นี้เป็นแบบฝึกหัดสำหรับการสัมภาษณ์ เตรียมอธิบายด้วยคำพูดของตนเองเรื่องความปลอดภัยต่อเธรดของ singleton การเลือกกลไกแคช และลำดับของ middleware

เริ่มฝึกซ้อมเลย!

ทดสอบความรู้ของคุณด้วยตัวจำลองสัมภาษณ์และแบบทดสอบเทคนิคครับ

ชาเลนจ์ประจำวัน

คุณหาบั๊กใน .NET เจอไหม

โค้ดจริงหนึ่งชิ้น บั๊กที่ซ่อนอยู่หนึ่งจุด วันละหนึ่งครั้ง ลองได้โดยไม่ต้องมีบัญชี

Anthony Fillion-Maillet

เขียนโดย

Anthony Fillion-Maillet

ผู้ก่อตั้ง SharpSkill

เป็นนักพัฒนาฟูลสแตกมากว่า 10 ปี ดูแล SharpSkill และรับผิดชอบทุกสิ่งที่เผยแพร่ที่นี่

อัปเดตเมื่อ 17 พฤศจิกายน 2569

แท็ก

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

แชร์

บทความที่เกี่ยวข้อง

.NET 10 new features Native AOT C# 14

.NET 10 ในปี 2026: ฟีเจอร์ใหม่ Native AOT และ C# 14 สำหรับเตรียมสัมภาษณ์งาน

.NET 10 เปิดตัวในฐานะรีลีส long-term support พร้อมการปรับปรุง Native AOT, extension member C# 14, field keyword และ file-based apps คู่มือครบถ้วนครอบคลุมฟีเจอร์ใหม่ การปรับปรุงประสิทธิภาพ และความรู้สำหรับสัมภาษณ์งานสำหรับนักพัฒนา .NET ในปี 2026

รูปแบบ lifetime ของ DbContext และความปลอดภัยของ thread ในการทำงานแบบ async ของ ASP.NET Core

การจัดการ Lifetime ของ DbContext ใน ASP.NET Core: ประสิทธิภาพ vs ความปลอดภัยของ Thread ในการทำงานแบบ Async

เรียนรู้วิธีจัดการ lifetime ของ DbContext ใน ASP.NET Core อย่างเหมาะสม ทำความเข้าใจว่าเมื่อใดควรใช้ scoped vs transient วิธีจัดการการทำงาน async อย่างปลอดภัย และการเพิ่มประสิทธิภาพด้วย DbContext pooling

Clean Code Architecture C# diagram showing layers and dependencies

Clean Code Architecture C#: คู่มือฉบับสมบูรณ์และคำถามสัมภาษณ์ 2026

เรียนรู้ Clean Code Architecture ใน C# พร้อมหลักการ SOLID, Repository Pattern, Dependency Injection และคำถามสัมภาษณ์ยอดนิยมสำหรับนักพัฒนา .NET