...
Eroare ASP.NET Core · Entity Framework Core

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'.

Pe scurt

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

Greșit
C#
using var tx = db.Database.BeginTransaction();
din.Sold -= suma;
catre.Sold += suma;
db.SaveChanges();
tx.Commit();
Corect
C#
din.Sold -= suma;
catre.Sold += suma;
db.SaveChanges(); // atomic

SaveChanges scrie ambele modificări în aceeași tranzacție implicită.

2Teste pe InMemory pentru cod cu tranzacții

Greșit
C#
o.UseInMemoryDatabase("teste");
Corect
C#
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ă

Greșit
C#
db.SaveChanges();
AltaOperatie();
db.SaveChanges();
Corect
C#
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ă tu

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ă.

Codul care dă eroarea
C#
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>();
}
După reparație, programul afișează
POST /transfer → 200 OK
{"din":300,"catre":300}
Indiciu

Un singur SaveChanges e deja atomic.

Cum o eviți pe viitor

  • Grupează modificările și apelează SaveChanges o 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

← Toate erorile ASP.NET Core

Tudor Andrei Dumitrescu
Cine a explicat eroarea

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Fiecare eroare de aici a fost reprodusă în editorul nostru: codul greșit chiar dă mesajul din titlu, iar reparația chiar funcționează.

Î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.