# Xây dựng blog C# năm 2026: Viết blog kỹ thuật với ASP.NET Core và Minimal APIs > Hướng dẫn xây dựng blog C# trên .NET 10 bằng ASP.NET Core Minimal APIs: bài viết Markdown có front matter, kho bài viết an toàn luồng với hot reload, trang component Razor, output caching và RSS feed. - 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 --- Một blog C# xây dựng trên ASP.NET Core Minimal APIs chỉ cần vài file: các bài viết Markdown lưu trên đĩa, một service singleton phân tích chúng một lần duy nhất, vài endpoint render HTML và một RSS feed. Với .NET 10, phiên bản hỗ trợ dài hạn (LTS) phát hành vào tháng 11 năm 2025, toàn bộ ngăn xếp này đã có sẵn trong framework hoặc nằm trong hai gói NuGet được duy trì tốt, hoàn toàn không cần CMS hay cơ sở dữ liệu. > **Toàn bộ kiến trúc trong một đoạn** > > Dự án web .NET 10 trống, Markdig để chuyển Markdown sang HTML, YamlDotNet cho front matter, kho bài viết bất biến trong bộ nhớ được nạp lại khi file thay đổi, các endpoint Minimal API trả về trang `RazorComponentResult`, output caching với cơ chế xóa theo tag và RSS 2.0 feed từ `System.ServiceModel.Syndication`. Toàn bộ engine chưa tới 300 dòng C#. ## Vì sao chọn blog Minimal API thay vì static site generator Các static site generator như Hugo hay Jekyll sinh file HTML ngay lúc build. Chúng nhanh và rẻ, nhưng mọi tính năng vượt ra ngoài template, chẳng hạn bài viết hẹn giờ đăng, API JSON cho ứng dụng di động, feed riêng theo tag hay tích hợp phân tích, đều trở thành plugin viết bằng một ngôn ngữ mà lập trình viên .NET hiếm khi dùng hằng ngày. Một blog ASP.NET Core vẫn giữ nội dung dưới dạng file Markdown thuần trong Git, nhưng render ở request đầu tiên rồi phục vụ kết quả từ bộ nhớ cho các lần sau. Khi đặt output caching phía trước, chi phí cho mỗi request gần như tương đương phục vụ một file tĩnh, còn đoạn code thực thi là C# thông thường, có thể debug, kiểm thử và mở rộng. Đây cũng là một dự án gọn gàng chạm tới dependency injection, request pipeline, caching và xử lý đồng thời, đúng những chủ đề thường xuất hiện trong phỏng vấn kỹ thuật .NET. | Tiêu chí | Static site generator | Blog ASP.NET Core Minimal API | |---|---|---| | Định dạng nội dung | Markdown + front matter | Markdown + front matter | | Thời điểm render | Lúc build | Request đầu tiên, sau đó lưu cache | | Logic tùy biến | Plugin, template | Endpoint C# thông thường | | Hosting | Host tĩnh hoặc CDN | Container, App Service, VPS bất kỳ | | Cập nhật nội dung | Build và deploy lại | File watcher nạp lại kho bài viết | ## Khởi tạo dự án blog ASP.NET Core trên .NET 10 Dự án bắt đầu từ template web trống. Lệnh `dotnet new web` tạo dự án dựa trên SDK `Microsoft.NET.Sdk.Web`, vốn biên dịch được các component `.razor` mà không cần cấu hình thêm. Ba gói còn lại đảm nhận phần việc khác: [Markdig](https://github.com/xoofx/markdig) để phân tích CommonMark, YamlDotNet cho front matter và `System.ServiceModel.Syndication` cho 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 ``` File `Program.cs` kết nối mọi thành phần. Kho bài viết được đăng ký dạng singleton vì dữ liệu đã phân tích được dùng chung cho mọi request, và middleware output caching nằm trước các endpoint để response đã cache bỏ qua hoàn toàn bước thực thi 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/"; } ``` Thiết lập `SiteUrl` sẽ quan trọng ở các phần sau: liên kết canonical và URL của feed luôn được dựng từ cấu hình, không bao giờ từ header `Host` của request gửi đến. ## Phân tích bài viết Markdown có front matter bằng C# Mỗi bài viết là một file, ví dụ `posts/output-caching-dotnet-10.md`. Tên file trở thành slug, còn khối YAML ở đầu file chứa siêu dữ liệu: ```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... ``` Bộ phân tích tách khối YAML ra khỏi phần thân, giải tuần tự hóa siêu dữ liệu vào một lớp nhỏ rồi chuyển phần thân sang HTML. Ký tự xuống dòng được chuẩn hóa trước tiên, nếu không một bài viết lưu trên Windows sẽ làm hỏng việc tìm dấu phân cách `---`. ```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()` bật bảng, chú thích cuối trang, danh sách công việc, ID tự động cho tiêu đề và các phần mở rộng Markdig khác mà một blog kỹ thuật cần. Mặc định Markdig giữ nguyên HTML thô. Điều này chấp nhận được với bài viết do chủ trang tự soạn, nhưng mọi nội dung Markdown do người dùng gửi lên (bình luận, bài viết khách mời) đều phải dùng pipeline có `DisableHtml()` để tránh lỗ hổng stored XSS. ## Kho bài viết singleton an toàn luồng với hot reload Kho bài viết đọc toàn bộ file khi khởi động và giữ kết quả trong một `FrozenDictionary` (có từ .NET 8), cấu trúc được tối ưu cho tra cứu đọc nhiều. Khi một file thay đổi, kho dựng một dictionary hoàn toàn mới rồi thay tham chiếu bằng một phép gán duy nhất. Bên đọc không bao giờ phải lấy khóa: mỗi request thấy hoặc snapshot cũ, hoặc snapshot mới, không bao giờ thấy một tập hợp đang dựng dở. ```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 } } } ``` Ba chi tiết giúp đoạn code này an toàn cho môi trường production. Trường `volatile` đảm bảo các luồng khác đọc được tham chiếu mới nhất sau khi hoán đổi. Khối `try/catch` giữ lại snapshot hợp lệ gần nhất khi một bài viết có YAML lỗi, nên một lỗi đánh máy trong một file không làm blog trống trơn. Cuối cùng, lời gọi `EvictByTagAsync` xóa mọi trang đã cache mang tag `posts`, nhờ đó nội dung mới xuất hiện ngay ở request kế tiếp thay vì phải chờ hết hạn một giờ. > **Theo dõi file bên trong container** > > `FileSystemWatcher` dựa vào thông báo của hệ điều hành, vốn không truyền qua bind mount của Docker hay thư mục chia sẻ mạng một cách ổn định. Trong container có mount thư mục `posts`, cần đặt biến môi trường `DOTNET_USE_POLLING_FILE_WATCHER=true` hoặc `PhysicalFileProvider.UsePollingFileWatcher = true`. Trình soạn thảo cũng thường lưu file qua nhiều lần ghi, nên `Reload` có thể chạy hai hoặc ba lần mỗi lần lưu: điều này vô hại ở đây vì mỗi lần chạy đều tạo ra cùng một snapshot. ## Endpoint Minimal API với route group và TypedResults Các trang công khai được gom dưới `/blog` bằng `MapGroup`, giúp áp dụng chính sách output cache cùng tag của nó cho mọi endpoint tại một chỗ. Handler trả về `RazorComponentResult`, có từ .NET 8, cho phép render một component Razor thành toàn bộ HTTP response mà không cần MVC, Razor Pages hay router của 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); ``` Kiểu trả về `Results` chính là điểm phân biệt `TypedResults` với các helper `Results` cũ hơn. Trình biên dịch kiểm tra rằng handler chỉ trả về những kết quả đã khai báo, bộ sinh OpenAPI đọc được cả hai mã trạng thái ngay từ chữ ký hàm, và unit test có thể kiểm tra `result.Result is NotFound` mà không cần khởi chạy server. Endpoint JSON được đặt ngoài nhóm `/blog` để URL của nó không trùng với slug bài viết. Trang bài viết là một component Razor bình thường. `MarkupString` báo cho Razor xuất kết quả của Markdig dưới dạng HTML thay vì mã hóa nó, còn URL canonical lấy từ `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` đi theo cùng mô hình với tham số `Posts` và một vòng lặp qua tiêu đề cùng phần tóm tắt. Đối tượng ẩn danh truyền vào `RazorComponentResult` ánh xạ tên thuộc tính sang tham số của component, vì vậy `new { Post = post }` phải khớp chính xác với tham số `Post`. ## Output caching cho các trang blog ASP.NET Core Output caching, được bổ sung từ ASP.NET Core 7, lưu toàn bộ response trên server rồi phát lại mà không chạy handler hay render lại component. Cơ chế này khác với middleware response caching ra đời trước đó, vốn tuân theo ngữ nghĩa HTTP `Cache-Control` và cho phép client bỏ qua cache bằng header `no-cache`. [Tài liệu output caching trên Microsoft Learn](https://learn.microsoft.com/en-us/aspnet/core/performance/caching/output) mô tả các quy tắc mặc định: chỉ request `GET` và `HEAD` trả về 200 mới được cache, còn response có đặt cookie hoặc đến từ request đã xác thực sẽ bị bỏ qua. Tag là yếu tố khiến output caching phù hợp với một trang nội dung. Mọi endpoint của blog đều mang tag `posts`, và kho bài viết xóa tag đó sau mỗi lần nạp lại. Chính sách cơ sở một giờ chỉ đóng vai trò lưới an toàn; trên thực tế các trang được giữ trong cache cho đến khi nội dung thay đổi. Với triển khai nhiều instance, kho cache trong bộ nhớ là riêng cho từng tiến trình: xóa cache trên một instance vẫn để các instance khác giữ dữ liệu cũ. ASP.NET Core cung cấp kho dựa trên Redis qua gói `Microsoft.AspNetCore.OutputCaching.StackExchangeRedis` và phương thức `AddStackExchangeRedisOutputCache`, giúp chia sẻ mục cache và thao tác xóa giữa các instance. Một instance nhỏ duy nhất thì không cần đến. ## Tạo RSS feed bằng C# với SyndicationFeed Độc giả kỹ thuật vẫn đăng ký theo dõi qua trình đọc feed, và các trang tổng hợp lấy bài mới từ feed chứ không phải từ sitemap. `SyndicationFeed` và `Rss20FeedFormatter` tạo ra feed đúng theo [đặc tả RSS 2.0](https://www.rssboard.org/rss-specification) mà không phải tự viết 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; } } ``` Dựng URL tuyệt đối từ `BlogOptions.SiteUrl` thay vì `HttpContext.Request.Host` giúp chặn lỗ hổng host header injection: nếu không, chỉ một request với giá trị `Host` giả mạo cũng đủ bị cache lại và phục vụ cho mọi người đăng ký với liên kết trỏ sang tên miền khác. Tham số `UTF8Encoding(false)` loại bỏ byte order mark, thứ mà một số trình đọc feed từ chối. ## Triển khai blog kỹ thuật C# và giới hạn của Native AOT Lệnh `dotnet publish -c Release` tạo bản build phụ thuộc framework, chạy được trên mọi máy chủ có runtime .NET 10. Từ .NET 8, SDK còn có thể tạo image container mà không cần Dockerfile: `dotnet publish -c Release /t:PublishContainer` tạo image dựa trên image runtime ASP.NET Core chính thức. Thư mục `posts` có thể đóng gói sẵn trong image (thay đổi nội dung đòi hỏi deploy lại) hoặc mount dưới dạng volume (thay đổi nội dung được file watcher phát hiện). Native AOT hấp dẫn nhờ thời gian khởi động và mức dùng bộ nhớ, nhưng dự án này không phải ứng viên phù hợp. [Bảng tương thích Native AOT của ASP.NET Core](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/native-aot) ghi Minimal APIs ở mức hỗ trợ một phần và Blazor Server không được hỗ trợ, trong khi bộ giải tuần tự mặc định của YamlDotNet dựa vào reflection. Một blog phục vụ trang đã cache từ một tiến trình chạy lâu dài nên thời gian khởi động gần như không đáng kể. Chuyển sang AOT đồng nghĩa với việc thay component Razor bằng template chuỗi và thay YAML bằng front matter JSON sinh mã nguồn, đổi lại lợi ích rất ít. ## Các câu hỏi phỏng vấn .NET mà dự án blog này giúp chuẩn bị Mỗi phần của engine đều gắn với một câu hỏi thường gặp trong phỏng vấn ASP.NET Core. [Bộ câu hỏi phỏng vấn .NET trên SharpSkill](https://sharpskill.dev/vi/technologies/dotnet) đi sâu vào từng chủ đề, và [module Minimal APIs](https://sharpskill.dev/vi/technologies/dotnet/cau-hoi-phong-van/minimal-apis) tập trung vào phía endpoint. **"Một service singleton có an toàn khi nhiều request đọc cùng lúc không?"** Chỉ khi trạng thái của nó bất biến hoặc được đồng bộ hóa. Kho bài viết ở trên dùng snapshot bất biến và phép hoán đổi tham chiếu `volatile`, nên bên đọc không bao giờ khóa và bên ghi không bao giờ chặn bên đọc. Cái bẫy kinh điển là một singleton giữ `List` rồi sửa đổi nó trong lúc nạp lại, dẫn đến `InvalidOperationException` giữa chừng khi duyệt dưới tải cao. [Module dependency injection](https://sharpskill.dev/vi/technologies/dotnet/cau-hoi-phong-van/dependency-injection) cũng đề cập vấn đề captive dependency: một singleton nhận vào service scoped, chẳng hạn `DbContext`, sẽ giữ nó sống suốt vòng đời ứng dụng. **"Output caching và response caching khác nhau thế nào?"** Output caching do server kiểm soát, hỗ trợ tag và xóa chủ động, đồng thời bỏ qua header cache của client. Response caching tuân theo ngữ nghĩa HTTP và chủ yếu là gợi ý cho proxy và trình duyệt. **"Vì sao trả về `TypedResults` thay vì `Results`?"** Kiểu kết quả cụ thể cho phép kiểm tra các kết quả có thể xảy ra ngay lúc biên dịch, tự động sinh metadata OpenAPI và giúp handler kiểm thử được như một phương thức thông thường. Phần so sánh sâu hơn với controller nằm trong bài viết về [kiến trúc và hiệu năng Minimal APIs](https://sharpskill.dev/vi/blog/dotnet/aspnet-core-minimal-apis-architecture-performance-interview). **"Thứ tự middleware quan trọng ở đâu trong ứng dụng này?"** `UseOutputCache` phải được đăng ký trước các endpoint mà nó cache, và sau `UseCors` khi CORS được bật. Ứng viên giải thích thêm được vì sao chính sách mặc định không bao giờ cache request đã xác thực, cũng như một `IOutputCachePolicy` tùy biến cần kiểm tra những gì trước khi cache chúng, sẽ cho thấy hiểu biết thực sự về pipeline thay vì chỉ thuộc lòng thứ tự. ## Xây dựng blog C# với ASP.NET Core: những điểm cần ghi nhớ - Bắt đầu từ `dotnet new web` trên .NET 10 và chỉ thêm Markdig, YamlDotNet cùng `System.ServiceModel.Syndication`; một blog kỹ thuật không cần CMS hay cơ sở dữ liệu. - Phân tích bài viết một lần vào `FrozenDictionary` bất biến và hoán đổi toàn bộ snapshot khi nạp lại, để bên đọc không bao giờ khóa và một file lỗi không bao giờ làm trống trang. - Render HTML bằng `RazorComponentResult` từ handler Minimal API, đồng thời khai báo kiểu trả về `Results` để OpenAPI và unit test thấy mọi kết quả. - Đặt mọi endpoint nội dung sau output caching với một tag chung, rồi gọi `EvictByTagAsync` sau mỗi lần nạp lại thay vì dựa vào thời gian hết hạn ngắn. - Dựng URL canonical và URL feed từ cấu hình, không bao giờ từ header `Host`, và bật `DisableHtml()` cho mọi pipeline render Markdown do người dùng gửi. - Đặt `DOTNET_USE_POLLING_FILE_WATCHER=true` khi thư mục bài viết được mount vào container. - Tận dụng dự án như bài luyện phỏng vấn: sẵn sàng giải thích thành lời về an toàn luồng của singleton, lựa chọn cơ chế cache và thứ tự middleware. --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/vi/blog/dotnet/csharp-blog-aspnet-core-minimal-apis-2026