Tìm Hiểu Các Chiến Lược Cache trong ASP.NET Core

Chào mừng các bạn quay trở lại với series “.NET roadmap“! Trong hành trình trở thành một lập trình viên .NET chuyên nghiệp, sau khi đã nắm vững những kiến thức nền tảng về C# (C# Cho Lập Trình Viên ASP.NET Core: Bắt Đầu Từ Đâu?), hiểu về hệ sinh thái .NET (Tìm Hiểu Hệ Sinh Thái .NET: Runtime, SDK, và CLI), làm quen với .NET CLI (Làm Chủ .NET CLI), quản lý mã nguồn với Git (Quản Lý Mã Nguồn với Git), hiểu về HTTP/HTTPS (HTTP và HTTPS: Giải Thích Từ A-Z), nắm vững cấu trúc dữ liệu cơ bản (Cấu Trúc Dữ Liệu) và các công nghệ truy cập dữ liệu như SQL (SQL và Cơ sở dữ liệu quan hệ), Stored Procedures (Stored Procedures, Constraints & Triggers), Entity Framework Core (Bắt Đầu Với Entity Framework Core, Làm Chủ EF Core Migrations, Theo Dõi Thay Đổi trong EF Core, Tải Dữ Liệu Liên Quan trong EF Core, Bộ Nhớ Đệm Cấp Hai trong EF Core, So Sánh EF Core, Dapper, và RepoDB) và NHibernate (Giới thiệu về NHibernate)… Bây giờ là lúc chúng ta khám phá một kỹ thuật cực kỳ quan trọng giúp nâng cao hiệu suất ứng dụng web của mình: Caching.

Trong thế giới ứng dụng web hiện đại, tốc độ là yếu tố then chốt. Người dùng mong đợi các trang web và ứng dụng phản hồi nhanh chóng. Một trong những cách hiệu quả nhất để đạt được điều này là sử dụng caching. Caching giúp lưu trữ tạm thời dữ liệu hoặc kết quả của các yêu cầu tốn kém, để khi cần truy cập lại, chúng ta có thể lấy dữ liệu từ bộ nhớ đệm nhanh hơn nhiều so với việc tính toán lại hoặc truy vấn nguồn dữ liệu gốc (như cơ sở dữ liệu hoặc API bên ngoài).

Caching Là Gì và Tại Sao Lại Quan Trọng?

Hiểu một cách đơn giản, caching là quá trình lưu trữ bản sao của dữ liệu ở một nơi truy cập nhanh hơn. Tưởng tượng bạn cần đọc một cuốn sách dày cộp mỗi lần muốn tra cứu một đoạn thông tin. Caching giống như việc bạn ghi lại những đoạn thông tin quan trọng đó vào một cuốn sổ tay để tra cứu nhanh chóng hơn vào lần sau.

Trong bối cảnh ASP.NET Core, caching giúp:

• Giảm tải cho tài nguyên gốc: Thay vì liên tục truy vấn cơ sở dữ liệu hoặc gọi các dịch vụ bên ngoài, ứng dụng có thể lấy dữ liệu từ cache. Điều này giúp giảm tải cho các hệ thống backend, cải thiện hiệu suất và độ ổn định của chúng.
• Tăng tốc độ phản hồi: Truy cập dữ liệu từ bộ nhớ (RAM) hoặc hệ thống cache chuyên dụng (như Redis) nhanh hơn đáng kể so với việc đọc từ đĩa cứng (cơ sở dữ liệu) hoặc chờ phản hồi từ mạng.
• Cải thiện khả năng mở rộng (Scalability): Với caching, ứng dụng của bạn có thể xử lý nhiều yêu cầu hơn mà không cần mở rộng tài nguyên backend tương ứng.
• Giảm chi phí: Giảm tải cho cơ sở dữ liệu hoặc các dịch vụ trả phí khác có thể giúp tiết kiệm chi phí vận hành.

ASP.NET Core cung cấp nhiều chiến lược caching khác nhau, phù hợp với các nhu cầu và kiến trúc ứng dụng đa dạng. Chúng ta sẽ đi sâu vào ba loại chính: In-Memory Caching, Distributed Caching và Response Caching.

