Theo Dõi Thay Đổi (Change Tracking) trong EF Core: Cơ Chế Hoạt Động và Ý Nghĩa Quan Trọng

Gán product.Price = 120m không làm EF Core ghi SQL. Nó chỉ đánh dấu một entry trong bộ nhớ; đến SaveChanges, EF mới so snapshot và sinh UPDATE cho đúng những cột đã đổi. Hiểu change tracking giải thích cả ba triệu chứng quen thuộc: vì sao query lớn chậm, vì sao sửa entity mà database không đổi, và vì sao ExecuteUpdate làm dữ liệu trong bộ nhớ thành cũ.

Cập nhật 2026

  • EF Core 10 (10.0.14, LTS) giữ nguyên mô hình snapshot; ExecuteUpdateAsync nhận lambda có nhánh if, nhưng vẫn không đi qua change tracker.
  • AsNoTrackingWithIdentityResolution là lựa chọn cho graph read-only cần một instance duy nhất cho mỗi khóa; AsNoTracking thuần có thể trả về nhiều instance của cùng một dòng.
  • EF Core 9+ có ExecuteSql/ExecuteSqlAsync cho SQL tùy ý, cũng bỏ qua tracker và trả về số dòng bị tác động.
  • .NET 8 và .NET 9 hết hỗ trợ ngày 2026-11-10; bài này giả định .NET 10 LTS.

Hai cấu trúc: identity map và snapshot

Identity map nghĩa là trong một DbContext, mỗi cặp (entity type, khóa) chỉ có một instance. Query cùng một dòng hai lần trả về cùng object; Include và relationship fixup dựa vào đó để nối navigation property thay vì tạo bản sao. Đây là lý do bạn không được dùng cùng entity trong hai context: mỗi context có map riêng, và instance của context A không được context B biết đến.

Snapshot nghĩa là khi entity được load, EF lưu bản sao giá trị gốc của từng property ngay trong EntityEntry. Khi SaveChanges, EF so giá trị hiện tại với bản gốc để biết property nào đổi và sinh UPDATE chỉ cho các cột đó. Vì vậy chi phí tracking tỉ lệ với số entity và số property được track, không phải với số dòng bạn sửa.

Mỗi entry có năm phần bạn sẽ dùng khi debug: State, CurrentValues, OriginalValues, Properties, và NavigationEntries. Ba thứ đầu là thứ DebugView in ra:

var entry = db.Entry(product);
Console.WriteLine(entry.State);
Console.WriteLine(db.ChangeTracker.DebugView.LongView);

Năm trạng thái và đường đi của chúng

State Nghĩa SaveChanges làm gì
Added Có trong context, chưa có trong DB INSERT
Unchanged Đang track, không có gì đổi Không làm gì
Modified Đang track, ít nhất một property đổi UPDATE các cột đổi
Deleted Đánh dấu xóa DELETE
Detached Không được track Bỏ qua
await using var db = new CatalogDbContext(options);

var product = await db.Products.FirstAsync(p => p.Id == id);   // Unchanged
product.Price = 120m;                                           // vẫn Unchanged cho tới DetectChanges
db.ChangeTracker.DetectChanges();
Console.WriteLine(db.Entry(product).State);                     // Modified

db.Products.Add(new Product { Id = Guid.NewGuid(), Name = "Mới" }); // Added
await db.SaveChangesAsync(ct);                                  // INSERT + UPDATE
Console.WriteLine(db.Entry(product).State);                     // Unchanged

db.Products.Remove(product);                                    // Deleted
await db.SaveChangesAsync(ct);
Console.WriteLine(db.Entry(product).State);                     // Detached

Hai chi tiết trong đoạn trên hay bị hiểu sai. Thứ nhất, gán property không đổi state ngay; state chỉ thành Modified sau khi DetectChanges chạy — và nó chạy tự động ngay trước SaveChanges. Thứ hai, sau khi SaveChanges thành công, entity Added và Modified trở về Unchanged, còn Deleted trở thành Detached vì dòng không còn tồn tại.

Relationship fixup cũng nằm trong cơ chế này: thêm một Comment vào collection của Post đang được track sẽ khiến entry của comment thành Added và FK được điền. Xóa khỏi collection của quan hệ required có thể đánh dấu con là Deleted; với quan hệ optional, nó chỉ set FK thành NULL. Đây là hành vi cấu hình được bằng OnDelete, không phải quy tắc cố định.

DetectChanges: chi phí ẩn trong mỗi lần lưu

DetectChanges duyệt các entry đang track và so từng property với snapshot. Với vài chục entity, không đáng kể. Với mười nghìn entity trong một context, nó là vòng lặp lớn chạy trước mỗi SaveChanges, mỗi lần gọi ChangeTracker.Entries() hoặc HasChanges(). Đó là lý do context sống lâu và track nhiều dữ liệu chỉ đọc là anti-pattern.

