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.

Blog C# xây dựng bằng ASP.NET Core Minimal APIs trên .NET 10

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 generatorBlog ASP.NET Core Minimal API
Định dạng nội dungMarkdown + front matterMarkdown + front matter
Thời điểm renderLúc buildRequest đầu tiên, sau đó lưu cache
Logic tùy biếnPlugin, templateEndpoint C# thông thường
HostingHost tĩnh hoặc CDNContainer, App Service, VPS bất kỳ
Cập nhật nội dungBuild và deploy lạiFile 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 để 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.

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

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

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() 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ở.

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

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

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

Kiểu trả về Results<T1, T2> 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<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 đ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.

Sẵn sàng chinh phục phỏng vấn .NET?

Luyện tập với mô phỏng tương tác, flashcards và bài kiểm tra kỹ thuật.

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 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 mà không phải tự viết 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;
    }
}

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 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 đi sâu vào từng chủ đề, và module 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<T> 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 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.

"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> từ handler Minimal API, đồng thời khai báo kiểu trả về Results<T1, T2> để 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.

Bắt đầu luyện tập!

Kiểm tra kiến thức với mô phỏng phỏng vấn và bài kiểm tra kỹ thuật.

Thử thách hôm nay

Bạn có tìm ra lỗi trong .NET không?

Một đoạn mã thật, một lỗi ẩn, mỗi ngày một lượt. Không cần tài khoản để thử.

Anthony Fillion-Maillet

Viết bởi

Anthony Fillion-Maillet

Người sáng lập SharpSkill

Lập trình viên fullstack hơn 10 năm. Anh điều hành SharpSkill và chịu trách nhiệm về mọi nội dung đăng tại đây.

Cập nhật ngày 17 tháng 11, 2026

Thẻ

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

Chia sẻ

Bài viết liên quan