C# Academy · leksjon

CRUD-operasjoner med EF Core

Utfør Create-, Read-, Update- og Delete-operasjoner med EF Cores endringssporing og SaveChanges.

Leksjon 3 av 413 trinn

CRUD-operasjoner med EF Core er en gratis leksjon i C# Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i C# Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i C# Academy inneholder totalt 4 leksjoner.

Oversikt over CRUD i EF Core

EF Core håndterer alle de fire CRUD-operasjonene — opprette, lese, oppdatere og slette — gjennom en kombinasjon av endringssporing og SaveChangesAsync(). Å forstå endringssporingen er nøkkelen til å mestre CRUD.

Opprette: Legge til en ny entitet

Bruk DbSet.Add() eller AddAsync() for å merke en entitet som Added. Når SaveChangesAsync() kalles, genererer EF Core en INSERT og fyller ut den autoinnkrementerte nøkkelen.

var order = new Order
{
    CustomerId = 5,
    PlacedAt   = DateTime.UtcNow,
    Status     = OrderStatus.Pending
};

await _db.Orders.AddAsync(order);
await _db.SaveChangesAsync();

Console.WriteLine(order.Id); // populated by DB

Legge til en graf av entiteter

Når en overordnet entitet med underordnede entiteter legges til i ett enkelt kall, settes hele objektgrafen inn. EF Core håndterer relasjonene med fremmednøkler automatisk.

var order = new Order
{
    CustomerId = 5,
    PlacedAt   = DateTime.UtcNow,
    Lines      = new List<OrderLine>
    {
        new() { ProductId = 10, Quantity = 2, Price = 49.99m },
        new() { ProductId = 11, Quantity = 1, Price = 19.99m }
    }
};

_db.Orders.Add(order);
await _db.SaveChangesAsync();
// Inserts Order + 2 OrderLines in one transaction

Lese: Spørringer med LINQ

EF Core oversetter LINQ-uttrykk til SQL. Sett sammen spørringer med Where, Select, OrderBy og så videre, og materialiser dem deretter med ToListAsync eller FirstOrDefaultAsync.

// Read all pending orders for a customer
var orders = await _db.Orders
    .Where(o => o.CustomerId == 5 && o.Status == OrderStatus.Pending)
    .OrderByDescending(o => o.PlacedAt)
    .Select(o => new OrderSummaryDto
    {
        Id     = o.Id,
        Total  = o.Lines.Sum(l => l.Quantity * l.Price),
        Status = o.Status.ToString()
    })
    .ToListAsync();

Lese: Oppslag etter enkeltentiteter

For lesing av én enkelt entitet kan De bruke FindAsync (kontrollerer sporingen først) eller FirstOrDefaultAsync / SingleOrDefaultAsync med et predikat.

// By PK (checks cache first)
var order = await _db.Orders.FindAsync(orderId);

// By predicate (always hits DB)
var latest = await _db.Orders
    .Where(o => o.CustomerId == 5)
    .OrderByDescending(o => o.PlacedAt)
    .FirstOrDefaultAsync();

Oppdatere: Endringssporing

Entiteter som lastes inn via EF Core, spores. Endre egenskapene direkte og kall SaveChangesAsync(). EF Core oppdager forskjellen og genererer en minimal UPDATE-setning.

var order = await _db.Orders.FindAsync(orderId);
if (order is null) return;

order.Status   = OrderStatus.Shipped;
order.ShippedAt = DateTime.UtcNow;

await _db.SaveChangesAsync();
// UPDATE Orders SET Status=..., ShippedAt=... WHERE Id=orderId

Oppdatere: Masseoppdatering (EF Core 7+)

ExecuteUpdateAsync oppdaterer rader direkte i databasen uten å laste inn entiteter. Dette er langt mer effektivt for masseoperasjoner.

// Mark all overdue orders as Cancelled — no loading needed
await _db.Orders
    .Where(o => o.Status == OrderStatus.Pending
             && o.PlacedAt < DateTime.UtcNow.AddDays(-30))
    .ExecuteUpdateAsync(set => set
        .SetProperty(o => o.Status, OrderStatus.Cancelled)
        .SetProperty(o => o.UpdatedAt, DateTime.UtcNow));

