C# / .NET Kompendium PLEN
.NET / C# / WPF

ICommand w WPF

Problem, który ICommand rozwiązuje

W code-behind (podejście bez MVVM) obsługa kliknięcia wygląda tak:

<Button Content="Zapisz" Click="SaveButton_Click" />
private void SaveButton_Click(object sender, RoutedEventArgs e)
{
    SaveOrder();
}

To działa, ale łamie MVVM - View (code-behind) bezpośrednio zawiera logikę biznesową, ViewModel nie ma jak tego przetestować bez UI, a Click to zwykły event .NET, więc trudno np. automatycznie wyłączyć przycisk, gdy akcja nie ma sensu (np. brak danych do zapisania).

ICommand to interfejs, który pozwala zbindować akcję UI (kliknięcie, skrót klawiszowy, menu) bezpośrednio do metody w ViewModelu, bez żadnego code-behind, plus dodaje wbudowaną obsługę "czy ta akcja jest w ogóle dostępna teraz".

Definicja interfejsu

public interface ICommand
{
    void Execute(object parameter);
    bool CanExecute(object parameter);
    event EventHandler CanExecuteChanged;
}

Trzy elementy: - Execute - co się dzieje, gdy komenda jest wywołana (odpowiednik ciała Click handlera) - CanExecute - czy komenda jest aktualnie dostępna (zwraca bool) - WPF automatycznie na tej podstawie wyszarza/aktywuje kontrolkę - CanExecuteChanged - event informujący WPF "sprawdź CanExecute jeszcze raz, mogło się coś zmienić"

Binding w XAML

<Button Content="Zapisz" Command="{Binding SaveOrderCommand}" />

Zamiast Click="..." (event w code-behind) - Command="{Binding ...}" wskazuje na właściwość typu ICommand w ViewModelu. To jest zwykły data binding, dokładnie taki sam mechanizm jak przy Text="{Binding Name}".

Własna implementacja - RelayCommand

WPF nie ma wbudowanej gotowej klasy implementującej ICommand do ogólnego użytku (ma tylko wyspecjalizowane, np. do edycji tekstu), więc prawie każdy projekt pisze własną, zwykle nazywaną RelayCommand albo DelegateCommand:

public class RelayCommand : ICommand
{
    private readonly Action<object> _execute;
    private readonly Predicate<object> _canExecute;

    public RelayCommand(Action<object> execute, Predicate<object> canExecute = null)
    {
        _execute = execute ?? throw new ArgumentNullException(nameof(execute));
        _canExecute = canExecute;
    }

    public bool CanExecute(object parameter) => _canExecute?.Invoke(parameter) ?? true;

    public void Execute(object parameter) => _execute(parameter);

    public event EventHandler CanExecuteChanged
    {
        // Podpina się pod wbudowany mechanizm WPF, który odpytuje
        // wszystkie komendy przy każdej zmianie fokusu/stanu UI
        add => CommandManager.RequerySuggested += value;
        remove => CommandManager.RequerySuggested -= value;
    }
}

Użycie w ViewModelu:

public class OrderViewModel : ViewModelBase
{
    private readonly IOrderService _orderService;

    public Order CurrentOrder { get; set; }

    public ICommand SaveOrderCommand { get; }

    public OrderViewModel(IOrderService orderService)
    {
        _orderService = orderService;

        SaveOrderCommand = new RelayCommand(
            execute: _ => SaveOrder(),
            canExecute: _ => CurrentOrder != null && CurrentOrder.Items.Count > 0
        );
    }

    private void SaveOrder()
    {
        _orderService.Save(CurrentOrder);
    }
}

Efekt w UI: dopóki CurrentOrder jest null albo nie ma żadnych pozycji, Button bindowany do SaveOrderCommand jest automatycznie wyszarzony (IsEnabled = false) - bez ani jednej linijki kodu w code-behind czy XAML odpowiedzialnej za to ręcznie.

CommandManager.RequerySuggested - jak to "automagicznie" działa

To jest szczegół, o który czasem pytają, bo wygląda jak magia. CommandManager w WPF nasłuchuje typowych zdarzeń UI (kliknięcia, naciśnięcia klawiszy, zmiana fokusu) i po każdym z nich automatycznie wywołuje CanExecute na wszystkich zarejestrowanych komendach, żeby sprawdzić, czy stan IsEnabled przycisków powinien się zmienić.

Problem z tym podejściem: RequerySuggested reaguje tylko na zdarzenia inputowe UI - jeśli zmieniasz CurrentOrder.Items programistycznie (np. w kodzie po odpowiedzi z API, bez żadnej interakcji użytkownika), CommandManager nie wie, że powinien przeliczyć CanExecute. Wtedy trzeba to wymusić ręcznie:

private void AddItem(OrderItem item)
{
    CurrentOrder.Items.Add(item);
    CommandManager.InvalidateRequerySuggested(); // ręcznie każ WPF przeliczyć wszystkie CanExecute
}

Lepsza wersja: RelayCommand z jawną kontrolą nad CanExecuteChanged

Wielu programistów unika polegania na globalnym CommandManager (bo odpytuje wszystkie komendy w aplikacji przy każdym kliknięciu - narzut przy dużych aplikacjach) i zamiast tego kontroluje to jawnie:

public class RelayCommand : ICommand
{
    private readonly Action<object> _execute;
    private readonly Predicate<object> _canExecute;

    public RelayCommand(Action<object> execute, Predicate<object> canExecute = null)
    {
        _execute = execute;
        _canExecute = canExecute;
    }

