EF Core không có bộ nhớ đệm cấp hai. Không có thuộc tính nào trong DbContextOptionsBuilder bật nó, và UseSecondLevelCache() mà bạn thấy trên blog thường đến từ một package bên thứ ba. Nhầm tưởng này dẫn đến hai lỗi thực tế: tin rằng DbContext đã cache query (nó không làm vậy), và bật một query cache mà không có chiến lược vô hiệu hóa.
Bài này chỉ rõ L1 và L2 khác nhau ở đâu, cách EFCoreSecondLevelCacheInterceptor 5.6.0 hoạt động trên EF Core 10, các điểm làm cache sai dữ liệu, và khi nào nên dùng HybridCache hoặc output caching thay vì query cache.
Mục lục
Cập nhật 2026
- EF Core 10 LTS (10.0.14) vẫn không tích hợp L2 cache. Cơ chế mở rộng chính thức là interceptor; L2 là quyết định của ứng dụng, không phải của ORM.
EFCoreSecondLevelCacheInterceptor5.6.0 đã tách provider thành package riêng:.MemoryCache,.StackExchange.Redis,.HybridCache,.FusionCache. Bản 5.6.0 có targetnet10.0và phụ thuộc EF Core 10.0.0.Microsoft.Extensions.Caching.Hybrid10.11.0 là abstraction cache ổn định: L1 trong process, L2 phân tán, chống stampede, hỗ trợ tag để invalidate.- Output caching và rate limiting là middleware sẵn có trong ASP.NET Core 10; không cần package ngoài.
L1 không phải query cache
“Bộ nhớ đệm cấp một” của EF Core là change tracker — một identity map theo DbContext. Nó bảo đảm mỗi khóa chỉ có một instance entity được track, và giữ snapshot để phát hiện thay đổi khi SaveChanges().
var first = await context.Products.FirstOrDefaultAsync(p => p.Id == 1);
var second = await context.Products.FirstOrDefaultAsync(p => p.Id == 1);
Console.WriteLine(ReferenceEquals(first, second)); // True
Điểm quan trọng: lần gọi thứ hai vẫn gửi SQL xuống database. EF Core thực thi truy vấn, nhận kết quả, nhưng trả về instance đã track thay vì tạo object mới. Vì vậy L1 không giảm round trip; nó chỉ giảm số instance và giữ tính nhất quán trong một unit of work. Khi DbContext bị dispose — cuối request — toàn bộ identity map biến mất.
L2 là thứ khác: cache kết quả của command, nằm ngoài DbContext, dùng chung giữa các request và có thể giữa các instance ứng dụng. Nó bỏ qua database thật sự, nên mới có chuyện nhanh hơn và mới có rủi ro dữ liệu cũ.
Cách interceptor hoạt động
SecondLevelCacheInterceptor chặn command của EF Core. Trước khi command chạy, nó tính cache key từ SQL đã sinh và giá trị tham số, tra cache. Nếu hit, nó trả về tập dòng đã lưu và bỏ qua database. Nếu miss, command chạy bình thường, kết quả được serialize vào cache kèm dependency theo tên bảng.
Vì cache là query cache, nó lưu kết quả tabular chứ không lưu entity graph. Lần hit, EF Core materialize lại entity từ dữ liệu cache; bạn không nhận được cùng instance như L1. Điều này cũng có nghĩa navigation không được “cache kèm”: nếu query không Include, cache cũng không tự có navigation.
Cấu hình với memory cache
dotnet add package EFCoreSecondLevelCacheInterceptor --version 5.6.0
dotnet add package EFCoreSecondLevelCacheInterceptor.MemoryCache --version 5.6.0
// File: Program.cs
using EFCoreSecondLevelCacheInterceptor;
builder.Services.AddEFSecondLevelCache(options =>
{
options.UseMemoryCacheProvider()
.UseCacheKeyPrefix("catalog-api:")
.ConfigureLogging(builder.Environment.IsDevelopment());
});
builder.Services.AddDbContext<AppDbContext>((sp, options) =>
{
options.UseSqlServer(builder.Configuration.GetConnectionString("Db"))
.AddInterceptors(sp.GetRequiredService<SecondLevelCacheInterceptor>());
});
Memory provider chỉ có tác dụng trong một process. Nếu bạn chạy ba instance API sau load balancer, mỗi instance có cache riêng và tỷ lệ hit chia nhỏ; dùng Redis khi cần chia sẻ.
Cấu hình với Redis
dotnet add package EFCoreSecondLevelCacheInterceptor.StackExchange.Redis --version 5.6.0
// File: Program.cs
using StackExchange.Redis;
var redis = new ConfigurationOptions
{
EndPoints = { { "127.0.0.1", 6379 } },
AbortOnConnectFail = false,
ConnectTimeout = 5_000
};
builder.Services.AddEFSecondLevelCache(options =>
options.UseStackExchangeRedisCacheProvider(redis, TimeSpan.FromMinutes(10))
.UseCacheKeyPrefix("catalog-api:")
.UseDbCallsIfCachingProviderIsDown(TimeSpan.FromMinutes(1)));
UseDbCallsIfCachingProviderIsDown là lựa chọn quan trọng: khi Redis lỗi, ứng dụng đi thẳng xuống database thay vì trả 500. Đổi lại, database có thể bị sốc nếu cache vừa mất. Hãy chắc rằng connection pool và timeout đủ cho tình huống đó.
Đánh dấu query nào được cache
var products = await context.Products
.AsNoTracking()
.Where(p => p.IsActive)
.OrderBy(p => p.Name)
.Cacheable(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(10))
.ToListAsync();
Cacheable() đánh dấu từng query; NotCacheable() loại trừ query khỏi chính sách toàn cục. Nếu muốn mọi query đều cache, dùng CacheAllQueries(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(5)) — nhưng đây là cách nhanh nhất để cache cả dữ liệu per-user và làm cache phình. Với API nhiều endpoint, hãy chọn danh sách query được cache thay vì bật toàn cục.
Bạn cũng có thể giới hạn theo bảng:
options.CacheQueriesContainingTableNames(
CacheExpirationMode.Absolute,
TimeSpan.FromMinutes(30),
TableNameComparison.ContainsOnly,
"products", "categories");
Invalidation và dữ liệu cũ
Interceptor tự động vô hiệu hóa các entry phụ thuộc vào bảng bị thay đổi khi bạn gọi SaveChanges()/SaveChangesAsync(). Đây là điểm mạnh so với cache tự viết: không cần nhớ xóa key thủ công ở mọi chỗ ghi.
Nhưng có ba lỗ hổng thực tế:
ExecuteUpdateAsync/ExecuteDeleteAsynckhông kích hoạt invalidation. Chúng chạy thẳng xuống database, bỏ qua change tracker và interceptor. Sau khi bulk update, cache vẫn trả dữ liệu cũ đến hết TTL.- Ghi từ hệ thống khác không được biết. Job ETL, service khác, hoặc người sửa trực tiếp database sẽ không làm cache mất hiệu lực. Khi đó TTL là biên duy nhất.
- Cache không phải transaction. Hai request đọc cùng lúc có thể thấy hai phiên bản dữ liệu khác nhau; không có snapshot cách ly như database transaction.
await context.Products
.Where(p => p.IsArchived)
.ExecuteUpdateAsync(s => s.SetProperty(p => p.IsActive, false));
// Bắt buộc: interceptor không thấy thao tác này
cacheService.ClearAllCachedEntries();
IEFCacheServiceProvider còn có InvalidateCacheDependencies(new EFCacheKey(...)) để xóa theo bảng, nhưng tên bảng phải khớp convention nội bộ của interceptor (kể cả prefix). Nếu không chắc, ClearAllCachedEntries() an toàn hơn về mặt đúng đắn, đổi lại hit rate giảm.
Thiết kế cache key và an toàn đa tenant
Key mặc định là hash của command text + tham số. Hệ quả:
- Cùng một query logic với tham số khác nhau là entry khác nhau. Điều này đúng cho
Where(p => p.CategoryId == id). Skip/Takenằm trong key, nên mỗi trang là một entry. Phân trang sâu tạo nhiều entry và hit rate thấp; cache trang đầu thay vì cache mọi trang.TagWith("...")thêm comment vào SQL, do đó thay đổi key. Dùng tag để vận hành và debug, không dùng để “tách” tenant một cách tình cờ.
Với multi-tenant, có hai tình huống rất khác nhau:
| Tình huống | Rủi ro | Cách xử lý |
|---|---|---|
Chung database, global query filter theo TenantId |
Thấp: TenantId nằm trong SQL nên key khác nhau |
Giữ filter ở mọi entity; test rò rỉ chéo tenant |
| Mỗi tenant một database, cùng schema | Cao: SQL giống nhau, key giống nhau | Prefix theo tenant hoặc cache/provider riêng cho từng tenant |
Với trường hợp mỗi tenant một database, đừng chỉ đổi connection string rồi dùng chung một interceptor. Hãy đăng ký DbContext và interceptor theo tenant (DI keyed service hoặc một scope riêng), hoặc dùng provider động chọn cache database theo tenant như tài liệu của thư viện. Nếu không, tenant A có thể nhận dữ liệu của tenant B — đây là lỗi bảo mật, không chỉ là lỗi hiệu năng.
Khi nào không nên dùng L2
- Dữ liệu thay đổi mỗi request hoặc cần đúng tức thời: số dư, tồn kho đang giữ, trạng thái thanh toán. TTL ngắn vẫn có cửa sổ sai.
- Query per-user: key cardinality tăng theo số user, cache thành bộ nhớ tạm của mọi người và hit rate gần 0.
- Kết quả lớn: cache 10.000 dòng chỉ để một request dùng là lãng phí RAM và tăng chi phí serialize.
- Query không xác định:
NEWID(),GETDATE(), random sampling. Cùng SQL có thể trả kết quả khác nhau; dùngSkipCachingCommandsđể loại. - Team chưa có chiến lược đo hit rate và TTL: bật cache mà không quan sát còn tệ hơn không bật.
So với HybridCache và output caching
Ba thứ này giải quyết ba bài toán khác nhau, không thay thế nhau:
| Cơ chế | Cache gì | Phù hợp khi |
|---|---|---|
| L2 query cache (interceptor) | Kết quả command theo SQL + tham số | Nhiều query đọc giống nhau, ít ghi, muốn trong suốt với code EF |
HybridCache |
Giá trị/DTO theo key do bạn đặt, L1 + L2, chống stampede | Read path đã có DTO rõ ràng, cần kiểm soát key và tag |
| Output caching | Toàn bộ HTTP response | Endpoint GET ít phụ thuộc user, có thể chấp nhận cache ở tầng HTTP |
// HybridCache: cache DTO, không cache query
builder.Services.AddHybridCache(options =>
{
options.DefaultEntryOptions = new HybridCacheEntryOptions
{
Expiration = TimeSpan.FromMinutes(10),
LocalCacheExpiration = TimeSpan.FromMinutes(1)
};
});
var catalog = await hybridCache.GetOrCreateAsync(
$"catalog:{categoryId}",
async ct => await db.Products
.AsNoTracking()
.Where(p => p.CategoryId == categoryId && p.IsActive)
.Select(p => new ProductDto(p.Id, p.Name, p.Price))
.ToListAsync(ct),
tags: ["catalog"],
cancellationToken: ct);
HybridCache phù hợp hơn L2 khi bạn đã projection sang DTO: key do bạn kiểm soát, tag cho phép RemoveByTagAsync("catalog") sau khi nhập liệu, và không phụ thuộc hình dạng SQL. Ngược lại, nó không tự động bắt mọi query như interceptor; bạn phải sửa read path.
// Output caching: tầng HTTP, không cache theo user
builder.Services.AddOutputCache(options =>
options.AddBasePolicy(policy => policy.Expire(TimeSpan.FromSeconds(30))));
app.UseOutputCache();
app.MapGet("/catalog/{categoryId:int}", async (int categoryId, CatalogService service, CancellationToken ct) =>
Results.Ok(await service.GetAsync(categoryId, ct)))
.CacheOutput(policy => policy.Expire(TimeSpan.FromMinutes(1)).SetVaryByQuery("page"));
Output caching không biết dữ liệu trong database đã đổi; nó chỉ hết hạn theo thời gian. Đừng dùng nó cho endpoint trả dữ liệu riêng của user hoặc dữ liệu cần chính xác sau khi ghi.
Đo hiệu quả thay vì tin cảm giác
Sau khi bật cache, đo ba thứ: số command SQL xuống database mỗi phút, P95 latency của read path, và tỷ lệ hit. Nếu hit rate dưới khoảng 50% ở một query bạn cho là ít đổi, nguyên nhân thường là tham số quá đa dạng hoặc TTL quá ngắn — tăng TTL không cứu được. Đo trên cùng mức tải trước và sau, đừng so cache bật với cache tắt ở hai thời điểm khác nhau. Nếu cache không giảm round trip thật, hãy tắt: một lớp cache không ai theo dõi chỉ thêm độ trễ khó debug.
2027: đừng chờ L2 native
.NET 11 (GA dự kiến tháng 11/2026, STS) và tiếp tục mở rộng truy vấn vector/JSON, không có tín hiệu tích hợp L2 vào core. Hướng đi hợp lý là: projection + HybridCache cho read path do bạn kiểm soát, interceptor cho query cũ cần cache nhanh, output caching cho endpoint HTTP công khai. Mỗi lớp có TTL và cách vô hiệu hóa riêng; đừng trộn chúng mà không biết entry nào đang phục vụ request.
Checklist
- Xác nhận bạn không nhầm L1 với query cache: bật SQL logging và kiểm tra lần đọc thứ hai vẫn có command.
- Chỉ cache query đọc, ít thay đổi, kết quả nhỏ; bắt đầu bằng danh sách bảng cụ thể thay vì
CacheAllQueries. - Đặt TTL ngắn hơn mức độ chấp nhận dữ liệu cũ của nghiệp vụ, và ghi lại con số đó trong tài liệu.
- Sau mọi
ExecuteUpdate/ExecuteDeletehoặc job ghi ngoài, chủ động invalidate. - Nếu chạy nhiều instance, dùng Redis; nếu multi-tenant, kiểm tra key không va chạm giữa tenant.
- Đo hit rate, memory và độ trễ trước/sau; nếu hit rate thấp, tắt cache thay vì tăng TTL mù quáng.
Đọc tiếp: Change Tracking trong EF Core để nắm L1; Các chiến lược cache trong ASP.NET Core để đặt L2 vào bức tranh tổng thể; và Sử dụng Redis trong ASP.NET Core cho phần hạ tầng cache phân tán.