In-Memory Caching: Đơn Giản và Hiệu Quả

In-Memory Caching là chiến lược caching cơ bản nhất trong ASP.NET Core. Nó lưu trữ dữ liệu trực tiếp trong bộ nhớ RAM của ứng dụng web. Đây là lựa chọn tuyệt vời cho các ứng dụng đơn giản hoặc khi bạn chỉ chạy ứng dụng trên một máy chủ duy nhất.

Cách Sử Dụng In-Memory Caching

ASP.NET Core cung cấp interface IMemoryCache để làm việc với In-Memory Caching. Để sử dụng nó, bạn cần đăng ký dịch vụ này trong phương thức ConfigureServices của Startup.cs (hoặc trong Program.cs với .NET 6+):

// Program.cs (.NET 6+)
builder.Services.AddMemoryCache();

// Hoặc Startup.cs (.NET 5 trở xuống)
public void ConfigureServices(IServiceCollection services)
{
    services.AddMemoryCache();
    // ... other services
}

Sau khi đăng ký, bạn có thể inject IMemoryCache vào các service hoặc controller của mình:

public class ProductController : ControllerBase
{
    private readonly IMemoryCache _cache;
    private readonly IProductService _productService; // Giả định có service lấy dữ liệu

    public ProductController(IMemoryCache cache, IProductService productService)
    {
        _cache = cache;
        _productService = productService;
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetProduct(int id)
    {
        string cacheKey = $"product_{id}";

        // 1. Thử lấy dữ liệu từ cache
        if (_cache.TryGetValue(cacheKey, out Product cachedProduct))
        {
            // Dữ liệu có trong cache, trả về ngay
            return Ok(cachedProduct);
        }

        // 2. Dữ liệu không có trong cache, lấy từ nguồn gốc
        var product = await _productService.GetProductByIdAsync(id);

        if (product == null)
        {
            return NotFound();
        }

        // 3. Lưu dữ liệu vào cache với các tùy chọn
        var cacheEntryOptions = new MemoryCacheEntryOptions()
            // Giữ trong cache tối đa 5 phút sau khi được truy cập lần cuối
            .SetSlidingExpiration(TimeSpan.FromMinutes(5))
            // Giữ trong cache tối đa 20 phút, bất kể có được truy cập hay không
            .SetAbsoluteExpiration(TimeSpan.FromMinutes(20));

        _cache.Set(cacheKey, product, cacheEntryOptions);
        // Hoặc dùng CreateEntry/Set như dưới đây, cách này chi tiết hơn
        // using (var entry = _cache.CreateEntry(cacheKey))
        // {
        //     entry.Value = product;
        //     entry.SetSlidingExpiration(TimeSpan.FromMinutes(5));
        //     entry.SetAbsoluteExpiration(TimeSpan.FromMinutes(20));
        //     // Các tùy chọn khác như priority, post eviction callback...
        // }


        // Trả về dữ liệu vừa lấy
        return Ok(product);
    }
}

Trong ví dụ trên, chúng ta sử dụng _cache.TryGetValue() để kiểm tra xem dữ liệu có tồn tại trong cache với khóa cacheKey hay không. Nếu có, chúng ta sử dụng dữ liệu đó. Nếu không, chúng ta lấy dữ liệu từ service gốc, sau đó lưu nó vào cache bằng _cache.Set() (hoặc _cache.CreateEntry()) kèm theo các tùy chọn hết hạn.

Các Tùy Chọn Hết Hạn (Expiration Options) Quan Trọng

• SetAbsoluteExpiration(TimeSpan) hoặc SetAbsoluteExpiration(DateTimeOffset): Dữ liệu sẽ bị xóa khỏi cache sau một khoảng thời gian cố định kể từ lúc được thêm vào, bất kể nó có được truy cập hay không.
• SetSlidingExpiration(TimeSpan): Dữ liệu sẽ bị xóa khỏi cache nếu nó không được truy cập trong khoảng thời gian được chỉ định. Mỗi lần dữ liệu được truy cập, thời gian hết hạn trượt sẽ được reset. Nếu cả Absolute và Sliding Expiration được thiết lập, dữ liệu sẽ hết hạn khi một trong hai điều kiện được thỏa mãn trước.
• SetPriority(CacheItemPriority): Gợi ý cho cache biết mức độ quan trọng của mục dữ liệu, giúp cache quyết định mục nào nên được loại bỏ trước khi bộ nhớ đầy.

Ưu và Nhược Điểm của In-Memory Caching

• Ưu điểm:
  • Đơn giản, dễ cài đặt và sử dụng.
  • Hiệu suất rất cao vì dữ liệu nằm ngay trong bộ nhớ của ứng dụng.
  • Không cần cài đặt thêm dịch vụ bên ngoài.
• Nhược điểm:
  • Không hoạt động hiệu quả trong môi trường phân tán (multiple servers/instances) vì mỗi instance có cache riêng, dẫn đến dữ liệu không nhất quán giữa các server.
  • Dữ liệu cache bị mất khi ứng dụng khởi động lại.
  • Bộ nhớ cache bị giới hạn bởi dung lượng RAM của máy chủ.

In-Memory Caching phù hợp với các ứng dụng web nhỏ đến trung bình, chạy trên một server duy nhất hoặc khi dữ liệu cache không yêu cầu sự nhất quán tuyệt đối trên các instance.

Distributed Caching: Cho Ứng Dụng Mở Rộng

Khi ứng dụng của bạn được triển khai trên nhiều máy chủ (ví dụ: trong môi trường cloud, sử dụng load balancing), In-Memory Caching sẽ gặp vấn đề về nhất quán dữ liệu. Lúc này, Distributed Caching là giải pháp. Distributed Cache là một bộ nhớ cache được chia sẻ bởi nhiều instance của ứng dụng.

ASP.NET Core cung cấp interface IDistributedCache. Không giống như IMemoryCache có sẵn implementation, IDistributedCache là một abstraction, và bạn cần chọn một implementation cụ thể. Các implementation phổ biến nhất là:

• SQL Server Distributed Cache
• Redis Distributed Cache
• NCache (cho môi trường doanh nghiệp)

Trong bài viết này, chúng ta sẽ tập trung vào Redis Distributed Cache vì nó rất phổ biến và hiệu quả.

Sử Dụng Redis Distributed Cache

Redis là một in-memory data structure store, thường được sử dụng làm database, cache, message broker, và queue. Để sử dụng Redis làm distributed cache trong ASP.NET Core, bạn cần cài đặt gói NuGet:

dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis

Sau đó, cấu hình Redis trong Program.cs (hoặc Startup.cs):

// Program.cs (.NET 6+)
builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = "localhost"; // Hoặc chuỗi kết nối tới server Redis của bạn
    options.InstanceName = "SampleInstance"; // Tên tiền tố cho các khóa cache
});

