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

MVVM + DI w WPF (C#)

Skoro masz duże doświadczenie w C#/.NET, pokażę pełny, realistyczny przepływ na typowej aplikacji WPF.

Struktura projektu

MyApp/
├── Models/
│   └── User.cs
├── Services/
│   ├── IUserService.cs
│   └── UserService.cs
├── ViewModels/
│   ├── ViewModelBase.cs
│   └── UserProfileViewModel.cs
├── Views/
│   └── UserProfileView.xaml
├── App.xaml.cs

1. Model

public class User
{
    public string Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

2. Serwis (abstrakcja + implementacja)

public interface IUserService
{
    Task<User> GetUserAsync(string id);
}

public class UserService : IUserService
{
    private readonly HttpClient _httpClient;

    public UserService(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    public async Task<User> GetUserAsync(string id)
    {
        var response = await _httpClient.GetFromJsonAsync<User>($"api/users/{id}");
        return response;
    }
}

3. ViewModelBase (INotifyPropertyChanged)

To fundament każdego ViewModelu w WPF - implementuje mechanizm powiadamiania View o zmianach.

public abstract class ViewModelBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected void SetProperty<T>(ref T field, T value, [CallerMemberName] string propertyName = null)
    {
        if (EqualityComparer<T>.Default.Equals(field, value)) return;
        field = value;
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

4. ViewModel z wstrzykniętymi zależnościami

public class UserProfileViewModel : ViewModelBase
{
    private readonly IUserService _userService;
    private readonly ILogger<UserProfileViewModel> _logger;

    private User _user;
    public User User
    {
        get => _user;
        set => SetProperty(ref _user, value);
    }

    private bool _isLoading;
    public bool IsLoading
    {
        get => _isLoading;
        set => SetProperty(ref _isLoading, value);
    }

    public ICommand LoadUserCommand { get; }

    // Zależności przychodzą z zewnątrz przez konstruktor - to jest sedno DI
    public UserProfileViewModel(IUserService userService, ILogger<UserProfileViewModel> logger)
    {
        _userService = userService;
        _logger = logger;
        LoadUserCommand = new RelayCommand(async () => await LoadUserAsync());
    }

    private async Task LoadUserAsync()
    {
        try
        {
            IsLoading = true;
            _logger.LogInformation("Loading user...");
            User = await _userService.GetUserAsync("123");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to load user");
        }
        finally
        {
            IsLoading = false;
        }
    }
}

Zauważ: ViewModel nic nie wie o HttpClient, o URL-u API, o tym jak działa logowanie - dostaje gotowe, skonfigurowane zależności przez konstruktor. To jest właśnie constructor injection, najpopularniejsza forma DI w .NET.

5. RelayCommand (prosta implementacja ICommand)

WPF nie ma wbudowanego dobrego ICommand, więc prawie każdy projekt ma swój RelayCommand:

public class RelayCommand : ICommand
{
    private readonly Func<Task> _execute;
    private readonly Func<bool> _canExecute;

    public RelayCommand(Func<Task> execute, Func<bool> canExecute = null)
    {
        _execute = execute;
        _canExecute = canExecute;
    }

    public bool CanExecute(object parameter) => _canExecute?.Invoke() ?? true;
    public async void Execute(object parameter) => await _execute();
    public event EventHandler CanExecuteChanged
    {
        add => CommandManager.RequerySuggested += value;
        remove => CommandManager.RequerySuggested -= value;
    }
}

6. Konfiguracja kontenera DI w App.xaml.cs

Tu spina się cała układanka - Microsoft.Extensions.DependencyInjection (ten sam, który znasz z ASP.NET Core) świetnie działa też w WPF.

public partial class App : Application
{
    private ServiceProvider _serviceProvider;

    protected override void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);

        var services = new ServiceCollection();
        ConfigureServices(services);
        _serviceProvider = services.BuildServiceProvider();

        // Rozwiązanie głównego okna z jego ViewModelem
        var mainWindow = _serviceProvider.GetRequiredService<MainWindow>();
        mainWindow.Show();
    }

    private void ConfigureServices(IServiceCollection services)
    {
        services.AddLogging(builder => builder.AddConsole());

        services.AddHttpClient<IUserService, UserService>(client =>
        {
            client.BaseAddress = new Uri("https://api.myapp.pl/");
        });

        // ViewModel jako Transient - nowa instancja przy każdym rozwiązaniu
        services.AddTransient<UserProfileViewModel>();

        // View - MainWindow też może dostać ViewModel przez konstruktor
        services.AddSingleton<MainWindow>();
    }

    protected override void OnExit(ExitEventArgs e)
    {
        _serviceProvider?.Dispose();
        base.OnExit(e);
    }
}

7. Wstrzykiwanie ViewModelu do View

public partial class MainWindow : Window
{
    public MainWindow(UserProfileViewModel viewModel)
    {
        InitializeComponent();
        DataContext = viewModel; // View "obserwuje" ViewModel przez binding
    }
}

I w XAML:

<Window x:Class="MyApp.Views.MainWindow" ...>
    <StackPanel>
        <TextBlock Text="{Binding User.Name}" />
        <Button Content="Załaduj" Command="{Binding LoadUserCommand}" />
        <ProgressBar IsIndeterminate="{Binding IsLoading}" Visibility="{Binding IsLoading, Converter={StaticResource BoolToVisibility}}" />
    </StackPanel>
</Window>

Dlaczego to podejście się opłaca

  • Testy jednostkowe ViewModelu bez WPF w ogóle - podmieniasz IUserService na mocka (np. Moq) i testujesz logikę LoadUserAsync bez odpalania okna czy prawdziwego API.
  • Łatwa podmiana implementacji - w testach integracyjnych możesz zarejestrować FakeUserService zamiast prawdziwego HTTP.
  • Zarządzanie cyklem życia - kontener sam decyduje, czy dana zależność to Singleton, Scoped czy Transient, zamiast ręcznego new rozsianego po kodzie.
  • Czytelna kompozycja aplikacji w jednym miejscu (ConfigureServices) - widzisz od razu, z czego składa się cała apka.

Popularne biblioteki DI dla WPF

  • Microsoft.Extensions.DependencyInjection - najlżejszy, ten sam co w ASP.NET Core (użyłem powyżej)
  • Prism - pełny framework MVVM dla WPF, ma wbudowany DI + nawigację + regiony
  • CommunityToolkit.Mvvm - lekki toolkit od Microsoftu z generatorami dla ObservableProperty i RelayCommand (mniej boilerplate'u niż ręczne SetProperty/RelayCommand)

Przykład pełnej aplikacji WPF/MVVM - SimpleTrader

Jeśli chcesz zobaczyć te wzorce (MVVM, DI, ViewModelBase, RelayCommand, nawigacja między widokami) zastosowane w kompletnej, realistycznej aplikacji - nie w wyizolowanym fragmencie kodu - warto obejrzeć projekt SimpleTrader autorstwa SingletonSean:

Repozytorium: github.com/SingletonSean/SimpleTrader Playlista wideo (krok po kroku): YouTube - SingletonSean

To pełna aplikacja WPF do "handlu" (symulowana giełda), budowana od zera, odcinek po odcinku, obejmująca dokładnie te tematy, które omawialiśmy:

  • MVVM od podstaw - ViewModelBase, INotifyPropertyChanged, RelayCommand
  • Dependency Injection - własny, ręcznie pisany kontener DI (bez Microsoft.Extensions.DependencyInjection), co jest edukacyjnie wartościowe - widzisz jak kontener DI działa "pod spodem", zanim zaczniesz używać gotowego
  • Nawigacja między widokami w WPF bez Frame/NavigationService (WPF go nie ma natywnie jak np. UWP) - własny NavigationStore + NavigationService
  • Warstwa serwisów - komunikacja z backendem (autentykacja, dane konta) przez HTTP
  • Wzorzec Store - współdzielony stan aplikacji (np. zalogowany użytkownik) dostępny z wielu ViewModeli naraz

Dlaczego warto: większość tutoriali o MVVM pokazuje pojedynczy ekran z jednym przyciskiem - SimpleTrader pokazuje, jak te wzorce skalują się w aplikacji z wieloma widokami, ekranem logowania, nawigacją i realną komunikacją z backendem, czyli bliżej temu, z czym można się spotkać w pracy.

Uwaga: projekt używa własnoręcznie pisanego kontenera DI (do celów edukacyjnych) - w kodzie produkcyjnym naturalnym wyborem byłby Microsoft.Extensions.DependencyInjection, jak pokazywałem w przykładzie wyżej.
Postaw mi kawę