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

IServiceScopeFactory - pełny przykład

Problem, który rozwiązujemy

services.AddSingleton<INotificationManager, NotificationManager>();
services.AddScoped<IUserContext, UserContext>();

// BŁĄD - Captive Dependency
public class NotificationManager : INotificationManager
{
    public NotificationManager(IUserContext userContext) { ... } // ❌
}

Rozwiązanie: wstrzyknij factory, nie sam serwis

public class NotificationManager : INotificationManager
{
    private readonly IServiceScopeFactory _scopeFactory;

    // Wstrzykujemy fabrykę scope'ów - to jest bezpieczne dla Singletona,
    // bo IServiceScopeFactory sam jest zarejestrowany jako Singleton
    public NotificationManager(IServiceScopeFactory scopeFactory)
    {
        _scopeFactory = scopeFactory;
    }

    public async Task SendNotificationAsync(string message)
    {
        // Tworzymy NOWY scope w momencie, gdy faktycznie potrzebujemy
        // Scoped zależności - nie wcześniej, nie "na zapas"
        using (IServiceScope scope = _scopeFactory.CreateScope())
        {
            // Rozwiązujemy IUserContext DOPIERO wewnątrz tego scope'a
            var userContext = scope.ServiceProvider.GetRequiredService<IUserContext>();

            Console.WriteLine($"Wysyłam powiadomienie do: {userContext.CurrentUserName}");
            await SomeExternalService.SendAsync(userContext.CurrentUserName, message);
        }
        // Po wyjściu z using() - scope i wszystkie jego Scoped/Transient
        // zależności są zwalniane (Dispose)
    }
}

Kluczowa różnica: zamiast dostać IUserContext raz w konstruktorze (i trzymać go "na zawsze"), NotificationManager dostaje fabrykę, która przy każdym wywołaniu metody tworzy świeży, tymczasowy kontener ze swoim własnym IUserContext. Scope żyje tylko na czas bloku using, więc nic się nie "zamraża".

Jak to wygląda w praktyce z wieloma zależnościami

public class ReportGeneratorBackgroundService : BackgroundService
{
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly ILogger<ReportGeneratorBackgroundService> _logger;

    public ReportGeneratorBackgroundService(
        IServiceScopeFactory scopeFactory,
        ILogger<ReportGeneratorBackgroundService> logger)
    {
        _scopeFactory = scopeFactory;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            using (var scope = _scopeFactory.CreateScope())
            {
                // DbContext jest Scoped - w tle działającym Singletonie
                // (BackgroundService) nie mógłbyś go normalnie wstrzyknąć
                var dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
                var reportService = scope.ServiceProvider.GetRequiredService<IReportService>();

                var pendingOrders = await dbContext.Orders
                    .Where(o => !o.ReportGenerated)
                    .ToListAsync(stoppingToken);

                foreach (var order in pendingOrders)
                {
                    await reportService.GenerateAsync(order);
                }
            }

            await Task.Delay(TimeSpan.FromMinutes(5), stoppingToken);
        }
    }
}

To jest bardzo częsty wzorzec - BackgroundService w .NET jest zawsze Singletonem, więc jeśli potrzebuje DbContext (Scoped), zawsze musi przejść przez IServiceScopeFactory.

Rejestracja - nic dodatkowego nie trzeba robić

IServiceScopeFactory jest automatycznie dostępny w każdym IServiceCollection z Microsoft.Extensions.DependencyInjection - nie trzeba go rejestrować ręcznie.


Co znaczy "thread-safe"?

Thread-safe oznacza, że kod działa poprawnie, gdy wiele wątków wykonuje go jednocześnie i sięga do tych samych danych - bez uszkodzenia stanu, race conditions czy nieprzewidywalnych wyników.

Przykład kodu, który NIE jest thread-safe

public class CounterService
{
    private int _count = 0;