// Hoặc Startup.cs (.NET 5 trở xuống)
public void ConfigureServices(IServiceCollection services)
{
    services.AddStackExchangeRedisCache(options =>
    {
        options.Configuration = "localhost";
        options.InstanceName = "SampleInstance";
    });
    // ... other services
}

Tương tự như In-Memory Cache, bạn inject IDistributedCache vào service hoặc controller:

public class DataController : ControllerBase
{
    private readonly IDistributedCache _cache;
    private readonly IDataService _dataService; // Giả định có service lấy dữ liệu

    public DataController(IDistributedCache cache, IDataService dataService)
    {
        _cache = cache;
        _dataService = dataService;
    }

    [HttpGet("{key}")]
    public async Task<IActionResult> GetData(string key)
    {
        string cacheKey = $"data_{key}";

        // 1. Thử lấy dữ liệu từ cache
        string cachedDataString = await _cache.GetStringAsync(cacheKey);

        if (!string.IsNullOrEmpty(cachedDataString))
        {
            // Dữ liệu có trong cache, deserial hóa và trả về
            // Lưu ý: IDistributedCache làm việc với byte array, thường cần serialize/deserialize
            var cachedData = JsonConvert.DeserializeObject<MyComplexDataType>(cachedDataString);
            return Ok(cachedData);
        }

        // 2. Dữ liệu không có trong cache, lấy từ nguồn gốc
        var data = await _dataService.GetComplexDataAsync(key);

        if (data == null)
        {
            return NotFound();
        }

        // 3. Serialize dữ liệu và lưu vào cache
        string dataString = JsonConvert.SerializeObject(data);
        var options = new DistributedCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromMinutes(10))
            .SetAbsoluteExpiration(TimeSpan.FromHours(1));