Slette: Fjerne én enkelt entitet

Kall Remove() på en sporet entitet, og kall deretter SaveChangesAsync(). Hvis De bare har ID-en, kan De finne entiteten først eller bruke ExecuteDeleteAsync.

var order = await _db.Orders.FindAsync(orderId);
if (order is null) return;

_db.Orders.Remove(order);
await _db.SaveChangesAsync();
// DELETE FROM Orders WHERE Id=orderId

Slette: Massesletting (EF Core 7+)

ExecuteDeleteAsync sender én enkelt DELETE-SQL-setning uten å laste inn entiteter — ideelt for opprydding i grupper.

// Delete all cancelled orders older than 1 year
int deleted = await _db.Orders
    .Where(o => o.Status == OrderStatus.Cancelled
             && o.PlacedAt < DateTime.UtcNow.AddYears(-1))
    .ExecuteDeleteAsync();

Console.WriteLine($"Deleted {deleted} old orders");

Transaksjoner

Alle operasjoner i ett enkelt kall til SaveChangesAsync pakkes inn i en transaksjon. For operasjoner i flere trinn og med flere lagringer bør De bruke en eksplisitt transaksjon.

using var transaction = await _db.Database.BeginTransactionAsync();
try
{
    _db.Orders.Add(newOrder);
    await _db.SaveChangesAsync();

    inventory.Stock -= newOrder.Quantity;
    await _db.SaveChangesAsync();

    await transaction.CommitAsync();
}
catch
{
    await transaction.RollbackAsync();
    throw;
}

Praktisk eksempel: Komplett CRUD-tjeneste

En komplett tjeneste pakker inn alle CRUD-operasjoner med riktig feilhåndtering og returnerer DTO-er for å unngå å eksponere interne detaljer om entiteter.

public async Task<OrderDto> CreateOrderAsync(CreateOrderRequest req)
{
    var order = new Order { CustomerId = req.CustomerId, PlacedAt = DateTime.UtcNow };
    _db.Orders.Add(order);
    await _db.SaveChangesAsync();
    return new OrderDto { Id = order.Id, Status = order.Status.ToString() };
}

public async Task<bool> CancelOrderAsync(int id)
{
    int rows = await _db.Orders
        .Where(o => o.Id == id && o.Status == OrderStatus.Pending)
        .ExecuteUpdateAsync(s =>
            s.SetProperty(o => o.Status, OrderStatus.Cancelled));
    return rows > 0;
}

Hurtigsjekk

Hva er fordelen med ExecuteUpdateAsync / ExecuteDeleteAsync fremfor å laste inn entiteter og kalle SaveChangesAsync?

Besvar den i den interaktive leksjonen

Oppsummering: CRUD-operasjoner med EF Core

Viktigste punkter:

Add + SaveChangesAsync → INSERT; EF Core fyller ut automatisk genererte nøkler
Endre sporede entiteter + SaveChangesAsync → minimal UPDATE
Remove + SaveChangesAsync → DELETE for enkeltentiteter
ExecuteUpdateAsync / ExecuteDeleteAsync → masseoperasjoner uten innlasting (EF Core 7+)
Pakk operasjoner i flere trinn inn i en eksplisitt transaksjon for atomisitet

Gratis å komme i gang

Lær deg C# med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 93
Leksjoner: 346

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «CRUD-operasjoner med EF Core» gratis?

Ja – hele teksten i «CRUD-operasjoner med EF Core» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av C# Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i C# Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «CRUD-operasjoner med EF Core»?

Utfør Create-, Read-, Update- og Delete-operasjoner med EF Cores endringssporing og SaveChanges. Du øver på C# Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med C# Academy?

Ingen tidligere erfaring er nødvendig. C# Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «CRUD-operasjoner med EF Core»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne C# Academy-leksjonen?

Ja. Alle C# Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Grunnleggende om DbContext og DbSet
Migreringer og skjemahåndtering
CRUD-operasjoner med EF Core
Relasjoner: én-til-mange og mange-til-mange

← Tilbake til C# Academy