C# / .NET Kompendium PLEN
.NET / C# / Entity Framework Core

Change Tracking w EF Core - wewnętrzny mechanizm

Jak EF Core "wie", co się zmieniło

Gdy pobierasz encję przez śledzony DbContext, EF Core robi snapshot wartości wszystkich właściwości w momencie pobrania:

var order = await _context.Orders.FirstAsync(o => o.Id == 1);
// EF Core zapisuje wewnętrznie: { Id: 1, Status: "Pending", TotalAmount: 100 } jako "original values"

order.Status = "Shipped"; // zmieniasz WŁAŚCIWOŚĆ obiektu w pamięci .NET, NIC więcej

await _context.SaveChangesAsync();
// Change Tracker PORÓWNUJE "current values" z "original values"
// Wykrywa: Status zmienił się z "Pending" na "Shipped"
// Generuje: UPDATE Orders SET Status = 'Shipped' WHERE Id = 1

Stany encji - EntityState

Każda encja śledzona przez DbContext ma jeden z pięciu stanów:

public enum EntityState
{
    Detached,   // nieśledzona - EF Core o niej nie wie
    Unchanged,  // śledzona, bez zmian od pobrania
    Added,      // nowa, do wstawienia (INSERT)
    Modified,   // zmieniona, do aktualizacji (UPDATE)
    Deleted     // oznaczona do usunięcia (DELETE)
}
var order = new Order { CustomerName = "Jan" };
_context.Orders.Add(order);
Console.WriteLine(_context.Entry(order).State); // Added

var existingOrder = await _context.Orders.FirstAsync();
Console.WriteLine(_context.Entry(existingOrder).State); // Unchanged

existingOrder.Status = "Shipped";
Console.WriteLine(_context.Entry(existingOrder).State); // Modified (automatycznie!)

_context.Orders.Remove(existingOrder);
Console.WriteLine(_context.Entry(existingOrder).State); // Deleted

ChangeTracker.DetectChanges() - kiedy faktycznie się wykonuje

To jest szczegół, o który czasem pytają - wykrywanie zmian nie dzieje się w momencie ustawienia właściwości, tylko przy pewnych operacjach:

order.Status = "Shipped"; // NIE od razu wykrywane
// DetectChanges() wywoływane automatycznie przy: SaveChanges(), ChangeTracker.Entries(), niektórych LINQ na DbSet
await _context.SaveChangesAsync(); // TERAZ następuje pełne porównanie snapshot vs current

AsNoTracking() - dlaczego wyłącza to wszystko

var readOnlyOrder = await _context.Orders.AsNoTracking().FirstAsync(o => o.Id == 1);
readOnlyOrder.Status = "Shipped"; // zmiana w PAMIĘCI, ale EF Core o niej NIE WIE

await _context.SaveChangesAsync(); // NIC się nie zapisze - encja nie jest śledzona!

Bez trackingu, EF Core nie robi snapshotu przy pobraniu, więc nie ma z czym porównać aktualnych wartości - stąd AsNoTracking() jest szybsze (mniej pamięci, brak porównywania), ale nie da się przez nią modyfikować i zapisywać zmian.

Attach() - ręczne dołączenie encji z zewnątrz do trackingu

Przydatne, gdy dostajesz obiekt z innego DbContext (np. z warstwy API, po deserializacji z JSON) i chcesz go zaktualizować:

public async Task UpdateOrderAsync(OrderDto dto)
{
    var order = new Order { Id = dto.Id, Status = dto.Status }; // "odłączony" obiekt, nie z tego DbContext

    _context.Orders.Attach(order); // dołącz do trackingu jako Unchanged
    _context.Entry(order).Property(o => o.Status).IsModified = true; // oznacz TYLKO Status jako zmieniony

    await _context.SaveChangesAsync(); // generuje UPDATE tylko dla Status
}

To pozwala precyzyjnie kontrolować, które konkretne pole ma być zaktualizowane, bez pobierania całej encji z bazy najpierw.

Dlaczego to jest ważne dla decyzji class vs record (nawiązanie)

Wracając do wcześniejszej rozmowy o record vs class - to jest właśnie techniczny powód, dla którego encje EF Core prawie zawsze są class z { get; set; }, nie record z { get; init; }:

// ❌ Encja jako record z init-only properties - Change Tracking NIE MA JAK zadziałać
public record Order(int Id, string Status); // init-only - nie da się zmienić po utworzeniu!

var order = await _context.Orders.FirstAsync();
order.Status = "Shipped"; // ❌ Błąd kompilacji - init nie pozwala na set po utworzeniu

Change Tracker wymaga mutowalnych właściwości (set), żeby w ogóle mógł zarejestrować zmianę - to jest fundamentalny konflikt z filozofią niemutowalności record.

Podsumowanie mechanizmu

Change Tracker w EF Core robi snapshot wartości właściwości w momencie pobrania encji przez śledzony DbContext. Przy SaveChangesAsync() (albo innych wywołaniach DetectChanges()) porównuje aktualne wartości właściwości obiektu z tym snapshotem i na tej podstawie generuje odpowiednie UPDATE/INSERT/DELETE. AsNoTracking() wyłącza tworzenie snapshotu (szybsze, ale bez możliwości zapisu zmian), a Attach() pozwala ręcznie dołączyć "odłączony" obiekt (np. z innego kontekstu/warstwy) do trackingu.

Postaw mi kawę