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

Sposoby wdrożenia DI (Dependency Injection)

Na rozmowie to pytanie zwykle sprawdza, czy znasz nie tylko "DI przez konstruktor", ale też pozostałe warianty i kiedy który stosować - to częsty follow-up po temacie DI.

1. Constructor Injection - domyślny wybór (99% przypadków)

Zależności przekazywane przez konstruktor, przypisywane do readonly pól.

public class OrderService : IOrderService
{
    private readonly IOrderRepository _repository;
    private readonly ILogger<OrderService> _logger;

    public OrderService(IOrderRepository repository, ILogger<OrderService> logger)
    {
        _repository = repository ?? throw new ArgumentNullException(nameof(repository));
        _logger = logger;
    }
}

Zalety: - Immutability - readonly, zależność nie może się zmienić po utworzeniu obiektu - Fail-fast - obiekt nie może w ogóle powstać bez wymaganych zależności (błąd wykryty od razu przy starcie, nie w trakcie działania) - Jawność - patrząc na konstruktor, od razu widzisz WSZYSTKIE zależności klasy - Kontenery DI (Microsoft.Extensions.DependencyInjection, Autofac) używają tego jako domyślnego mechanizmu

Wada: przy wielu zależnościach konstruktor się rozrasta (patrz "constructor bloat" niżej).

2. Property Injection (Setter Injection)

Zależność ustawiana przez publiczną właściwość, nie przez konstruktor.

public class ReportGenerator
{
    // Zależność opcjonalna - jeśli nie ustawiona, klasa i tak działa (z domyślnym zachowaniem)
    public ILogger Logger { get; set; } = NullLogger.Instance;

    public void Generate(Report report)
    {
        Logger.Log("Generowanie raportu...");
        // ...
    }
}
var generator = new ReportGenerator();
generator.Logger = new FileLogger(); // opcjonalne nadpisanie

Kiedy używać: - Zależność jest opcjonalna (klasa działa sensownie bez niej, z wartością domyślną) - Framework wymusza bezparametrowy konstruktor (np. niektóre starsze frameworki serializacji, kontrolki WPF tworzone przez XAML parser)

Wada: obiekt może istnieć w niepełnym, "połowicznym" stanie - nic nie gwarantuje, że ktoś ustawi property przed użyciem klasy. Brak fail-fast.

3. Method Injection (Parameter Injection)

Zależność przekazywana jako parametr konkretnej metody, nie przechowywana w polu klasy.

public class OrderProcessor
{
    // Nie każda metoda w klasie potrzebuje tej zależności -
    // tylko ta jedna, więc nie ma sensu trzymać jej jako pole
    public void ProcessOrder(Order order, IDiscountCalculator discountCalculator)
    {
        var discount = discountCalculator.Calculate(order);
        order.TotalAmount -= discount;
    }
}

Kiedy używać: - Zależność potrzebna tylko w jednej metodzie, nie w całej klasie - Zależność zmienia się przy każdym wywołaniu (np. różne strategie przekazywane za każdym razem) - Klasyczny przykład: IComparer<T> przekazywany do List<T>.Sort(IComparer<T> comparer)

4. Ambient Context (rzadziej, kontrowersyjny)

Zależność dostępna globalnie, bez jawnego przekazywania - np. przez statyczną właściwość albo AsyncLocal.

public static class CurrentUser
{
    private static readonly AsyncLocal<string> _userId = new();
    public static string UserId
    {
        get => _userId.Value;
        set => _userId.Value = value;
    }
}

// Użycie gdziekolwiek, bez przekazywania przez konstruktor
public class AuditLogger
{
    public void Log(string action)
    {
        Console.WriteLine($"{CurrentUser.UserId}: {action}");
    }
}

Rzadko polecane - ukrywa prawdziwe zależności klasy (nie widać ich w konstruktorze), utrudnia testowanie (globalny stan współdzielony między testami) i thread-safety wymaga ostrożności. Realny przykład wbudowany w .NET: Thread.CurrentPrincipal, HttpContext.Current (stary ASP.NET).

5. Service Locator - anty-pattern, ale warto znać

Zamiast wstrzykiwać konkretne zależności, klasa dostaje dostęp do "lokalizatora usług" i sama sobie z niego pobiera to, czego potrzebuje.

// ❌ Anty-pattern
public class OrderService
{
    public void ProcessOrder(Order order)
    {
        var repository = ServiceLocator.Current.GetInstance<IOrderRepository>();
        var logger = ServiceLocator.Current.GetInstance<ILogger>();
        // ...
    }
}

Dlaczego to anty-pattern (częste pytanie na rozmowie: "dlaczego Service Locator jest zły"): - Ukryte zależności - patrząc na konstruktor/sygnaturę klasy, nie widzisz, czego ona faktycznie potrzebuje - dowiadujesz się dopiero czytając całą implementację - Klasa zależy teraz od samego kontenera DI, a nie od abstrakcji - to odwraca sens Dependency Inversion Principle - Błędy brakującej rejestracji wychodzą w runtime, przy konkretnym wywołaniu GetInstance<T>(), zamiast przy starcie aplikacji (fail-fast) jak w constructor injection - Trudniejsze testowanie - musisz mockować cały ServiceLocator, zamiast pojedynczej zależności

To jest zresztą różnica względem IServiceScopeFactory, o którym mówiliśmy przy Singletonach - CreateScope() + GetRequiredService<T>() wygląda podobnie do Service Locatora, ale różnica jest istotna: robisz to świadomie, w jednym konkretnym miejscu, żeby rozwiązać problem cyklu życia (Scoped w Singletonie), a nie jako generalny sposób dostarczania wszystkich zależności w całej aplikacji.

Porównanie w tabeli

Sposób Kiedy używać Fail-fast? Widoczność zależności
Constructor Injection Domyślny wybór, zależności wymagane ✅ Tak ✅ Pełna, w sygnaturze
Property Injection Zależność opcjonalna ❌ Nie ⚠️ Częściowa
Method Injection Zależność tylko w jednej metodzie ✅ Tak (na poziomie metody) ✅ W sygnaturze metody
Ambient Context Rzadko - dane przekrojowe (np. user context) ❌ Nie ❌ Ukryte
Service Locator Unikać ❌ Nie (dopiero w runtime) ❌ Całkowicie ukryte

Pytanie, które mogą zadać jako follow-up

"Co robisz, gdy konstruktor ma 8 zależności?" - to jest tzw. constructor bloat/over-injection, i dobra odpowiedź to nie "po prostu tak zostawiam", tylko rozpoznanie, że to sygnał złamania Single Responsibility Principle (wracamy do SOLID) - klasa robi prawdopodobnie zbyt wiele różnych rzeczy i warto ją rozbić na mniejsze, bardziej wyspecjalizowane klasy, z których każda ma 2-3 zależności.


Konstruktor jest tym, czego prawie zawsze będziesz używać w praktyce - ale rozmówca może chcieć usłyszeć, że rozumiesz kompromisy pozostałych podejść, a nie tylko znasz jedną nazwę.

Postaw mi kawę