    public bool CanExecute(object parameter) => _canExecute?.Invoke(parameter) ?? true;
    public void Execute(object parameter) => _execute(parameter);

    public event EventHandler CanExecuteChanged;

    // Wywoływane ręcznie, dokładnie wtedy, kiedy WIADOMO, że coś się zmieniło
    public void RaiseCanExecuteChanged() => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
}
private void AddItem(OrderItem item)
{
    CurrentOrder.Items.Add(item);
    ((RelayCommand)SaveOrderCommand).RaiseCanExecuteChanged(); // precyzyjnie, tylko ta komenda
}

To bardziej wydajne, ale wymaga pamiętać o ręcznym wywołaniu w każdym miejscu, gdzie zmienia się warunek CanExecute.

Wersja generyczna - typowany parametr

W praktyce często chcesz uniknąć rzutowania object w środku:

public class RelayCommand<T> : ICommand
{
    private readonly Action<T> _execute;
    private readonly Predicate<T> _canExecute;

    public RelayCommand(Action<T> execute, Predicate<T> canExecute = null)
    {
        _execute = execute;
        _canExecute = canExecute;
    }

    public bool CanExecute(object parameter) => _canExecute?.Invoke((T)parameter) ?? true;
    public void Execute(object parameter) => _execute((T)parameter);

    public event EventHandler CanExecuteChanged
    {
        add => CommandManager.RequerySuggested += value;
        remove => CommandManager.RequerySuggested -= value;
    }
}

// Użycie
public ICommand DeleteOrderCommand => new RelayCommand<Order>(order => _orderService.Delete(order));
<Button Content="Usuń" Command="{Binding DeleteOrderCommand}" CommandParameter="{Binding SelectedOrder}" />

CommandParameter w XAML pozwala przekazać dowolny obiekt jako argument do Execute/CanExecute - tu np. aktualnie zaznaczone zamówienie z ListBox.

Async Command - częsty problem praktyczny

ICommand.Execute zwraca void, więc nie da się naturalnie zrobić async Task Execute(...) - trzeba to obejść:

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

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

    public bool CanExecute(object parameter) => !_isExecuting && (_canExecute?.Invoke() ?? true);

    public async void Execute(object parameter) // async void - konieczne, bo interfejs wymaga void
    {
        _isExecuting = true;
        RaiseCanExecuteChanged(); // np. wyszarz przycisk na czas trwania operacji

        try
        {
            await _execute();
        }
        finally
        {
            _isExecuting = false;
            RaiseCanExecuteChanged();
        }
    }

    public event EventHandler CanExecuteChanged;
    public void RaiseCanExecuteChanged() => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
}
SaveOrderCommand = new AsyncRelayCommand(
    execute: SaveOrderAsync,
    canExecute: () => CurrentOrder != null
);

private async Task SaveOrderAsync()
{
    await _orderService.SaveAsync(CurrentOrder);
}

async void Execute(...) to jedyne miejsce, gdzie async void jest akceptowalne (zamiast async Task) - bo interfejs ICommand narzuca sygnaturę void. To zresztą częste pytanie-pułapka na rozmowie: "dlaczego generalnie unikamy async void, i gdzie jest wyjątek?" - odpowiedź: unikamy, bo wyjątki z async void nie da się złapać przez zwykły try/catch wywołującego (lecą prosto do SynchronizationContext/crashują appkę), ale ICommand.Execute to jeden z niewielu miejsc, gdzie nie mamy wyboru.

CommunityToolkit.Mvvm - nowoczesne podejście (mniej boilerplate'u)

Skoro wspominałem to wcześniej - większość tego kodu można dziś zastąpić atrybutem:

public partial class OrderViewModel : ObservableObject
{
    [ObservableProperty]
    private Order _currentOrder;

    [RelayCommand(CanExecute = nameof(CanSaveOrder))]
    private async Task SaveOrderAsync()
    {
        await _orderService.SaveAsync(CurrentOrder);
    }

    private bool CanSaveOrder() => CurrentOrder != null && CurrentOrder.Items.Count > 0;
}

Generator źródłowy sam tworzy SaveOrderCommand jako IAsyncRelayCommand, z pełną obsługą CanExecute i RaiseCanExecuteChanged wywoływanym automatycznie przy zmianie CurrentOrder (dzięki [ObservableProperty]).

Podsumowanie - dlaczego to jest lepsze niż zwykły Click

Click (event) ICommand
Gdzie logika Code-behind (łamie MVVM) ViewModel (zgodne z MVVM)
Testowalność Trudna (wymaga UI) Łatwa (wywołujesz Execute() bezpośrednio w teście)
Automatyczne enable/disable Musisz robić ręcznie Wbudowane przez CanExecute
Reużywalność Handler przywiązany do konkretnej kontrolki Ta sama komenda może być bindowana z wielu miejsc (przycisk, menu, skrót klawiszowy)

Ostatni punkt jest niedoceniany - jedna komenda SaveOrderCommand może być jednocześnie podpięta pod przycisk, pozycję w menu i skrót klawiszowy Ctrl+S, bez duplikowania logiki:

<Button Command="{Binding SaveOrderCommand}" Content="Zapisz" />
<MenuItem Command="{Binding SaveOrderCommand}" Header="Zapisz" />
<Window.InputBindings>
    <KeyBinding Command="{Binding SaveOrderCommand}" Key="S" Modifiers="Control" />
</Window.InputBindings>

Wszystkie trzy automatycznie się wyłączą/włączą razem, bo współdzielą ten sam CanExecute.

Postaw mi kawę