Tải Dữ Liệu Liên Quan trong EF Core: Lazy Loading, Eager Loading & Explicit Loading – Khi Nào Chọn Phương Pháp Nào?

Mặc định EF Core không tải navigation property. Khi bạn viết order.Items trong một vòng lặp, bạn không chỉ đọc bộ nhớ — bạn có thể đang gửi thêm một câu SQL xuống database cho từng dòng. Hiểu rõ bốn cách tải dữ liệu liên quan (lazy, eager, explicit, projection) là cách rẻ nhất để tránh N+1 và giữ API ổn định dưới tải.

Bài này dùng EF Core 10 LTS trên .NET 10, SQL Server, với mô hình Order — OrderItem — Product. Mọi ví dụ chạy được với package Microsoft.EntityFrameworkCore.SqlServer phiên bản 10.0.14.

Cập nhật 2026

  • EF Core 10 là bản LTS (hỗ trợ đến 2028-11-10). Include, filtered Include, ThenInclude, AsSplitQuery và AutoInclude đã ổn định từ nhiều phiên bản trước; không có API tải dữ liệu mới nào thay thế chúng.
  • UseLazyLoadingProxies() vẫn nằm trong package riêng Microsoft.EntityFrameworkCore.Proxies 10.0.14, và vẫn yêu cầu navigation property virtual.
  • Projection sang DTO là mặc định nên chọn cho read path: ít cột hơn, không cần change tracker, không phụ thuộc navigation.
  • EF Core 10 bổ sung vector search và JSON native trên SQL Server 2025, nhưng điều đó không thay đổi quy tắc N+1.

Mô hình và cái bẫy mặc định

// File: Domain/Order.cs
public sealed class Order
{
    public int Id { get; set; }
    public int CustomerId { get; set; }
    public Customer Customer { get; set; } = null!;
    public ICollection<OrderItem> Items { get; set; } = [];
    public DateTime CreatedAt { get; set; }
}

public sealed class OrderItem
{
    public int Id { get; set; }
    public int OrderId { get; set; }
    public Order Order { get; set; } = null!;
    public int ProductId { get; set; }
    public Product Product { get; set; } = null!;
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
}

Khi bạn gọi context.Orders.ToList(), EF Core chỉ đọc bảng Orders. Items là collection rỗng, Customer là null. Đây không phải lỗi cấu hình; đó là thiết kế để tránh tải cả đồ thị object mà bạn không cần. Vấn đề chỉ bắt đầu khi code giả định navigation đã có dữ liệu.

Lazy Loading: tiện lúc viết, trả giá lúc chạy

Lazy loading tạo proxy cho entity. Lần đầu bạn chạm vào navigation, proxy gọi EF Core để nạp dữ liệu. Cần hai điều kiện: bật proxy và khai báo navigation virtual.

// File: Program.cs
builder.Services.AddDbContext<AppDbContext>(options => options
    .UseSqlServer(builder.Configuration.GetConnectionString("Db"))
    .UseLazyLoadingProxies()); // Microsoft.EntityFrameworkCore.Proxies 10.0.14

Giờ đoạn code này chạy đúng nhưng tốn query:

var orders = await context.Orders.ToListAsync(); // 1 query

foreach (var order in orders)
{
    foreach (var item in order.Items)          // N query, mỗi order một lần
    {
        Console.WriteLine($"{order.Id}: {item.Product.Name}"); // thêm M query
    }
}

Với 50 đơn hàng và 3 mặt hàng mỗi đơn, bạn có thể tạo 1 + 50 + 150 query. Đó là N+1, và phiên bản tệ hơn là N+1 lồng nhau. Trong web API, lazy loading còn có hai vấn đề thực tế: proxy chỉ hoạt động khi DbContext còn sống, nên serialize entity sau khi request kết thúc sẽ ném ObjectDisposedException; và vòng lặp serializer có thể kéo theo toàn bộ đồ thị object, gây payload phình hoặc lỗi vòng tham chiếu.

Phát hiện N+1 bằng SQL logging

Đừng đoán. Bật log command của EF Core ở môi trường dev và đếm số câu SELECT cho một request:

optionsBuilder
    .UseSqlServer(connectionString)
    .LogTo(Console.WriteLine, LogLevel.Information)
    .EnableSensitiveDataLogging(); // chỉ bật ở dev

Logger Microsoft.EntityFrameworkCore.Database.Command in ra từng câu SQL và tham số. Một request lấy danh sách 50 đơn chỉ nên có một đến hai câu SELECT; nếu thấy 50 câu giống nhau chỉ khác tham số, bạn đã có N+1. Với môi trường production, dùng OpenTelemetry hoặc profiler của database để đếm round trip thay vì bật sensitive logging.