        await _cache.SetStringAsync(cacheKey, dataString, options);

        // Trả về dữ liệu vừa lấy
        return Ok(data);
    }
}

// Cần cài gói Newtonsoft.Json hoặc System.Text.Json
// dotnet add package Newtonsoft.Json

Điểm khác biệt chính khi làm việc với IDistributedCache là nó lưu trữ dữ liệu dưới dạng mảng byte (byte[]). Do đó, bạn thường cần tự thực hiện việc chuyển đổi (serialize) đối tượng của mình thành byte[] hoặc string (và ngược lại deserialize) khi lưu và lấy dữ liệu. Các extension method như GetStringAsync, SetStringAsync giúp làm việc dễ dàng hơn với string, thường sử dụng JSON để serialize.

Các Phương Thức Quan Trọng của IDistributedCache

• GetAsync(string key): Lấy dữ liệu dưới dạng byte[].
• GetStringAsync(string key): Lấy dữ liệu dưới dạng string.
• SetAsync(string key, byte[] value, DistributedCacheEntryOptions options): Lưu dữ liệu dưới dạng byte[].
• SetStringAsync(string key, string value, DistributedCacheEntryOptions options): Lưu dữ liệu dưới dạng string.
• RefreshAsync(string key): Làm mới thời gian hết hạn trượt (sliding expiration) cho một mục cache.
• RemoveAsync(string key): Xóa một mục khỏi cache.

Ưu và Nhược Điểm của Distributed Caching

• Ưu điểm:
  • Nhất quán dữ liệu trên nhiều instance của ứng dụng.
  • Dữ liệu cache vẫn tồn tại khi ứng dụng khởi động lại.
  • Khả năng mở rộng cao (Redis có thể chạy trên các server riêng).
• Nhược điểm:
  • Phức tạp hơn để cài đặt và quản lý (yêu cầu dịch vụ cache riêng như Redis hoặc SQL Server).
  • Hiệu suất có thể thấp hơn In-Memory Caching một chút do cần truyền dữ liệu qua mạng và serialize/deserialize.
  • Cần quan tâm đến việc serialize/deserialize dữ liệu.

Distributed Caching là lựa chọn tiêu chuẩn cho các ứng dụng web production, chạy trên môi trường cloud hoặc có yêu cầu mở rộng theo chiều ngang (horizontal scaling).

Response Caching: Cache Kết Quả Toàn Bộ Request

Thay vì cache từng phần dữ liệu, Response Caching cho phép bạn cache toàn bộ response HTTP cho một request cụ thể. Khi một request tương tự đến lần sau, middleware Response Caching sẽ trả về response đã được cache mà không cần xử lý request đó trong pipeline ứng dụng.

Response Caching phù hợp với các tài nguyên tĩnh hoặc các API endpoint mà dữ liệu ít thay đổi và giống nhau cho tất cả người dùng (ví dụ: danh sách sản phẩm, tin tức chung…).

Cấu Hình Response Caching

Để sử dụng Response Caching, bạn cần:

1. Thêm dịch vụ Response Caching:

// Program.cs (.NET 6+)
builder.Services.AddResponseCaching();

// Hoặc Startup.cs (.NET 5 trở xuống)
public void ConfigureServices(IServiceCollection services)
{
    services.AddResponseCaching();
    // ... other services
}

2. Thêm middleware Response Caching vào pipeline xử lý request:

// Program.cs (.NET 6+)
app.UseResponseCaching();
app.MapControllers(); // Đảm bảo middleware nằm trước MapControllers hoặc UseEndpoints

// Hoặc Startup.cs (.NET 5 trở xuống)
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // ... other middleware
    app.UseResponseCaching();
    // ... app.UseRouting(), app.UseEndpoints()
}

3. Áp dụng attribute [ResponseCache] lên controller hoặc action method:

[ApiController]
[Route("[controller]")]
public class ContentController : ControllerBase
{
    // Cache response cho action này trong 60 giây
    // Cache được lưu ở Client (Browser) và Shared Cache (Proxy Server)
    [HttpGet("latest-news")]
    [ResponseCache(Duration = 60, Location = ResponseCacheLocation.Any)]
    public IActionResult GetLatestNews()
    {
        // Giả định lấy tin tức mới nhất
        var news = new { Title = "Tin mới nhất", Content = "Nội dung tin tức...", Timestamp = DateTime.UtcNow };
        return Ok(news);
    }

    // Cache response cho action này trong 5 phút
    // Cache chỉ được lưu ở Client (Browser)
    [HttpGet("user-profile/{userId}")]
    [ResponseCache(Duration = 300, Location = ResponseCacheLocation.Client, NoStore = false)]
    public IActionResult GetUserProfile(int userId)
    {
        // Giả định lấy profile người dùng (dữ liệu có thể thay đổi theo user)
        // Cần cẩn thận khi cache dữ liệu theo user, thường ResponseCacheLocation.Client là an toàn nhất
        var profile = new { UserId = userId, Name = $"User {userId}", LastLogin = DateTime.UtcNow };
        return Ok(profile);
    }

    // Cache response phụ thuộc vào query string parameter 'category' và header 'Accept-Language'
    [HttpGet("products")]
    [ResponseCache(Duration = 180, Location = ResponseCacheLocation.Any, VaryByQueryKeys = new[] { "category" }, VaryByHeader = "Accept-Language")]
    public IActionResult GetProductsByCategory([FromQuery] string category)
    {
        // Giả định lấy danh sách sản phẩm theo danh mục và ngôn ngữ
        var products = new { Category = category, Language = Request.Headers["Accept-Language"].ToString(), Items = new[] { $"Product A in {category}", $"Product B in {category}" } };
        return Ok(products);
    }
}

Các thuộc tính chính của [ResponseCache]:

• Duration: Thời gian (tính bằng giây) response được cache.
• Location: Chỉ định nơi response có thể được cache.
  • Any: Cache ở Client và Proxy Server (Shared Cache). Thêm header Cache-Control: public,max-age=....
  • Client: Chỉ cache ở Client (Browser). Thêm header Cache-Control: private,max-age=....
  • None: Không cache ở bất kỳ đâu. Thêm header Cache-Control: no-cache,no-store.
• NoStore: Nếu true, bỏ qua mọi cơ chế cache khác và thêm header Cache-Control: no-store.
• VaryByHeader: Cache response dựa trên giá trị của một hoặc nhiều header request (ví dụ: “Accept-Language”, “User-Agent”).
• VaryByQueryKeys: Cache response dựa trên giá trị của một hoặc nhiều query string parameter (ví dụ: “category”, “page”). Sử dụng “*” để cache theo tất cả query string parameters.

Response Caching hoạt động bằng cách thêm các header HTTP Cache-Control vào response. Đây là một kỹ thuật caching ở lớp HTTP, không phải caching dữ liệu bên trong logic ứng dụng.

Ưu và Nhược Điểm của Response Caching

• Ưu điểm:
  • Rất hiệu quả cho các response giống nhau cho mọi người dùng.
  • Dễ dàng áp dụng bằng attribute.
  • Hỗ trợ caching ở nhiều cấp độ (Client, Proxy Server).
• Nhược điểm:
  • Chỉ cache toàn bộ response, không thể cache từng phần dữ liệu.
  • Không phù hợp với dữ liệu cá nhân hóa hoặc thường xuyên thay đổi.
  • Việc vô hiệu hóa cache có thể phức tạp hơn (phụ thuộc vào thời gian hết hạn).
  • Theo mặc định, Response Caching chỉ hỗ trợ In-Memory cache. Để sử dụng Distributed Cache cho Response Caching, bạn cần cấu hình thêm hoặc sử dụng thư viện bên thứ ba.

