PricingLoginStart free
C# Academy · Lektion

CRUD-Operationen mit EF Core

Führen Sie Create-, Read-, Update- und Delete-Operationen mit dem Änderungs-Tracking von EF Core und SaveChanges aus.

Lektion 3 von 413 Schritte

CRUD-Operationen mit EF Core ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

CRUD-Überblick in EF Core

EF Core unterstützt alle vier CRUD-Operationen – Create, Read, Update, Delete – durch eine Kombination aus Änderungsnachverfolgung und SaveChangesAsync(). Das Verständnis des Änderungs-Trackers ist der Schlüssel zur Beherrschung von CRUD.

Create: Eine neue Entität hinzufügen

Verwenden Sie DbSet.Add() oder AddAsync(), um eine Entität als Added zu markieren. Bei SaveChangesAsync() generiert EF Core ein INSERT und füllt den automatisch inkrementierten Schlüssel aus.

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

Einen Entitätsgraphen hinzufügen

Wenn Sie ein übergeordnetes Objekt mit untergeordneten Objekten in einem einzigen Aufruf hinzufügen, wird der gesamte Objektgraph eingefügt. EF Core löst die FK-Beziehungen automatisch auf.

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

Read: Mit LINQ abfragen

EF Core übersetzt LINQ-Ausdrücke in SQL. Stellen Sie Abfragen mit Where, Select, OrderBy usw. zusammen und materialisieren Sie sie anschließend mit ToListAsync oder 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();

Read: Einzelne Entitäten suchen

Verwenden Sie für das Lesen einzelner Entitäten FindAsync (prüft zuerst den Tracker) oder FirstOrDefaultAsync bzw. SingleOrDefaultAsync mit einem Prädikat.

// 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();

Update: Änderungsnachverfolgung

Über EF Core geladene Entitäten werden nachverfolgt. Ändern Sie die Eigenschaften direkt und rufen Sie SaveChangesAsync() auf. EF Core erkennt die Differenz und generiert eine minimale UPDATE-Anweisung.

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

Update: Massenaktualisierung (EF Core 7+)

ExecuteUpdateAsync aktualisiert Zeilen direkt in der Datenbank, ohne Entitäten zu laden. Für Massenoperationen ist dies wesentlich effizienter.

// 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));

Delete: Eine einzelne Entität entfernen

Rufen Sie für eine nachverfolgte Entität Remove() und anschließend SaveChangesAsync() auf. Wenn Ihnen nur die ID vorliegt, suchen Sie die Entität zuerst oder verwenden Sie 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

Delete: Massenlöschung (EF Core 7+)

ExecuteDeleteAsync führt eine einzelne DELETE-SQL-Anweisung aus, ohne Entitäten zu laden – ideal für die stapelweise Bereinigung.

// 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");

Transaktionen

Alle Vorgänge innerhalb eines einzelnen Aufrufs von SaveChangesAsync werden in eine Transaktion eingeschlossen. Verwenden Sie für mehrstufige Vorgänge über mehrere Speichervorgänge hinweg eine explizite Transaktion.

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;
}

Praxisbeispiel: Vollständiger CRUD-Service

Ein vollständiger Service kapselt alle CRUD-Operationen mit einer geeigneten Fehlerbehandlung und gibt DTOs zurück, um die Interna der Entitäten nicht offenzulegen.

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;
}

Schnelltest

Welchen Vorteil bieten ExecuteUpdateAsync und ExecuteDeleteAsync gegenüber dem Laden von Entitäten und dem Aufruf von SaveChangesAsync?

Beantworte es in der interaktiven Lektion

Zusammenfassung: CRUD-Operationen mit EF Core

Wichtige Erkenntnisse:

  • Add + SaveChangesAsync → INSERT; EF Core füllt automatisch generierte Schlüssel aus
  • Nachverfolgte Entitäten ändern + SaveChangesAsync → minimale UPDATE-Anweisung
  • Remove + SaveChangesAsync → DELETE für einzelne Entitäten
  • ExecuteUpdateAsync und ExecuteDeleteAsync → Massenoperationen ohne Laden der Entitäten (EF Core 7+)
  • Schließen Sie mehrstufige Vorgänge in eine explizite Transaktion ein, um ihre Atomarität sicherzustellen
Kostenlos starten

Lerne C# mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
93
Lektionen
346
Kostenlos lernenDen vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „CRUD-Operationen mit EF Core“ kostenlos?

Ja — der vollständige Text von „CRUD-Operationen mit EF Core“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „CRUD-Operationen mit EF Core“?

Führen Sie Create-, Read-, Update- und Delete-Operationen mit dem Änderungs-Tracking von EF Core und SaveChanges aus. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „CRUD-Operationen mit EF Core“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Grundlagen von DbContext und DbSet
  2. Migrationen und Schemaverwaltung
  3. CRUD-Operationen mit EF Core
  4. Beziehungen: Eins-zu-viele und Viele-zu-viele
← Zurück zu C# Academy