Khi bạn chắc chắn mình kiểm soát được thời điểm phát hiện, có thể tắt tự động:

db.ChangeTracker.AutoDetectChangesEnabled = false;

product.Price = 120m;
db.ChangeTracker.DetectChanges();   // phải gọi tay trước khi lưu
await db.SaveChangesAsync(ct);

Tắt mà quên gọi tay thì SaveChanges không thấy thay đổi và im lặng bỏ qua. Đây là tối ưu chỉ nên dùng trong import job có vòng lặp rõ ràng, không dùng trong request handler thông thường.

Có một giới hạn nữa: property được map qua value converter hoặc một cột JSON, nếu kiểu là reference mutable, EF so sánh tham chiếu trừ khi bạn cấu hình ValueComparer. Sửa nội dung một list hoặc object tại chỗ có thể không được phát hiện, dù snapshot đã cũ. Với primitive collection, EF Core đã có comparer sẵn; với kiểu tự định nghĩa, hãy kiểm tra trước khi tin rằng thay đổi sẽ được lưu.

Đọc: NoTracking, identity resolution, projection

Ba mức chi phí cho cùng một truy vấn đọc:

  • Tracking mặc định. Trả entity, tạo entry, lưu snapshot, chạy identity map. Cần khi bạn sẽ sửa và gọi SaveChanges.
  • AsNoTracking(). Không tạo entry, không snapshot; entity trả về ở trạng thái Detached. Rẻ nhất trong các cách trả entity. Nhược điểm: nếu cùng một dòng xuất hiện nhiều lần trong kết quả Include, bạn nhận nhiều instance khác nhau.
  • AsNoTrackingWithIdentityResolution(). Vẫn detached, nhưng EF dựng graph nội bộ để mỗi khóa chỉ có một instance. Đúng cho graph read-only có navigation, đổi lại chi phí cao hơn AsNoTracking.
// Graph chỉ đọc, cần một instance cho mỗi Post
var posts = await db.Posts
    .AsNoTrackingWithIdentityResolution()
    .Include(p => p.Comments)
    .ToListAsync(ct);

// Chỉ cần vài cột: projection, không track, không materialize entity
var titles = await db.Posts
    .AsNoTracking()
    .Select(p => new PostSummary(p.Id, p.Title, p.Comments.Count))
    .ToListAsync(ct);

Projection sang DTO hoặc kiểu ẩn danh không đi qua tracker dù bạn không gọi AsNoTracking, vì kết quả không phải entity trong model. Đây là cách đọc rẻ nhất và cũng là cách tránh vô tình trả về navigation chưa load.

Nếu toàn bộ context chỉ đọc, đặt mặc định ở cấp context và bật tracking cho từng query cần:

optionsBuilder.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);

var editable = await db.Products.AsTracking().FirstAsync(p => p.Id == id, ct);

Ghi: đường đi không qua tracker

ExecuteUpdateAsync và ExecuteDeleteAsync gửi thẳng SQL xuống database, không load entity, không tạo entry, và trả về số dòng bị tác động:

var affected = await db.Products
    .Where(p => p.Status == ProductStatus.Draft && p.CreatedAt < cutoff)
    .ExecuteUpdateAsync(s => s
        .SetProperty(p => p.Status, ProductStatus.Retired)
        .SetProperty(p => p.Price, p => p.Price > 0 ? p.Price : 0m), ct);

Ba hệ quả phải nhớ. Một: entity đang được track trong cùng context không được cập nhật; nếu bạn đọc lại từ tracker, bạn thấy giá trị cũ. Hai: lệnh chạy ngay lập tức, không nằm trong batch SaveChanges; muốn nguyên tử với thao tác khác thì mở transaction tường minh. Ba: trigger và audit ở database vẫn chạy, vì đây là UPDATE thật — chỉ change tracker của EF là không biết.

ExecuteSql (EF Core 9+) tương tự cho câu SQL không trả dữ liệu. Cùng họ với nó là FromSql, nhưng FromSql vẫn trả entity và vẫn track nếu không gọi AsNoTracking.

ChangeTracker.Clear() tách toàn bộ entry, đưa chúng về Detached. Nó không xóa gì trong database và không thay đổi dữ liệu; nó chỉ làm context “quên” mọi thứ. Dùng sau một lô import lớn, sau khi SaveChanges thất bại giữa chừng, hoặc trước khi nạp lại dữ liệu. Với context lấy từ pool, tracker đã được reset khi trả về pool, nên Clear chỉ cần trong scope sống lâu.

Entity detached: Attach, Update và cập nhật chọn lọc

Trong web app, entity thường được load ở request A, gửi ra client, quay lại ở request B dưới dạng detached. Attach bắt đầu track ở trạng thái Unchanged; Update bắt đầu track ở Modified và đánh dấu tất cả property là đã đổi. Với graph, Update duyệt con: khóa đã có giá trị thì Modified, khóa còn mặc định thì Added.