Eager Loading: một truy vấn, nhưng không miễn phí

Include yêu cầu EF Core tải navigation cùng truy vấn gốc. ThenInclude đi sâu thêm một cấp. Đây là cách chuẩn để tránh N+1 khi bạn biết chắc mình cần dữ liệu liên quan.

var cutoff = DateTime.UtcNow.AddDays(-30);

var orders = await context.Orders
    .AsNoTracking()
    .Include(o => o.Customer)
    .Include(o => o.Items)
        .ThenInclude(i => i.Product)
    .Where(o => o.CreatedAt >= cutoff)
    .AsSplitQuery()
    .ToListAsync();

Ba điều cần nhớ:

  • Include chỉ tải navigation được chỉ định, không tải toàn bộ đồ thị. Nếu Product có Category, bạn phải ThenInclude(i => i.Product).ThenInclude(p => p.Category).
  • AsNoTracking() giảm chi phí change tracker cho read path. Nó không ảnh hưởng đến việc Include có tải dữ liệu hay không.
  • Include trên collection biến truy vấn thành LEFT JOIN. Nếu mỗi đơn có 20 mặt hàng và mỗi mặt hàng có 1 sản phẩm, database trả về 20 dòng cho mỗi đơn; EF Core gộp lại trong bộ nhớ nhưng dữ liệu lặp vẫn đi qua mạng.

Một chi tiết dễ bỏ qua: AsNoTracking() không hợp nhất các instance trùng. Nếu JOIN trả về cùng một Order ở nhiều dòng, bạn có thể nhận nhiều object Order riêng biệt trong kết quả. Khi cần đúng một instance cho mỗi khóa mà vẫn không track, dùng AsNoTrackingWithIdentityResolution(); nó tốn thêm bộ nhớ để giữ bảng ánh xạ identity.

Filtered Include

Bạn có thể lọc ngay trong Include để không tải những dòng không dùng:

var orders = await context.Orders
    .AsNoTracking()
    .Include(o => o.Items.Where(i => i.Quantity > 0))
    .ToListAsync();

Filtered Include hỗ trợ Where, OrderBy, Take và các toán tử LINQ tương đương. Cẩn thận với navigation bắt buộc: nếu bạn lọc bỏ hết item của một order, order đó vẫn được trả về nhưng collection rỗng; đừng dùng filtered Include để thay thế điều kiện lọc ở cấp entity.

AutoInclude: tiện nhưng dễ che giấu chi phí

// File: Infrastructure/AppDbContext.cs
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Order>()
        .Navigation(o => o.Customer)
        .AutoInclude();
}

AutoInclude khiến mọi truy vấn Order đều tải Customer. Nó hữu ích cho navigation nhỏ, gần như luôn cần, nhưng là anti-pattern với collection lớn: mọi truy vấn đều trả giá, kể cả truy vấn chỉ cần Id. Dùng IgnoreAutoInclude() trên từng truy vấn khi cần bỏ qua.

Single query hay split query

Mặc định EF Core dùng một câu SQL cho tất cả Include. Với hai collection trở lên, số dòng là tích của các collection — hiện tượng cartesian explosion. Ví dụ 20 đơn, mỗi đơn 10 item và 5 ghi chú: một câu JOIN có thể trả về 20 × 10 × 5 = 1.000 dòng thay vì 20 + 200 + 100 dòng logic.

AsSplitQuery() chia thành nhiều câu SELECT, mỗi collection một câu, giảm dữ liệu lặp và bộ nhớ tạm. Đổi lại, các câu chạy tuần tự nên không phải một snapshot nhất quán nếu dữ liệu thay đổi giữa các câu; và round trip tăng. Với dữ liệu ít thay đổi hoặc trong một transaction, split query thường là lựa chọn tốt hơn khi có từ hai collection trở lên.

Bạn có thể đặt mặc định toàn cục:

optionsBuilder.UseSqlServer(connectionString, sql =>
    sql.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery));
// Truy vấn cần một câu duy nhất: .AsSingleQuery()

Explicit Loading: kiểm soát có chủ đích

Explicit loading nạp navigation sau khi entity đã được truy vấn, thông qua Entry. Nó hữu ích khi quyết định tải dữ liệu phụ thuộc vào một điều kiện nghiệp vụ, hoặc khi bạn đã có entity trong tay và chỉ cần thêm một phần dữ liệu.

var order = await context.Orders.FirstAsync(o => o.Id == orderId);

// Chỉ tải các item còn hiệu lực, không tải cả collection
await context.Entry(order)
    .Collection(o => o.Items)
    .Query()
    .Where(i => i.Quantity > 0)
    .LoadAsync();

