# สร้างบล็อก C# ในปี 2026: บล็อกเชิงเทคนิคด้วย ASP.NET Core และ Minimal APIs > สร้างบล็อก C# บน .NET 10 ด้วย ASP.NET Core Minimal APIs: บทความ Markdown พร้อม front matter ที่เก็บบทความที่ปลอดภัยต่อเธรดพร้อม hot reload หน้าคอมโพเนนต์ Razor, output caching และฟีด 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 --- บล็อก 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 matter | Markdown + 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](https://github.com/xoofx/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 ไปทั้งหมด ```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/"; } ``` ค่า `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 จะทำให้การค้นหาตัวคั่น `---` ล้มเหลว ```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()` เปิดใช้ตาราง เชิงอรรถ รายการงาน ID อัตโนมัติบนหัวข้อ และส่วนขยายอื่น ๆ ของ Markdig ที่บล็อกเชิงเทคนิคต้องการ โดยค่าเริ่มต้น Markdig จะส่ง HTML ดิบผ่านไปตามเดิม ซึ่งยอมรับได้สำหรับบทความที่เจ้าของเว็บเขียนเอง แต่ Markdown ใดก็ตามที่มาจากผู้ใช้ เช่น ความคิดเห็นหรือบทความจากผู้เขียนรับเชิญ จำเป็นต้องใช้ pipeline ที่เรียก `DisableHtml()` เพื่อป้องกัน stored XSS ## ที่เก็บบทความแบบ singleton ที่ปลอดภัยต่อเธรดพร้อม hot reload ที่เก็บบทความจะอ่านไฟล์ทั้งหมดตอนเริ่มระบบ และเก็บผลลัพธ์ไว้ใน `FrozenDictionary` (มีให้ใช้ตั้งแต่ .NET 8) ซึ่งออกแบบมาให้ค้นหาได้เร็วในงานที่อ่านเป็นหลัก เมื่อไฟล์ใดเปลี่ยนแปลง ที่เก็บจะสร้าง dictionary ใหม่ทั้งชุดแล้วสลับการอ้างอิงด้วยการกำหนดค่าเพียงครั้งเดียว ฝั่งผู้อ่านจึงไม่ต้องใช้ lock เลย ทุกคำขอจะเห็นเพียง snapshot เก่าหรือ snapshot ใหม่ ไม่มีทางเห็นคอลเลกชันที่สร้างไม่เสร็จ ```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 } } } ``` รายละเอียดสามข้อทำให้โค้ดนี้พร้อมใช้งานจริงในระบบ 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` ที่มีให้ใช้ตั้งแต่ .NET 8 ซึ่งเรนเดอร์คอมโพเนนต์ Razor เป็นคำตอบ HTTP ที่สมบูรณ์ โดยไม่ต้องใช้ MVC, Razor Pages หรือ 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); ``` ชนิดค่าคืน `Results` คือสิ่งที่ทำให้ `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 Options @Post.Title | @Options.Value.Title

@Post.Title

