C# / .NET Kompendium PLEN
.NET / C# / SOLID, Clean Code, DI

DI: cykle życia usług i najczęstsze pułapki

Podstawy (czym są Singleton, Scoped i Transient) są w temacie Singleton vs Transient vs Scoped. Tutaj są pułapki, które wychodzą w prawdziwych projektach, z gotowymi przykładami kodu.

Najpierw najważniejsze: lifetime nie decyduje o tym, który moduł dostaje którą implementację. Decyduje o tym, jak długo żyje instancja i kto ją współdzieli. Pułapka z IUnitOfWork (punkt 6) to inna sprawa: przy kilku rejestracjach tego samego typu GetService<T> zwraca ostatnią. Z Scoped czy z Singleton wynik byłby ten sam: jeśli kilka modułów rejestruje własny IUnitOfWork, moduł Customers może dostać IdentityDbContext, bo ten został zarejestrowany jako ostatni.

Trzy cykle życia

Lifetime Instancja Typowe użycie
Transient nowa przy każdym rozwiązaniu (każde wstrzyknięcie, każde GetService) lekkie, bezstanowe usługi
Scoped jedna na scope; w ASP.NET Core scope = jedno żądanie HTTP DbContext, Unit of Work, repozytoria, ICurrentUser
Singleton jedna na cały kontener, żyje do końca aplikacji cache, konfiguracja, zegar; musi być thread-safe

Zasada: zależność musi żyć co najmniej tak długo jak usługa, która ją trzyma. Singleton może zależeć tylko od singletonów, scoped od scoped i singletonów, transient od czegokolwiek.

Pułapki

1. Captive dependency (zależność uwięziona)

Singleton dostaje w konstruktorze usługę scoped, więc trzyma ją do końca życia aplikacji. Przy DbContext oznacza to jeden kontekst dla wszystkich żądań: rosnący change tracker, nieaktualne dane i wyjątki przy równoległych żądaniach.

// BAD: singleton captures a scoped DbContext forever
services.AddSingleton<PriceCache>();
public sealed class PriceCache(CustomersDbContext dbContext) { }

Transient wstrzyknięty do singletona też staje się w praktyce singletonem. Walidacja tego nie zgłosi, więc jest groźne tylko wtedy, gdy ten transient trzyma stan.

2. ValidateScopes / ValidateOnBuild

ValidateScopes rzuca wyjątek przy captive dependency i przy rozwiązywaniu usługi scoped z root providera. ValidateOnBuild przy starcie sprawdza, czy da się zbudować każdą rejestrację. W Development oba są włączone domyślnie (WebApi i Worker przez Host.CreateApplicationBuilder). Warto je włączyć zawsze, bo testy integracyjne często nie działają w Development:

builder.Host.UseDefaultServiceProvider(options =>
{
    options.ValidateScopes = true;
    options.ValidateOnBuild = true;
});

Ograniczenie: walidacja nie zajrzy do środka fabryk sp => ....

3. DbContext nie jest thread-safe

AddDbContext rejestruje go jako scoped, czyli jeden na żądanie. Dwie równoległe operacje na tym samym kontekście kończą się błędem „A second operation was started on this context”:

// BAD: two concurrent operations on the same DbContext
await Task.WhenAll(
    dbContext.Customers.ToListAsync(cancellationToken),
    dbContext.Contacts.ToListAsync(cancellationToken));

Przy równoległości albo w singletonie używaj AddDbContextFactory + IDbContextFactory<T> i twórz osobny kontekst dla każdej operacji.

4. Transient IDisposable z root providera

Kontener zapamiętuje każdy obiekt IDisposable, który sam utworzył, i zwalnia go razem ze swoim scope. Root scope kończy się dopiero z aplikacją, więc app.Services.GetService<SomeDisposableTransient>() w pętli daje wyciek pamięci.

Druga strona tej zasady: nigdy nie wywołuj Dispose na wstrzykniętej usłudze, bo jej właścicielem jest kontener.