Vì Update ghi mọi cột, nó có thể đè lên thay đổi của người khác — lost update. Hai cách tránh: cập nhật chọn lọc property, hoặc dùng concurrency token.

var entry = db.Entry(detached);
entry.State = EntityState.Modified;
entry.Property(p => p.Name).IsModified = false;   // không ghi cột Name
entry.Property(p => p.Status).IsModified = true;

await db.SaveChangesAsync(ct);

Cách chặt hơn là thêm rowversion (SQL Server) hoặc cột version, cấu hình IsConcurrencyToken(), và để DbUpdateConcurrencyException báo rằng dữ liệu đã đổi giữa hai request. Không có token thì database không có cách nào biết bạn đang ghi đè dữ liệu cũ.

Hiệu năng: đo, đừng đoán

Ba chi phí của tracking: cấp phát snapshot cho mỗi entity (và mỗi property), dictionary lookup trong identity map, và vòng DetectChanges. Không có con số chung nào đúng cho mọi model — số của người khác không chuyển sang schema của bạn. Hãy đo bằng BenchmarkDotNet 0.15.8 trên dữ liệu thật:

using BenchmarkDotNet.Attributes;

[MemoryDiagnoser]
public class TrackingBenchmarks
{
    private DbContextOptions<CatalogDbContext> _options = null!;

    [GlobalSetup]
    public void Setup() => _options = new DbContextOptionsBuilder<CatalogDbContext>()
        .UseSqlite("Data Source=bench.db")   // file đã có schema và dữ liệu seed
        .Options;

    [Benchmark(Baseline = true)]
    public async Task<int> Tracked()
    {
        await using var db = new CatalogDbContext(_options);
        var rows = await db.Products.ToListAsync();
        return rows.Count;
    }

    [Benchmark]
    public async Task<int> NoTracking()
    {
        await using var db = new CatalogDbContext(_options);
        var rows = await db.Products.AsNoTracking().ToListAsync();
        return rows.Count;
    }

    [Benchmark]
    public async Task<int> Projection()
    {
        await using var db = new CatalogDbContext(_options);
        return await db.Products.AsNoTracking().CountAsync();
    }
}

Chạy dotnet run -c Release, không chạy Debug, và đọc cả Allocated lẫn Mean. Cách diễn giải: nếu chênh lệch thời gian nhỏ nhưng allocation giảm mạnh, AsNoTracking vẫn đáng dùng vì giảm áp lực GC khi tải cao. Nếu truy vấn đi qua network tới database, latency mạng thường lấn át chi phí tracking — tối ưu index và số round trip trước, rồi mới đến tracker.

Bẫy thường gặp

  • Sửa entity load bằng AsNoTracking rồi SaveChanges. Không có gì được ghi; entity đang Detached. Phải Attach/Update, và biết mình đang ghi đè gì.
  • Dùng entity của context khác. Mỗi context có identity map riêng; Attach một instance đang được context khác track sẽ lỗi hoặc tạo trạng thái sai.
  • Track cả bảng để hiển thị. Query 50.000 dòng cho một trang danh sách là 50.000 snapshot không ai dùng. Dùng projection + phân trang.
  • ExecuteUpdate rồi đọc lại từ tracker. Bạn nhận dữ liệu cũ; clear tracker hoặc query lại với AsNoTracking.
  • Update cho DTO đến từ client. Mọi cột bị ghi, kể cả cột client không được phép sửa. Map sang entity đích hoặc chỉ đánh dấu cột hợp lệ là IsModified.
  • Tắt AutoDetectChanges toàn cục. Chỉ tắt trong scope hẹp, có DetectChanges tường minh, và có test cho luồng đó.

Checklist

  • Mọi query chỉ đọc có AsNoTracking hoặc projection; graph có navigation dùng AsNoTrackingWithIdentityResolution.
  • Request handler không giữ context quá một request; job dài tạo scope theo lô và Clear() sau mỗi lô.
  • Cập nhật từ client dùng danh sách cột được phép ghi hoặc concurrency token, không dùng Update mù.
  • ExecuteUpdate/ExecuteDelete chỉ dùng khi không cần entity trong bộ nhớ; sau đó không đọc lại từ tracker.
  • Mọi tối ưu tracker được đo bằng BenchmarkDotNet ở Release trên dữ liệu gần production.

2027

.NET 11 GA tháng 11/2026 (STS), EF Core 11 đi cùng; .NET 12 LTS dự kiến 2027. Mô hình snapshot nhiều khả năng không đổi, nhưng các API ghi trực tiếp như ExecuteUpdate sẽ ngày càng được dùng nhiều hơn cho batch job — nghĩa là kỹ năng quan trọng là biết khi nào cố ý bỏ qua tracker và dọn state sau đó.

Đọc tiếp: EF Core Code-First, EF Core Migrations, và tải dữ liệu liên quan trong EF Core.