@((MarkupString)Post.Html)
@code { [Parameter, EditorRequired] public Post Post { get; set; } = default!; } ``` `PostListPage.razor` ใช้รูปแบบเดียวกัน โดยมีพารามิเตอร์ `Posts` และวนลูปแสดงชื่อเรื่องพร้อมบทสรุป ออบเจกต์นิรนามที่ส่งให้ `RazorComponentResult` จะจับคู่ชื่อพร็อพเพอร์ตีกับพารามิเตอร์ของคอมโพเนนต์ ดังนั้น `new { Post = post }` ต้องตรงกับพารามิเตอร์ `Post` ทุกตัวอักษร ## 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](https://learn.microsoft.com/en-us/aspnet/core/performance/caching/output) อธิบายกฎเริ่มต้นไว้ว่า จะแคชเฉพาะคำขอ `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](https://www.rssboard.org/rss-specification) โดยไม่ต้องเขียน XML เอง ```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; } } ``` การสร้าง 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](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/native-aot) ระบุว่า Minimal APIs รองรับเพียงบางส่วน และ Blazor Server ไม่รองรับ อีกทั้งตัวแปลงข้อมูลเริ่มต้นของ YamlDotNet ยังพึ่งพา reflection บล็อกส่งหน้าที่แคชไว้จากโพรเซสที่ทำงานต่อเนื่องยาวนาน เวลาเริ่มระบบจึงแทบไม่มีผล การเปลี่ยนไปใช้ AOT หมายถึงต้องแทนคอมโพเนนต์ Razor ด้วยเทมเพลตสตริง และแทน YAML ด้วย front matter แบบ JSON ที่ใช้ source generator ซึ่งได้ประโยชน์น้อยมาก ## คำถามสัมภาษณ์ .NET ที่โปรเจกต์บล็อกนี้ช่วยเตรียมตัว ทุกส่วนของเอนจินเชื่อมโยงกับคำถามที่พบบ่อยในการสัมภาษณ์งาน ASP.NET Core [คำถามสัมภาษณ์ .NET บน SharpSkill](https://sharpskill.dev/th/technologies/dotnet) อธิบายหัวข้อเหล่านี้อย่างละเอียด และ [โมดูล Minimal APIs](https://sharpskill.dev/th/technologies/dotnet/interview-questions/minimal-apis) เน้นที่ฝั่ง endpoint **"บริการแบบ singleton ปลอดภัยหรือไม่ เมื่อมีหลายคำขออ่านพร้อมกัน"** ปลอดภัยก็ต่อเมื่อสถานะของบริการเป็น immutable หรือมีการซิงโครไนซ์ ที่เก็บบทความข้างต้นใช้ snapshot แบบ immutable และการสลับการอ้างอิงแบบ `volatile` ผู้อ่านจึงไม่ต้อง lock และผู้เขียนไม่ขวางผู้อ่าน กับดักคลาสสิกคือ singleton ที่ถือ `List` แล้วแก้ไขระหว่างการโหลดใหม่ ซึ่งจะโยน `InvalidOperationException` กลางการวนลูปเมื่อมีโหลดสูง [โมดูล dependency injection](https://sharpskill.dev/th/technologies/dotnet/interview-questions/dependency-injection) ยังครอบคลุมปัญหา captive dependency คือ singleton ที่รับบริการแบบ scoped เช่น `DbContext` เข้ามา จะทำให้บริการนั้นมีชีวิตอยู่ตลอดอายุของแอป **"output caching กับ response caching ต่างกันอย่างไร"** output caching ควบคุมโดยเซิร์ฟเวอร์ รองรับแท็กและการล้างแคช และไม่สนใจ header แคชจากไคลเอนต์ ส่วน response caching ทำงานตามความหมายของ HTTP และส่วนใหญ่เป็นเพียงคำแนะนำสำหรับพร็อกซีและเบราว์เซอร์ **"ทำไมจึงคืนค่า `TypedResults` แทน `Results`"** ชนิดผลลัพธ์ที่ชัดเจนช่วยให้ตรวจสอบผลลัพธ์ที่เป็นไปได้ตั้งแต่ตอนคอมไพล์ สร้างข้อมูลเมตา OpenAPI ได้อัตโนมัติ และทำให้ทดสอบ handler ได้เหมือนเมธอดทั่วไป การเปรียบเทียบเชิงลึกกับ controller อยู่ในบทความเรื่อง [สถาปัตยกรรมและประสิทธิภาพของ Minimal APIs](https://sharpskill.dev/th/blog/dotnet/aspnet-core-minimal-apis-architecture-performance-interview) **"ลำดับของ 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` จาก handler แบบ Minimal API และประกาศชนิดค่าคืน `Results` เพื่อให้ OpenAPI และ unit test เห็นผลลัพธ์ทุกกรณี - วาง endpoint เนื้อหาทุกตัวไว้หลัง output caching ที่ใช้แท็กร่วมกัน และเรียก `EvictByTagAsync` หลังการโหลดใหม่ทุกครั้ง แทนการพึ่งพาเวลาหมดอายุที่สั้น - สร้าง URL canonical และ URL ของฟีดจากการตั้งค่า ห้ามสร้างจาก header `Host` และเปิด `DisableHtml()` ใน pipeline ใดก็ตามที่เรนเดอร์ Markdown จากผู้ใช้ - ตั้งค่า `DOTNET_USE_POLLING_FILE_WATCHER=true` เมื่อ mount โฟลเดอร์บทความเข้าไปในคอนเทนเนอร์ - ใช้โปรเจกต์นี้เป็นแบบฝึกหัดสำหรับการสัมภาษณ์ เตรียมอธิบายด้วยคำพูดของตนเองเรื่องความปลอดภัยต่อเธรดของ singleton การเลือกกลไกแคช และลำดับของ middleware --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/th/blog/dotnet/csharp-blog-aspnet-core-minimal-apis-2026