5. BackgroundService w Workerze to singleton

Nie wstrzykuj do niego DbContextu (punkt 1). Wstrzyknij IServiceScopeFactory i twórz scope na jedną jednostkę pracy:

public sealed class OutboxWorker(IServiceScopeFactory scopeFactory) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken cancellationToken)
    {
        while (!cancellationToken.IsCancellationRequested)
        {
            // One scope per iteration = fresh DbContext, disposed at the end
            await using var scope = scopeFactory.CreateAsyncScope();
            var dbContext = scope.ServiceProvider.GetRequiredService<CustomersDbContext>();
            // ... process batch ...
            await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken);
        }
    }
}

To samo dotyczy middleware z klasą konwencjonalną (jest singletonem). Usługi scoped wstrzykujesz wtedy jako parametr InvokeAsync, a nie do konstruktora.

6. Wiele rejestracji tego samego typu (pułapka z IUnitOfWork)

  • GetRequiredService<IUnitOfWork>() zwraca ostatnią rejestrację i nie zgłasza żadnego błędu.
  • IEnumerable<IUnitOfWork> zwraca wszystkie, w kolejności rejestracji.
  • TryAddScoped dodaje rejestrację tylko wtedy, gdy żadnej jeszcze nie ma. To nie jest naprawa, bo wtedy po cichu wygrywa pierwsza zamiast ostatniej.
  • TryAddEnumerable blokuje duplikat tej samej pary interfejs + implementacja. Przydaje się przy rejestrowaniu np. wielu handlerów zdarzeń.

7. Forwarding: jedna instancja pod dwoma typami

To bardzo realna pułapka przy DbContext per moduł:

// BAD: builds a SECOND CustomersDbContext in the same scope.
// Repository adds to instance A, SaveChanges runs on instance B -> nothing saved.
services.AddScoped<ICustomersUnitOfWork, CustomersDbContext>();

// GOOD: forward to the instance registered by AddDbContext
services.AddScoped<ICustomersUnitOfWork>(sp => sp.GetRequiredService<CustomersDbContext>());

Ten sam mechanizm działa przy singletonach. AddSingleton<IFoo, Foo>() i AddSingleton<IBar, Foo>() tworzą dwa różne obiekty Foo.

8. Keyed services (.NET 8+)

Pozwalają zarejestrować kilka implementacji pod kluczami:

services.AddKeyedScoped<IUnitOfWork>("customers",
    (sp, _) => sp.GetRequiredService<CustomersDbContext>());

public sealed class CreatePersonHandler([FromKeyedServices("customers")] IUnitOfWork unitOfWork) { }

Działa, ale klucz to string i literówka wychodzi dopiero w runtime. Osobny interfejs per moduł (ICustomersUnitOfWork) sprawdza kompilator, więc to argument za takim rozwiązaniem zamiast kluczy.

Krótko o dwóch innych rzeczach

  • IOptions<T> to singleton, IOptionsSnapshot<T> jest scoped (nie wstrzykniesz go do singletona), a IOptionsMonitor<T> to singleton z odświeżaniem.
  • Typed HttpClient jest transient, więc nie trzymaj go w singletonie.

Pytania sprawdzające

  1. ICurrentUser (czyta usera z HttpContext) zarejestrowany jako singleton. Co się stanie i czy ValidateScopes to wyłapie?
  2. Dwa moduły robią TryAddScoped<IUnitOfWork, ...>. Który wygra i dlaczego problem nadal istnieje?
  3. Repozytorium dostaje CustomersDbContext, a handler ICustomersUnitOfWork zarejestrowany jako AddScoped<ICustomersUnitOfWork, CustomersDbContext>(). Co zobaczysz w bazie po SaveChangesAsync?
  4. Worker przetwarza 100 wiadomości z kolejki. Ile scope'ów powinien utworzyć i dlaczego nie jeden?
  5. Czy transient zależny od scoped to błąd? A scoped zależny od transient?

Zobacz też

Postaw mi kawę