System.InvalidOperationException: Warning as error exception for warning 'Microsoft.EntityFrameworkCore.Database.Transaction.TransactionIgnoredWarning': Transactions are not supported by the in-memory store. See https://go.microsoft.com/fwlink/?LinkId=800142 This exception can be suppressed or logged by passing event ID 'InMemoryEventId.TransactionIgnoredWarning' to the 'ConfigureWarnings' method in 'DbContext.OnConfiguring' or 'AddDbContext'.
Ai pornit o tranzacție (BeginTransaction) pe providerul InMemory, care nu are tranzacții. Pentru o singură salvare nu-ți trebuie: SaveChanges e deja atomic. Dacă tranzacția e necesară, testează cu SQLite sau ignoră avertismentul cu ConfigureWarnings, conștient că nu există rollback.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Providerul InMemory nu implementează tranzacții. Când apelezi Database.BeginTransaction(), EF emite avertismentul TransactionIgnoredWarning, pe care providerul îl tratează implicit ca eroare („Warning as error”), ca să nu crezi că ai protecție când nu ai: un Rollback nu ar anula nimic.
Mesajul îți spune și cum îl poți dezactiva: ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning)). Fă asta doar dacă înțelegi consecința (în teste, de exemplu).
Întrebarea mai utilă este dacă ai nevoie de tranzacție. Un singur SaveChanges este deja atomic: EF trimite toate modificările urmărite într-o tranzacție implicită, deci la un transfer bancar fie se actualizează ambele conturi, fie niciunul. Tranzacția explicită e necesară doar când ai mai multe SaveChanges, combini EF cu SQL brut sau ai nevoie de alt nivel de izolare.
De ce apare: cauzele frecvente
1Tranzacție explicită pentru o singură salvare
using var tx = db.Database.BeginTransaction();
din.Sold -= suma;
catre.Sold += suma;
db.SaveChanges();
tx.Commit();din.Sold -= suma;
catre.Sold += suma;
db.SaveChanges(); // atomicSaveChanges scrie ambele modificări în aceeași tranzacție implicită.
2Teste pe InMemory pentru cod cu tranzacții
o.UseInMemoryDatabase("teste");o.UseInMemoryDatabase("teste")
.ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning));Testul rulează, dar fără garanții de rollback; pentru a testa chiar tranzacția, folosește SQLite.
3Mai multe salvări care trebuie să reușească împreună
db.SaveChanges();
AltaOperatie();
db.SaveChanges();await using var tx = await db.Database.BeginTransactionAsync();
db.SaveChanges();
AltaOperatie();
db.SaveChanges();
await tx.CommitAsync();Aici tranzacția explicită e justificată, dar pe o bază relațională, nu pe InMemory.
Repară eroarea, direct în pagină
POST /transfer răspunde 500 cu Transactions are not supported by the in-memory store. Transferul modifică două conturi și le salvează cu un singur SaveChanges; scoate tranzacția explicită, care nu e necesară, ca transferul de 200 de lei de la Ana la Ion să reușească.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<Banca>(o => o.UseInMemoryDatabase("banca"));
var app = builder.Build();
using (var scope = app.Services.CreateScope())
{
var db = scope.ServiceProvider.GetRequiredService<Banca>();
db.Conturi.AddRange(new Cont { Titular = "Ana", Sold = 500m }, new Cont { Titular = "Ion", Sold = 100m });
db.SaveChanges();
}
app.MapPost("/transfer", (Transfer t, Banca db) =>
{
using var tranzactie = db.Database.BeginTransaction();
var din = db.Conturi.Find(t.DinId)!;
var catre = db.Conturi.Find(t.CatreId)!;
if (din.Sold < t.Suma) return Results.BadRequest("Sold insuficient.");
din.Sold -= t.Suma;
catre.Sold += t.Suma;
db.SaveChanges();
tranzactie.Commit();
return Results.Ok(new { din = din.Sold, catre = catre.Sold });
});
app.Run();
public record Transfer(int DinId, int CatreId, decimal Suma);
public class Cont
{
public int Id { get; set; }
public string Titular { get; set; } = "";
public decimal Sold { get; set; }
}
public class Banca(DbContextOptions<Banca> options) : DbContext(options)
{
public DbSet<Cont> Conturi => Set<Cont>();
}POST /transfer → 200 OK
{"din":300,"catre":300}Indiciu
Un singur SaveChanges e deja atomic.
Reparația
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<Banca>(o => o.UseInMemoryDatabase("banca"));
var app = builder.Build();
using (var scope = app.Services.CreateScope())
{
var db = scope.ServiceProvider.GetRequiredService<Banca>();
db.Conturi.AddRange(new Cont { Titular = "Ana", Sold = 500m }, new Cont { Titular = "Ion", Sold = 100m });
db.SaveChanges();
}
app.MapPost("/transfer", (Transfer t, Banca db) =>
{
var din = db.Conturi.Find(t.DinId)!;
var catre = db.Conturi.Find(t.CatreId)!;
if (din.Sold < t.Suma) return Results.BadRequest("Sold insuficient.");
din.Sold -= t.Suma;
catre.Sold += t.Suma;
db.SaveChanges();
return Results.Ok(new { din = din.Sold, catre = catre.Sold });
});
app.Run();
public record Transfer(int DinId, int CatreId, decimal Suma);
public class Cont
{
public int Id { get; set; }
public string Titular { get; set; } = "";
public decimal Sold { get; set; }
}
public class Banca(DbContextOptions<Banca> options) : DbContext(options)
{
public DbSet<Cont> Conturi => Set<Cont>();
}De ce merge
BeginTransaction() nu are sens pe InMemory, iar providerul oprește execuția ca să nu-ți dea o falsă siguranță. Codul nici nu avea nevoie de ea: ambele solduri se modifică pe obiecte urmărite și se scriu împreună la un singur SaveChanges, care pe o bază relațională rulează într-o tranzacție implicită. După transfer, Ana are 300, iar Ion 300.
Cum o eviți pe viitor
- Grupează modificările și apelează
SaveChangeso singură dată: e atomic fără cod în plus. - Folosește tranzacții explicite doar pentru mai multe salvări sau SQL brut, pe baze relaționale.
- Testează codul cu tranzacții pe SQLite în memorie sau pe baza reală.
- Nu ignora avertismentul în producție: acolo nu folosești InMemory.
Întrebări frecvente
Dacă ignor avertismentul, codul cu Rollback mai e corect?
Codul rulează, dar Rollback nu anulează nimic pe InMemory: modificările salvate rămân. Testul tău nu mai verifică ce crezi că verifică.
SaveChanges chiar folosește o tranzacție?
Da, pe providerii relaționali. Dacă una dintre comenzi eșuează, toate sunt anulate și primești DbUpdateException. Comportamentul se poate dezactiva cu Database.AutoTransactionBehavior, dar rar e nevoie.
Erori înrudite
System.InvalidOperationException: Relational-specific methods can only be used when the context is using a relational database provider. Ai apelat o metodă care există doar pentru baze relaționale (Migrate, ExecuteSqlRaw, GetDbConnection, FromSql...) pe un context configurat cu UseInMemoryDatabase. Pe InMemory folosește EnsureCreated și LINQ, sau testează cu SQLite în memorie. Microsoft.EntityFrameworkCore.DbUpdateException: An error occurred while saving the entity changes. See the inner exception for details. Baza de date a refuzat SaveChanges, iar EF a învelit eroarea reală în InnerException. Citește ex.InnerException.Message (sau logul complet): acolo e cauza exactă, de obicei o constrângere încălcată (UNIQUE, NOT NULL, FOREIGN KEY) sau o coloană prea lungă. Învață ASP.NET Core de la zero, cu exerciții la fiecare lecție
Curs ASP.NET Core: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 20 lecții sunt gratuite.
