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

Transakcje i poziomy izolacji w EF Core

SaveChangesAsync() - domyślna transakcja "za darmo"

_context.Orders.Add(newOrder);
_context.Customers.Update(customer);
await _context.SaveChangesAsync();
// EF Core AUTOMATYCZNIE owija WSZYSTKIE zmiany z tego wywołania w JEDNĄ transakcję SQL
// Jeśli COKOLWIEK zawiedzie - WSZYSTKO jest wycofane (rollback), nic częściowo nie zapisze

To jest ważny fakt - nie musisz ręcznie zarządzać transakcją dla pojedynczego SaveChangesAsync(), nawet jeśli modyfikujesz wiele różnych tabel naraz - EF Core robi to automatycznie.

Kiedy potrzebujesz jawnej transakcji - wiele SaveChangesAsync() w jednej operacji

public async Task TransferFundsAsync(int fromAccountId, int toAccountId, decimal amount)
{
    using var transaction = await _context.Database.BeginTransactionAsync();
    try
    {
        var fromAccount = await _context.Accounts.FindAsync(fromAccountId);
        fromAccount.Balance -= amount;
        await _context.SaveChangesAsync(); // pierwszy zapis

        var toAccount = await _context.Accounts.FindAsync(toAccountId);
        toAccount.Balance += amount;
        await _context.SaveChangesAsync(); // drugi zapis

        await transaction.CommitAsync(); // OBA zapisy zatwierdzone RAZEM
    }
    catch
    {
        await transaction.RollbackAsync(); // OBA zapisy wycofane, jeśli cokolwiek zawiedzie
        throw;
    }
}

Bez jawnej transakcji, gdyby drugi SaveChangesAsync() zawiódł (np. błąd sieci do bazy), pierwszy zapis już by został zapisany - konto źródłowe miałoby odjęte pieniądze, a docelowe by ich nie dostało. Jawna transakcja gwarantuje atomowość całej operacji.

Savepoints - częściowy rollback wewnątrz transakcji

using var transaction = await _context.Database.BeginTransactionAsync();

await _context.SaveChangesAsync(); // pierwsza operacja
await transaction.CreateSavepointAsync("AfterFirstStep");

try
{
    await SomeRiskyOperationAsync(); // np. wywołanie zewnętrznego serwisu
    await _context.SaveChangesAsync();
}
catch
{
    await transaction.RollbackToSavepointAsync("AfterFirstStep"); // wycofaj TYLKO ryzykowną część
    // pierwsza operacja NADAL jest zachowana w transakcji
}

await transaction.CommitAsync();

To przydatne, gdy jedna transakcja ma kilka etapów, z których tylko część jest ryzykowna - nie musisz wycofywać wszystkiego, tylko fragment po ostatnim bezpiecznym punkcie.

Poziomy izolacji transakcji (Isolation Levels)

using var transaction = await _context.Database.BeginTransactionAsync(IsolationLevel.Serializable);
Poziom Co gwarantuje Koszt wydajnościowy
ReadUncommitted Może czytać niezatwierdzone zmiany innych transakcji ("dirty read") Najniższy
ReadCommitted (domyślny w SQL Server) Czyta tylko zatwierdzone dane, ale mogą się zmienić między odczytami w tej samej transakcji Niski
RepeatableRead Te same wiersze dają ten sam wynik przy wielokrotnym odczycie w transakcji Średni
Serializable Pełna izolacja - transakcje zachowują się jakby wykonywały się jedna po drugiej Najwyższy (najwięcej blokad, ryzyko deadlocków)

Praktyczna reguła: wyższy poziom izolacji = więcej bezpieczeństwa przed anomaliami współbieżności, ale więcej blokad i mniejszy throughput pod dużym obciążeniem. Domyślny ReadCommitted wystarcza w większości scenariuszy biznesowych; Serializable rezerwuje się dla operacji finansowych/krytycznych, gdzie nawet rzadka anomalia jest niedopuszczalna.

Concurrency Conflicts - optymistyczna blokada (RowVersion)

To jest inny mechanizm niż izolacja transakcji - chroni przed konfliktem edycji między dwoma niezależnymi requestami:

public class Order
{
    public int Id { get; set; }
    public string Status { get; set; }

    [Timestamp] // RowVersion - EF Core automatycznie sprawdza, czy wiersz się nie zmienił
    public byte[] Version { get; set; }
}
var order = await _context.Orders.FindAsync(1);
order.Status = "Shipped";

try
{
    await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
    // Ktoś INNY zmienił ten wiersz między odczytem a zapisem - Twoja wersja jest przestarzała
    Console.WriteLine("Zamówienie zostało zmienione przez kogoś innego, odśwież dane");
}

RowVersion generuje w SQL warunek WHERE Id = 1 AND Version = @originalVersion przy UPDATE - jeśli w międzyczasie ktoś inny zmienił wiersz (i tym samym Version), zapytanie nie znajdzie żadnego wiersza do zaktualizowania, i EF Core rzuca DbUpdateConcurrencyException.

Podsumowanie - kiedy co

Mechanizm Chroni przed Kiedy używać
Domyślna transakcja SaveChangesAsync() Częściowym zapisem w RAMACH jednego wywołania Zawsze, automatycznie
Jawna transakcja (BeginTransactionAsync) Częściowym zapisem między WIELOMA SaveChangesAsync() Operacje wieloetapowe wymagające atomowości
Poziom izolacji Anomaliami współbieżności (dirty/non-repeatable read) Operacje finansowe/krytyczne wymagające Serializable
RowVersion/optimistic concurrency Nadpisaniem zmian innego użytkownika Edycja tego samego rekordu przez wielu userów naraz
Postaw mi kawę