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

Dobre praktyki async w EF Core

Zasada podstawowa - wszystko I/O powinno być async

// ✅ Poprawnie
var order = await _context.Orders.FirstOrDefaultAsync(o => o.Id == id);
var count = await _context.Orders.CountAsync();
var exists = await _context.Orders.AnyAsync(o => o.Status == "Pending");
await _context.SaveChangesAsync();

// ❌ Źle - blokuje wątek, marnuje throughput w Web API pod obciążeniem
var order = _context.Orders.FirstOrDefault(o => o.Id == id);

Jak omawialiśmy wcześniej - synchroniczne wywołanie I/O blokuje wątek z puli wątków na cały czas trwania zapytania do bazy (mogą to być milisekundy, ale przy dużym ruchu to się kumuluje). Async pozwala wątkowi wrócić do puli i obsłużyć inny request, podczas gdy czekamy na bazę.

Pułapka #1: Nigdy nie współdziel jednego DbContext między równoległymi zadaniami

// ❌ BŁĄD - DbContext NIE jest thread-safe (jak omawialiśmy przy Singleton/thread-safety)
var task1 = _context.Orders.ToListAsync();
var task2 = _context.Customers.ToListAsync();
await Task.WhenAll(task1, task2); // InvalidOperationException - "A second operation was started..."
// ✅ Poprawnie - osobne scope'y/DbContext dla równoległych operacji
using var scope1 = _scopeFactory.CreateScope();
using var scope2 = _scopeFactory.CreateScope();
var context1 = scope1.ServiceProvider.GetRequiredService<AppDbContext>();
var context2 = scope2.ServiceProvider.GetRequiredService<AppDbContext>();

var task1 = context1.Orders.ToListAsync();
var task2 = context2.Customers.ToListAsync();
await Task.WhenAll(task1, task2); // OK - różne instancje DbContext

To dokładnie nawiązuje do tego, co mówiliśmy o IServiceScopeFactory i Scoped lifetime - DbContext jest Scoped właśnie dlatego, że nie jest thread-safe, i próba jego współdzielenia między równoległymi task-ami (nawet w ramach tego samego requestu!) rzuci wyjątek.

Pułapka #2: ConfigureAwait(false) w warstwie danych

public class OrderRepository
{
    public async Task<Order> GetByIdAsync(int id)
    {
        // Jak mówiliśmy przy SynchronizationContext - warstwa danych/serwisy
        // NIE dotykają UI, więc ConfigureAwait(false) ma tu sens
        return await _context.Orders
            .FirstOrDefaultAsync(o => o.Id == id)
            .ConfigureAwait(false);
    }
}

Pułapka #3: .Result/.Wait() - blokowanie na asynchronicznym kodzie

// ❌ NIGDY - ryzyko deadlocku (jak w scenariuszu z WPF, o którym mówiliśmy)
var order = _context.Orders.FirstOrDefaultAsync(o => o.Id == id).Result;

// ✅ Async all the way
var order = await _context.Orders.FirstOrDefaultAsync(o => o.Id == id);

Pułapka #4: IEnumerable vs IQueryable przy async

// ❌ Problem - jeśli typ zmiennej to IEnumerable, TERAZ filtr NIE trafi do SQL
IEnumerable<Order> orders = _context.Orders;
var filtered = orders.Where(o => o.Status == "Pending"); // w PAMIĘCI, po pobraniu WSZYSTKIEGO
var list = filtered.ToList(); // synchronicznie! (IEnumerable nie ma ToListAsync)

// ✅ Poprawnie - IQueryable aż do końca, materializacja asynchroniczna
IQueryable<Order> orders = _context.Orders;
var filtered = orders.Where(o => o.Status == "Pending"); // trafia do SQL WHERE
var list = await filtered.ToListAsync();

CancellationToken - propagacja przez cały łańcuch async

[HttpGet]
public async Task<ActionResult<List<OrderDto>>> GetOrders(CancellationToken cancellationToken)
{
    var orders = await _context.Orders.ToListAsync(cancellationToken); // przekazane DALEJ do EF Core
    return Ok(orders);
}

Jeśli użytkownik zamknie kartę przeglądarki/przerwie request, ASP.NET Core automatycznie odwoła (cancel) ten token - EF Core przerwie zapytanie SQL w toku, zamiast czekać na jego zakończenie i wyrzucać wynik. To realnie odciąża bazę danych pod dużym ruchem.

Podsumowanie - checklist dobrych praktyk

  1. Zawsze async/await dla operacji EF Core (ToListAsync, FirstOrDefaultAsync, SaveChangesAsync)
  2. Nigdy nie współdziel jednego DbContext między równoległymi taskami - twórz osobne scope'y
  3. ConfigureAwait(false) w warstwie repozytoriów/serwisów (nie dotyczy kodu UI, jak omawialiśmy przy WPF)
  4. Nigdy .Result/.Wait() na kodzie EF Core - ryzyko deadlocku
  5. Trzymaj IQueryable aż do materializacji (ToListAsync), żeby filtr/paginacja trafiły do SQL
  6. Propaguj CancellationToken przez cały łańcuch wywołań
Postaw mi kawę