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 |