// Reference: kiểm tra IsLoaded trước khi gọi database
var customerEntry = context.Entry(order).Reference(o => o.Customer);
if (!customerEntry.IsLoaded)
{
    await customerEntry.LoadAsync();
}

Query() trả về IQueryable của collection, cho phép lọc và sắp xếp trước khi LoadAsync(). Đây là điểm khác biệt so với Load() trần — vốn tải toàn bộ collection.

Giới hạn: explicit loading cần entity đang được track bởi DbContext còn sống. Nếu bạn gọi nó trong vòng lặp trên 100 entity, bạn tái tạo N+1 với 100 query. Chỉ dùng cho một vài entity, hoặc gom điều kiện thành một truy vấn Include/projection.

Projection: mặc định tốt nhất cho read path

Phần lớn API không cần entity. Nó cần một shape dữ liệu nhỏ. Projection sang DTO vừa tránh N+1 vừa giảm cột, giảm payload và bỏ được change tracker.

// File: Contracts/OrderSummary.cs
public sealed record OrderSummary(
    int Id,
    string CustomerName,
    int LineCount,
    decimal Total);

// File: Features/Orders/GetOrders.cs
var page = await context.Orders
    .AsNoTracking()
    .OrderByDescending(o => o.CreatedAt)
    .Skip((pageNumber - 1) * pageSize)
    .Take(pageSize)
    .Select(o => new OrderSummary(
        o.Id,
        o.Customer.Name,
        o.Items.Count,
        o.Items.Sum(i => i.Quantity * i.UnitPrice)))
    .ToListAsync();

EF Core dịch Count và Sum thành subquery hoặc aggregate trong SQL, không tải toàn bộ Items về bộ nhớ. Bạn không cần Include, không cần lazy loading, và không phụ thuộc việc entity có navigation hay không. Với hot path, cân nhắc EF.CompileAsyncQuery để bỏ chi phí dịch LINQ mỗi lần gọi; chỉ làm sau khi profiling cho thấy đây là điểm nóng.

Bảng quyết định

Tình huống Cách tải Lưu ý
API trả danh sách/chi tiết, chỉ cần vài trường Projection sang DTO Mặc định; AsNoTracking
Cần entity để sửa, biết chắc cần navigation Include + ThenInclude Tránh N+1; cân nhắc split query
Hai collection trở lên hoặc collection lớn Include + AsSplitQuery Không nhất quán giữa các câu nếu dữ liệu đổi
Điều kiện tải phụ thuộc nghiệp vụ, một vài entity Explicit loading Không dùng trong vòng lặp lớn
Desktop app, navigation hiếm khi dùng Lazy loading Vẫn phải đo query; không dùng cho web API

Sai lầm thường gặp

  • Bật lazy loading toàn cục rồi serialize entity. Vừa N+1 vừa payload khổng lồ. Giải pháp: tắt proxy, dùng projection.
  • Include mọi navigation để “cho chắc”. Truy vấn nặng, dữ liệu lặp, và bạn vẫn thiếu navigation cấp sâu nếu không ThenInclude.
  • Dùng Include cho collection rồi Count() trong vòng lặp. Bạn đã tải cả collection chỉ để đếm; dùng projection với Count.
  • Quên AsNoTracking() trên read path. Change tracker giữ entity và snapshot, tốn bộ nhớ không cần thiết.
  • Đo bằng cảm giác. Bật SQL log ở dev, đếm query theo request; tối ưu dựa trên số đo.

2027: không có phép màu, chỉ có ý thức về truy vấn

.NET 11 dự kiến GA tháng 11/2026 (STS) và EF Core 11 đi cùng. Các hướng đang mở rộng là vector search, JSON và compiled model, không phải cơ chế tải navigation mới. Vì vậy kỹ năng đọc SQL sinh ra, đếm round trip và chọn projection vẫn là kỹ năng cốt lõi.

Checklist

  1. Tắt lazy loading trong web API; nếu buộc dùng, giới hạn ở desktop hoặc công cụ nội bộ.
  2. Bật Microsoft.EntityFrameworkCore.Database.Command logging ở dev và đếm query cho một request điển hình.
  3. Mọi endpoint danh sách dùng projection hoặc Include có chủ đích, không dựa vào navigation ngầm.
  4. Khi có từ hai collection, kiểm tra kích thước kết quả và cân nhắc AsSplitQuery.
  5. Thêm test hoặc metric cho số query của các endpoint quan trọng để phát hiện N+1 hồi quy.

Đọc tiếp: Theo dõi thay đổi (Change Tracking) trong EF Core để hiểu vì sao AsNoTracking quan trọng; Làm chủ EF Core Migrations cho phần schema; và Các chiến lược cache trong ASP.NET Core khi read path vẫn quá tải sau khi đã tối ưu truy vấn.