C# / .NET Kompendium PLEN
.NET / C# / Entity Framework Core

Entity Framework Core - podstawy

DbContext i DbSet - fundament

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

    public DbSet<Order> Orders { get; set; }
    public DbSet<Customer> Customers { get; set; }
    public DbSet<OrderItem> OrderItems { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Order>()
            .HasMany(o => o.Items)
            .WithOne(i => i.Order)
            .HasForeignKey(i => i.OrderId);
    }
}

DbSet<T> reprezentuje tabelę w bazie i implementuje IQueryable<T> (o czym mówiliśmy wcześniej) - każde zapytanie na DbSet jest budowane jako drzewo wyrażeń, dopóki nie zażądasz materializacji.

Change Tracking - domyślne zachowanie

var order = await _context.Orders.FirstAsync(o => o.Id == 1);
order.Status = "Shipped"; // EF Core AUTOMATYCZNIE śledzi tę zmianę

await _context.SaveChangesAsync(); // generuje UPDATE tylko dla zmienionych pól

EF Core automatycznie wykrywa zmiany na obiektach, które zostały pobrane przez ten sam DbContext - nie musisz ręcznie mówić "ten obiekt się zmienił".

AsNoTracking() - wyłączenie trackingu dla odczytu

// Ze trackingiem (domyślnie) - EF Core przechowuje "snapshot" do porównania przy SaveChanges
var orders = await _context.Orders.ToListAsync();

// Bez trackingu - szybsze, mniej pamięci, gdy TYLKO czytasz dane (nie będziesz ich modyfikować)
var readOnlyOrders = await _context.Orders.AsNoTracking().ToListAsync();

Kiedy używać AsNoTracking(): dla wszystkich zapytań tylko do odczytu (np. wyświetlanie listy w API, raporty) - eliminuje narzut change trackera, co przy dużych zbiorach danych daje realną różnicę wydajnościową.

Problem N+1 - klasyczna pułapka wydajnościowa

// ❌ N+1 problem - jedno zapytanie po zamówienia + N zapytań po klienta dla każdego z nich
var orders = await _context.Orders.ToListAsync();
foreach (var order in orders)
{
    Console.WriteLine(order.Customer.Name); // LAZY LOADING - osobne zapytanie SQL dla KAŻDEGO order!
}
// ✅ Eager loading z Include - JEDNO zapytanie z JOIN
var orders = await _context.Orders
    .Include(o => o.Customer)
    .ToListAsync();

foreach (var order in orders)
{
    Console.WriteLine(order.Customer.Name); // dane już załadowane, brak dodatkowych zapytań
}

Include() generuje JOIN w SQL i ładuje powiązane dane w tym samym zapytaniu - to jest standardowe rozwiązanie problemu N+1 w EF Core.

// Include wielopoziomowy (ThenInclude)
var orders = await _context.Orders
    .Include(o => o.Customer)
    .Include(o => o.Items).ThenInclude(i => i.Product)
    .ToListAsync();

Migracje - zarządzanie schematem bazy

dotnet ef migrations add AddOrderStatusColumn   # generuje plik migracji na podstawie zmian w modelu
dotnet ef database update                        # stosuje migracje do bazy danych
dotnet ef migrations remove                       # usuwa ostatnią, jeszcze niezastosowaną migrację
dotnet ef database update PreviousMigrationName    # rollback do konkretnej migracji

Migracja to plik C# generowany automatycznie, opisujący różnicę między poprzednim a aktualnym modelem (Up()/Down()):

public partial class AddOrderStatusColumn : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.AddColumn<string>(name: "Status", table: "Orders", type: "nvarchar(50)", nullable: true);
    }

    protected override void Down(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.DropColumn(name: "Status", table: "Orders");
    }
}

Async guidelines - zawsze asynchronicznie

// ✅ Poprawnie - EF Core operacje I/O powinny być zawsze async
var order = await _context.Orders.FirstOrDefaultAsync(o => o.Id == id);
await _context.SaveChangesAsync();

// ❌ Źle - blokuje wątek na czas I/O, marnuje zasoby (zwłaszcza w Web API pod obciążeniem)
var order = _context.Orders.FirstOrDefault(o => o.Id == id);
_context.SaveChanges();

Podsumowanie kluczowych metod

Metoda Cel
AsNoTracking() Wyłącza change tracking, szybsze zapytania tylko-do-odczytu
Include()/ThenInclude() Eager loading, unika problemu N+1
FirstOrDefaultAsync() Pobranie jednego rekordu lub null
AnyAsync() Sprawdzenie istnienia bez pobierania danych
CountAsync() Liczenie bez materializacji wszystkich rekordów
SaveChangesAsync() Zapisanie wszystkich śledzonych zmian jako transakcja
Postaw mi kawę