So Sánh Các Chiến Lược Caching

Để giúp bạn dễ dàng lựa chọn chiến lược phù hợp, đây là bảng so sánh các đặc điểm chính:

Lựa Chọn Chiến Lược Phù Hợp và Các Lưu Ý

Việc lựa chọn chiến lược caching phụ thuộc vào:

• Kiến trúc ứng dụng: Ứng dụng chạy trên một server hay nhiều server? Có sử dụng load balancer không?
• Loại dữ liệu cần cache: Dữ liệu có thay đổi thường xuyên không? Dữ liệu có cá nhân hóa cho từng người dùng không? Kích thước dữ liệu như thế nào?
• Yêu cầu về nhất quán dữ liệu: Dữ liệu cache có cần phải giống hệt nhau trên mọi instance của ứng dụng tại mọi thời điểm không?
• Ngân sách và nguồn lực: Bạn có sẵn sàng cài đặt và quản lý một dịch vụ cache độc lập như Redis không?

Thường thì, các ứng dụng production lớn sẽ sử dụng kết hợp các chiến lược này:

• Distributed Caching cho các đối tượng dữ liệu quan trọng, cần chia sẻ và nhất quán giữa các server (ví dụ: session data, kết quả truy vấn database phức tạp, dữ liệu cấu hình…).
• Response Caching cho các endpoint công cộng, ít thay đổi (ví dụ: danh sách sản phẩm, bài viết, trang chủ…).
• In-Memory Caching cho các dữ liệu rất nhỏ, chỉ cần cache trong phạm vi một request hoặc một service duy nhất, hoặc trong các ứng dụng nhỏ, đơn giản.

Các Lưu Ý Quan Trọng:

• Vô hiệu hóa Cache (Cache Invalidation): Caching chỉ hữu ích khi dữ liệu trong cache còn “fresh” (tức là không quá cũ so với nguồn gốc). Bạn cần có chiến lược để vô hiệu hóa cache khi dữ liệu nguồn thay đổi. Điều này có thể là xóa mục cache cụ thể (manual removal), sử dụng dependency-based expiration (khi dữ liệu phụ thuộc thay đổi), hoặc dựa vào thời gian hết hạn (expiration).
• Cache Stampede: Xảy ra khi một mục cache hết hạn và nhiều request cùng lúc cố gắng tính toán lại dữ liệu nguồn. Điều này có thể gây áp lực lớn lên backend. Cần có kỹ thuật để xử lý (ví dụ: locking để chỉ cho phép một request tính toán lại, các request khác chờ).
• Serialization: Với Distributed Caching, đảm bảo đối tượng của bạn có thể serialize và deserialize đúng cách (thường dùng JSON). Cân nhắc kích thước dữ liệu khi serialize.
• Monitoring: Theo dõi hiệu suất cache (tỷ lệ hit/miss) là rất quan trọng để hiểu caching có đang mang lại lợi ích hay không.

Kết Luận

Caching là một kỹ thuật mạnh mẽ và không thể thiếu để xây dựng các ứng dụng ASP.NET Core hiệu suất cao và có khả năng mở rộng. Bằng cách hiểu rõ các chiến lược In-Memory, Distributed và Response Caching, cùng với ưu nhược điểm của từng loại, bạn có thể đưa ra quyết định sáng suốt về việc áp dụng caching vào ứng dụng của mình.

Việc nắm vững caching là một bước tiến quan trọng trên Lộ trình học ASP.NET Core 2025 của bạn. Hãy bắt đầu thử nghiệm với các chiến lược này trong các dự án nhỏ và dần áp dụng chúng vào các ứng dụng lớn hơn. Hiệu suất ứng dụng của bạn chắc chắn sẽ được cải thiện đáng kể!

Hẹn gặp lại các bạn trong các bài viết tiếp theo của series!