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

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

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

  1. Rozdzielenie odpowiedzialności - ViewModel nie musi wiedzieć, jak skonstruować swoje zależności (np. że UserApiService potrzebuje URL-a bazowego, tokenu auth itd.) - to zadanie zewnętrznego "kompozytora".

  2. Reużywalność - ten sam ViewModel może działać z różnymi implementacjami (np. FakeUserApiService w 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.

Postaw mi kawę