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ę.