    public void Increment()
    {
        _count++; // ⚠️ To wygląda na jedną operację, ale nią nie jest!
    }

    public int GetCount() => _count;
}

_count++ to w rzeczywistości trzy oddzielne kroki: 1. Odczytaj wartość _count 2. Dodaj 1 3. Zapisz wynik z powrotem do _count

Jeśli dwa wątki wykonują to jednocześnie:

Wątek A: odczytuje _count = 5
Wątek B: odczytuje _count = 5      (jeszcze zanim A zapisał!)
Wątek A: liczy 5 + 1 = 6
Wątek B: liczy 5 + 1 = 6
Wątek A: zapisuje _count = 6
Wątek B: zapisuje _count = 6       ← nadpisuje wynik wątku A!

Efekt: wywołałeś Increment() dwa razy, a _count zwiększył się tylko o 1 zamiast o 2. To jest race condition - wynik zależy od tego, "który wątek zdąży pierwszy", czyli od przypadku/timingu.

Dlaczego to jest istotne akurat dla Singletona

Jeśli CounterService jest zarejestrowany jako Singleton:

services.AddSingleton<CounterService>();

...to wszystkie requesty/wątki w całej aplikacji dzielą tę samą instancję i to samo pole _count. Przy dużym ruchu, gdy wiele requestów przychodzi równolegle, ten race condition będzie się realnie zdarzał - i to sporadycznie, trudno do odtworzenia (klasyczny "heisenbug" - działa w debugerze, bo debugger spowalnia wykonanie i maskuje problem).

Gdyby CounterService był Transient albo Scoped, każdy wątek/request miałby swoją własną instancję ze swoim własnym _count - problem by nie istniał, bo nie ma współdzielonego stanu.

Jak naprawić - kilka podejść

1. lock - najprostsze, ale blokujące

public class CounterService
{
    private readonly object _lock = new object();
    private int _count = 0;

    public void Increment()
    {
        lock (_lock)
        {
            _count++; // tylko jeden wątek na raz może wejść do tego bloku
        }
    }
}

2. Interlocked - dla prostych operacji atomowych, bez blokady

public class CounterService
{
    private int _count = 0;

    public void Increment()
    {
        Interlocked.Increment(ref _count); // atomowa operacja na poziomie CPU
    }

    public int GetCount() => Interlocked.CompareExchange(ref _count, 0, 0);
}

3. ConcurrentDictionary, ConcurrentQueue itd. - gotowe kolekcje thread-safe

public class CacheService
{
    // zamiast zwykłego Dictionary<K,V>, które NIE jest thread-safe
    private readonly ConcurrentDictionary<string, User> _cache = new();

    public void Add(string key, User user) => _cache[key] = user;
    public User Get(string key) => _cache.TryGetValue(key, out var user) ? user : null;
}

Praktyczna zasada dla Singletonów

Jeśli Singleton ma mutowalny stan (pola, które się zmieniają po utworzeniu) - musi być thread-safe. Jeśli jest bezstanowy (immutable) albo tylko odczytuje dane raz ustawione przy starcie - problemu nie ma.

// OK bez synchronizacji - stan ustawiony raz, tylko odczyt
public class AppConfig
{
    public string ApiUrl { get; }
    public AppConfig(IConfiguration config) => ApiUrl = config["ApiUrl"];
}

// WYMAGA synchronizacji - stan się zmienia w trakcie działania
public class RequestCounter
{
    private int _totalRequests; // ⚠️ mutowalne, wielu wątków pisze jednocześnie
}

To zresztą częste pytanie na rozmowach: "Dlaczego DbContext w EF Core jest Scoped, a nie Singleton?" - odpowiedź brzmi właśnie: DbContext nie jest thread-safe (ma wewnętrzny change tracker, stan transakcji), więc gdyby był Singletonem, dwa równoległe requesty operujące na tym samym DbContext uszkodziłyby sobie nawzajem stan.

Postaw mi kawę