Entity Framework Core og SQL Server: Unngå ytelsesfellene
Entity Framework Core er den vanligste måten .NET-applikasjoner snakker med SQL Server på. Det er produktivt, men det skjuler SQL-en – og det er nettopp der ytelsesproblemene gjemmer seg. En side som laster ti ordrer kan sende hundre spørringer, og en uskyldig Where kan tvinge SQL Server til å lese hele tabellen. Denne guiden viser de vanligste fellene med EF Core og SQL Server, hvordan du ser hva som faktisk sendes til databasen, og hvordan du retter det.
- Se SQL-en. Bruk
ToQueryString(),LogToog Query Store – ikke gjett. - Unngå N+1: hent relaterte data med
Includeeller projeksjon, ikke lazy loading i løkker. - Pass på at strengtypene stemmer:
varchar-kolonner må være mappet medIsUnicode(false), ellers får du implisitt konvertering. - Bruk
AsNoTracking()for lesing,Selectfor å hente bare kolonnene du trenger, ogAsSplitQuery()ved mangeInclude.
Først: se hvilken SQL som sendes
Alle ytelsesproblemer med EF Core starter med at du ikke vet hva databasen får. Det finnes tre enkle måter å finne det ut på.
// 1. For én spørring – uten å kjøre den
var spørring = db.Ordrer
.Where(o => o.KundeId == kundeId)
.OrderByDescending(o => o.Dato);
Console.WriteLine(spørring.ToQueryString());
// 2. For alt – i oppsettet av DbContext (kun utvikling!)
options.UseSqlServer(connectionString)
.LogTo(Console.WriteLine, LogLevel.Information)
.EnableSensitiveDataLogging();
// 3. Merk spørringen, så du finner den igjen i Query Store og Profiler
var ordrer = await db.Ordrer
.TagWith("Kundeside: siste ordrer")
.Where(o => o.KundeId == kundeId)
.ToListAsync();
TagWith legger en kommentar først i SQL-en. Den følger med til SQL Server og gjør det mye enklere å finne riktig spørring i Query Store eller i sys.dm_exec_query_stats.
EnableSensitiveDataLogging skriver parameterverdier – også personopplysninger og passord – til loggen. Bruk det bare lokalt. Se GDPR og personvern.
Felle 1: N+1-spørringer
Den klassiske feilen: én spørring henter en liste, og så går koden gjennom listen og henter relaterte data for hver rad.
// Dårlig: 1 spørring for ordrene + 1 per ordre for linjene (med lazy loading)
var ordrer = await db.Ordrer.Where(o => o.Dato >= fraDato).ToListAsync();
foreach (var ordre in ordrer)
total += ordre.Linjer.Sum(l => l.Antall * l.Pris);
// Bedre: la databasen gjøre jobben i én spørring
var total = await db.Ordrelinjer
.Where(l => l.Ordre.Dato >= fraDato)
.SumAsync(l => l.Antall * l.Pris);
Lazy loading er av som standard i EF Core, og det er et godt valg. Ser du hundrevis av nesten like spørringer i loggen, er det nesten alltid N+1.
Felle 2: Implisitt konvertering (varchar mot nvarchar)
EF Core mapper string til nvarchar som standard. Er kolonnen i databasen varchar – vanlig i eldre databaser – sender EF Core likevel parameteren som nvarchar. Fordi nvarchar har høyere prioritet, må SQL Server konvertere kolonnen for hver rad, og en indeks på kolonnen kan ikke brukes til seek. Resultatet er en full scan og en advarsel om CONVERT_IMPLICIT i kjøreplanen.
// Kolonnen er varchar(20) i databasen – fortell EF Core det
public class Kunde
{
public int Id { get; set; }
[Unicode(false), MaxLength(20)]
public string Kundenummer { get; set; } = "";
}
// Eller i OnModelCreating
modelBuilder.Entity<Kunde>()
.Property(k => k.Kundenummer)
.IsUnicode(false)
.HasMaxLength(20);
Det motsatte – en nvarchar-kolonne og en varchar-parameter – er ufarlig, fordi det er parameteren som konverteres. Les mer om valg mellom typene i guiden om datatyper.
Felle 3: Parameter sniffing
EF Core parameteriserer spørringer, og det er bra: SQL Server kan gjenbruke kjøreplanen. Men planen lages for den første parameterverdien. Er den første kunden en med tre ordrer, og den neste en med tre millioner, kan planen bli helt feil. Symptomet er en spørring som «plutselig» er treg, og som blir rask igjen etter en omstart eller statistikkoppdatering.
Diagnose og tiltak er de samme som for annen SQL – se hvorfor er spørringen treg?. Med Query Store kan du tvinge en god plan eller legge på et hint uten å endre koden.
Lister i Contains
ids.Contains(o.Id) med en liste fra C# oversettes ulikt avhengig av versjon. EF Core 8 og 9 sender listen som én JSON-parameter og pakker den ut med OPENJSON, noe som gir én plan for alle listestørrelser – men dårlige estimater. EF Core 10 bruker som standard enkeltparametere med utfylling til faste størrelser, som gir bedre estimater. Du kan styre det med UseParameterizedCollectionMode i UseSqlServer-oppsettet hvis en spørring får dårlig plan.
Felle 4: Tracking og for mye data
Som standard holder DbContext oversikt over alle entiteter du henter, slik at endringer kan lagres. Det koster minne og CPU. Til lesing trenger du det ikke:
// Leser bare: ingen sporing
var produkter = await db.Produkter
.AsNoTracking()
.Where(p => p.Aktiv)
.ToListAsync();
// Enda bedre: hent bare kolonnene du trenger
var liste = await db.Produkter
.Where(p => p.Aktiv)
.Select(p => new ProduktListeDto(p.Id, p.Navn, p.Pris))
.ToListAsync();
Projeksjon med Select gjør ofte mer for ytelsen enn noe annet: mindre data over nettverket, og SQL Server kan bruke en smalere, dekkende indeks.
Felle 5: Kartesisk eksplosjon – bruk split queries
Henter du flere samlinger med Include, lager EF Core én spørring med JOIN-er. En ordre med 50 linjer og 20 hendelser gir da 1 000 rader tilbake, der ordredata gjentas i hver rad.
var ordre = await db.Ordrer
.Include(o => o.Linjer)
.Include(o => o.Hendelser)
.AsSplitQuery() // én spørring per samling i stedet for én stor JOIN
.SingleAsync(o => o.Id == id);
// Eller som standard for hele konteksten
options.UseSqlServer(cs, sql => sql.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery));
Split queries betyr flere rundturer, og dataene kan i teorien endre seg mellom dem. Bruk det der det er flere samlinger, ikke overalt.
Flere tips
- Masseoppdateringer:
ExecuteUpdateAsyncogExecuteDeleteAsyncsender énUPDATE/DELETEi stedet for å laste og lagre hver rad. - Paging: Bruk
Skip/Takemed en stabilOrderBy, eller keyset-paging (Where(o => o.Id > sisteId)) for store tabeller. - DbContext-pooling:
AddDbContextPoolsparer allokeringer i applikasjoner med mange forespørsler. - Gjentatte feil:
EnableRetryOnFailure()håndterer forbigående feil, særlig mot Azure SQL. - Lange transaksjoner: Hold
SaveChangesog transaksjoner korte, ellers får du blokkering.
Vanlige spørsmål
Er rå SQL raskere enn EF Core?
Selve overheaden i EF Core er liten. Forskjellen ligger nesten alltid i hvilken SQL som sendes. Trenger du full kontroll, kan du bruke FromSql eller SqlQuery for enkelte spørringer og beholde EF Core for resten.
Bør jeg bruke lagrede prosedyrer?
Ikke for ytelsens skyld – parameteriserte spørringer gjenbruker planer like godt. Prosedyrer kan likevel være nyttige for kompleks logikk som hører hjemme nær dataene, og for tilgangsstyring.
Hvorfor er spørringen rask i SSMS, men treg fra applikasjonen?
Ofte er det ulike SET-innstillinger (særlig ARITHABORT) som gir hver sin plan, kombinert med parameter sniffing. Test med samme parametere som applikasjonen, eller se den faktiske planen i Query Store.