Grundlagen von DbContext und DbSet
Richten Sie einen DbContext ein, definieren Sie Entitäten, konfigurieren Sie die Verbindungszeichenfolge und führen Sie Ihre erste Abfrage aus.
Grundlagen von DbContext und DbSet ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.
Was ist Entity Framework Core?
EF Core ist der offizielle objektrelationale Mapper (ORM) für .NET. Er bildet C#-Klassen (Entitäten) auf Datenbanktabellen ab und ermöglicht das Abfragen und Speichern von Daten mit LINQ – für die meisten Vorgänge ist kein SQL erforderlich.
Eine Entität definieren
Eine Entität ist eine einfache C#-Klasse, deren Eigenschaften Datenbankspalten zugeordnet werden. Konventionsgemäß wird eine Eigenschaft namens Id oder <TypeName>Id zum Primärschlüssel.
public class Product
{
public int Id { get; set; }
public string Name { get; set; } = "";
public decimal Price { get; set; }
public int Stock { get; set; }
public DateTime CreatedAt { get; set; }
}Einen DbContext erstellen
DbContext ist der Zugangspunkt zur Datenbank. Er enthält DbSet<T>-Eigenschaften für jede Entität und verwaltet die Verbindung, die Änderungsnachverfolgung und Transaktionen.
using Microsoft.EntityFrameworkCore;
public class AppDbContext : DbContext
{
public AppDbContext(DbContextOptions<AppDbContext> options)
: base(options) { }
public DbSet<Product> Products => Set<Product>();
public DbSet<Order> Orders => Set<Order>();
}DbContext mit DI registrieren
Rufen Sie AddDbContext in Program.cs auf, um den Kontext als Scoped-Dienst zu registrieren und den Datenbankanbieter zu konfigurieren.
builder.Services.AddDbContext<AppDbContext>(options =>
options.UseSqlServer(
builder.Configuration.GetConnectionString("Default")));
// For SQLite (great for development/testing):
// options.UseSqlite("Data Source=app.db");Grundlegende Abfragen mit DbSet
DbSet<T> stellt LINQ-Operatoren bereit. Abfragen werden erst ausgeführt, wenn sie enumeriert werden (await ...ToListAsync()). Dies wird als verzögerte Ausführung bezeichnet.
public class ProductService
{
private readonly AppDbContext _db;
public ProductService(AppDbContext db) => _db = db;
public async Task<List<Product>> GetExpensiveAsync(decimal minPrice)
{
return await _db.Products
.Where(p => p.Price >= minPrice)
.OrderBy(p => p.Name)
.ToListAsync();
}
}Nach Primärschlüssel suchen
FindAsync prüft zunächst den lokalen Cache des Änderungs-Trackers, bevor auf die Datenbank zugegriffen wird. Verwenden Sie diese Methode bei Abfragen nach dem Primärschlüssel, um redundante Roundtrips zu vermeiden.
var product = await _db.Products.FindAsync(42);
if (product is null)
throw new KeyNotFoundException("Product not found");
// For complex keys, pass all key values:
var orderLine = await _db.OrderLines.FindAsync(orderId, productId);Neue Datensätze hinzufügen
Rufen Sie Add auf, um eine Entität zum Einfügen vorzumerken, und anschließend SaveChangesAsync, um die Änderung zu übernehmen. EF Core generiert das INSERT-SQL und füllt die automatisch generierte Id aus.
var product = new Product
{
Name = "Mechanical Keyboard",
Price = 149.99m,
Stock = 50,
CreatedAt = DateTime.UtcNow
};
_db.Products.Add(product);
await _db.SaveChangesAsync();
Console.WriteLine(product.Id); // Auto-generated PKDatensätze aktualisieren
Von EF Core geladene Entitäten werden nachverfolgt. Ändern Sie die Eigenschaften direkt und rufen Sie SaveChangesAsync auf – EF Core erkennt die Änderungen und generiert eine optimierte UPDATE-Anweisung.
var product = await _db.Products.FindAsync(42);
if (product is not null)
{
product.Price = 129.99m;
product.Stock -= 1;
await _db.SaveChangesAsync(); // UPDATE Products SET Price=...
}Datensätze löschen
Rufen Sie Remove auf, um eine Entität zum Löschen zu markieren, und anschließend SaveChangesAsync. Verwenden Sie ExecuteDeleteAsync (.NET 7+) für das Löschen vieler Datensätze, ohne die Entitäten zu laden.
// Delete a tracked entity
_db.Products.Remove(product);
await _db.SaveChangesAsync();
// Bulk delete without loading (EF Core 7+)
await _db.Products
.Where(p => p.Stock == 0)
.ExecuteDeleteAsync();Mit der Fluent API konfigurieren
Überschreiben Sie OnModelCreating, um Entitäten mit der Fluent API zu konfigurieren – darunter Tabellennamen, Spaltentypen, Einschränkungen, Indizes und Beziehungen.
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Product>(entity =>
{
entity.ToTable("products");
entity.Property(p => p.Name).IsRequired().HasMaxLength(200);
entity.Property(p => p.Price).HasColumnType("decimal(18,2)");
entity.HasIndex(p => p.Name);
});
}Praxisbeispiel: Repository mit DbContext
Ein typisches Repository kapselt den DbContext, um die Datenzugriffslogik zu zentralisieren und Abfragedetails aus Serviceklassen herauszuhalten.
public class ProductRepository : IProductRepository
{
private readonly AppDbContext _db;
public ProductRepository(AppDbContext db) => _db = db;
public async Task<Product?> GetByIdAsync(int id)
=> await _db.Products.AsNoTracking().FirstOrDefaultAsync(p => p.Id == id);
public async Task<List<Product>> SearchAsync(string query)
=> await _db.Products
.Where(p => p.Name.Contains(query))
.AsNoTracking()
.ToListAsync();
}Schnelltest
Was bewirkt AsNoTracking() bei einer Abfrage mit EF Core?
Zusammenfassung: Grundlagen von DbContext und DbSet
Wichtige Erkenntnisse:
- DbContext ist die Sitzung mit der Datenbank; DbSet<T> repräsentiert eine Tabelle
- Registrieren Sie den Kontext mit
AddDbContextin DI; standardmäßig wird er als Scoped registriert - LINQ-Abfragen werden verzögert ausgeführt – führen Sie sie mit
ToListAsyncoderFirstOrDefaultAsyncaus - Änderungsnachverfolgung ermöglicht automatische UPDATE- und DELETE-Operationen über SaveChangesAsync
- Verwenden Sie
AsNoTracking()für schreibgeschützte Abfragen, um die Leistung zu verbessern
Häufig gestellte Fragen
Ist die Lektion „Grundlagen von DbContext und DbSet“ kostenlos?
Ja — der vollständige Text von „Grundlagen von DbContext und DbSet“ 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 „Grundlagen von DbContext und DbSet“?
Richten Sie einen DbContext ein, definieren Sie Entitäten, konfigurieren Sie die Verbindungszeichenfolge und führen Sie Ihre erste Abfrage 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 1 von 4.
Wie lange dauert die Lektion „Grundlagen von DbContext und DbSet“?
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
- Grundlagen von DbContext und DbSet
- Migrationen und Schemaverwaltung
- CRUD-Operationen mit EF Core
- Beziehungen: Eins-zu-viele und Viele-zu-viele