Dependency Injection w architekturze MVVM
Krótkie przypomnienie: czym jest MVVM
MVVM (Model-View-ViewModel) to wzorzec architektoniczny dzielący aplikację na trzy warstwy:
- Model - dane i logika biznesowa (np. pobieranie danych z API, baza danych)
- View - warstwa UI (komponenty, ekrany) - "głupia", tylko wyświetla
- ViewModel - pośrednik między Model a View - trzyma stan UI, reaguje na akcje użytkownika, woła Model
View "obserwuje" ViewModel (przez binding/reaktywność), a ViewModel nie wie nic o View - to kluczowe dla testowalności.
Gdzie w tym wszystkim jest DI?
Problem: ViewModel potrzebuje dostępu do Modelu (np. serwisu API, repozytorium danych), żeby wykonać swoją pracę. Pytanie brzmi - skąd ViewModel bierze te zależności?
Bez DI (źle) - ViewModel sam tworzy swoje zależności
public class UserProfileViewModel
{
private readonly UserApiService _apiService = new UserApiService(); // sztywno wpisana konkretna klasa
private readonly ConsoleLogger _logger = new ConsoleLogger();
public async Task LoadUser(string id)
{
_logger.Log("Loading user...");
var user = await _apiService.GetUser(id);
}
}
To narusza Dependency Inversion Principle, o którym rozmawialiśmy przy SOLID - ViewModel jest ciasno powiązany (tightly coupled) z konkretną implementacją UserApiService. Skutki:
- Nie da się podmienić na mocka w testach jednostkowych
- Nie da się użyć innego źródła danych (np. cache, inny endpoint) bez zmiany kodu ViewModelu
- Trudno zarządzać cyklem życia zależności (np. singleton vs nowa instancja)
Z DI (dobrze) - zależności są wstrzykiwane z zewnątrz
public interface IUserApiService
{
Task<User> GetUser(string id);
}
public interface ILogger
{
void Log(string message);
}
public class UserProfileViewModel
{
private readonly IUserApiService _apiService;
private readonly ILogger _logger;
public UserProfileViewModel(IUserApiService apiService, ILogger logger)
{
_apiService = apiService;
_logger = logger;
}
public async Task LoadUser(string id)
{
_logger.Log("Loading user...");
var user = await _apiService.GetUser(id);
}
}
// Tworzenie ViewModelu - zależności "wstrzyknięte" z zewnątrz
var viewModel = new UserProfileViewModel(
new UserApiService(),
new ConsoleLogger()
);
ViewModel zależy teraz od abstrakcji (interfejsów), nie od konkretnych klas - dokładnie zasada D z SOLID.
Dlaczego to jest szczególnie ważne właśnie w MVVM
- Testowalność ViewModelu bez UI - to główny sens MVVM. Możesz przetestować logikę ViewModelu, wstrzykując mocki zamiast prawdziwych serwisów:
var mockApiService = new Mock<IUserApiService>();
mockApiService.Setup(s => s.GetUser("1")).ReturnsAsync(new User { Id = "1", Name = "Test User" });
var viewModel = new UserProfileViewModel(mockApiService.Object, new NoOpLogger());
await viewModel.LoadUser("1");
mockApiService.Verify(s => s.GetUser("1"), Times.Once);
Bez DI musiałbyś odpalać prawdziwe requesty API w testach, albo robić brzydkie hacki z podmianą modułów.
-
Rozdzielenie odpowiedzialności - ViewModel nie musi wiedzieć, jak skonstruować swoje zależności (np. że
UserApiServicepotrzebuje URL-a bazowego, tokenu auth itd.) - to zadanie zewnętrznego "kompozytora". -
Reużywalność - ten sam ViewModel może działać z różnymi implementacjami (np.
FakeUserApiServicew trybie offline/demo).
Kontener DI (Dependency Injection Container)
W większych aplikacjach ręczne tworzenie i przekazywanie zależności (jak wyżej) robi się uciążliwe, więc używa się kontenera DI, który automatycznie tworzy i wstrzykuje zależności na podstawie rejestracji:
using Microsoft.Extensions.DependencyInjection; // pakiet NuGet z tym samym API co w ASP.NET Core
// 1. Stwórz kolekcję serwisów - to jest "rejestr", w którym zapisujesz,
// co ma być czym (interfejs -> konkretna implementacja)
var services = new ServiceCollection();
// 2. Rejestracja (raz, przy starcie aplikacji)
services.AddSingleton<ILogger, ConsoleLogger>();
services.AddSingleton<IUserApiService, UserApiService>();
// WAŻNE: ViewModel też musi być zarejestrowany, inaczej GetRequiredService
// poniżej rzuci wyjątkiem "Unable to resolve service" - resolwowanie
// dotyczy WSZYSTKIEGO, co ma powstać przez kontener, nie tylko "usług"
services.AddTransient<UserProfileViewModel>();
// 3. Zbuduj kontener (IServiceProvider) na podstawie rejestracji z kroku 2 -
// to jest moment, w którym "rejestr" zamienia się w działający kontener
var serviceProvider = services.BuildServiceProvider();
// 4. Rozwiązywanie zależności (automatyczne) - kontener SAM wywoła konstruktor
// UserProfileViewModel, wstrzykując mu ILogger i IUserApiService
var viewModel = serviceProvider.GetRequiredService<UserProfileViewModel>();
Co robi każdy krok: ServiceCollection to pusta lista rejestracji - sama nie umie jeszcze niczego tworzyć. Metody Add* (AddSingleton, AddTransient, AddScoped) tylko dopisują wpis "gdy ktoś poprosi o X, dawaj Y". BuildServiceProvider() kompiluje te wpisy w faktyczny, działający kontener - to jest moment, w którym kontener sprawdza, czy da się wszystko poskładać. GetRequiredService<T>() dopiero wtedy faktycznie tworzy instancję, wywołując konstruktor i wstrzykując zarejestrowane zależności.
Popularne przykłady w różnych ekosystemach:
- Android (Kotlin/Java): Hilt, Koin, Dagger
- iOS (Swift): Swinject, Resolver
- .NET/WPF: Microsoft.Extensions.DependencyInjection, Autofac
- Angular: wbudowany DI container
- Frontend TS ogólnie: tsyringe, InversifyJS
Podsumowanie w jednym zdaniu
DI w MVVM sprawia, że ViewModel dostaje swoje zależności (serwisy, repozytoria) zamiast tworzyć je sam - dzięki temu można go testować w izolacji od UI i od konkretnych implementacji danych, co jest właściwie sensem istnienia całego wzorca MVVM.