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
IUserServicena mocka (np. Moq) i testujesz logikęLoadUserAsyncbez odpalania okna czy prawdziwego API. - Łatwa podmiana implementacji - w testach integracyjnych możesz zarejestrować
FakeUserServicezamiast prawdziwego HTTP. - Zarządzanie cyklem życia - kontener sam decyduje, czy dana zależność to
Singleton,ScopedczyTransient, zamiast ręcznegonewrozsianego 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
ObservablePropertyiRelayCommand(mniej boilerplate'u niż ręczneSetProperty/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łasnyNavigationStore+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.
Microsoft.Extensions.DependencyInjection, jak pokazywałem w przykładzie wyżej.