MVVM basics and commands

The view-model pattern, ICommand and a reusable RelayCommand, and where commands stop being enough.

What MVVM actually buys you

MVVM splits a screen into a model (data and rules), a view-model (state and behaviour for one screen) and a view (XAML that binds to the view-model). The payoff is that the view-model has no reference to any control, so you can test the logic that fills a form without opening a window.

• Push back on any Click handler that contains a decision. Handlers belong in code-behind only for view-specific concerns such as focus or a drag gesture.
• A view-model that takes an IWindowService instead of calling MessageBox.Show is testable; one that shows dialogs directly is not.
• Keep view-models small and per screen. A god view-model shared by the whole app reintroduces the coupling MVVM was meant to remove.

ICommand and RelayCommand

A command is the binding-friendly replacement for a click handler. It exposes Execute, CanExecute and a CanExecuteChanged event that WPF subscribes to in order to enable or disable every bound button automatically.

public sealed 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 event EventHandler? CanExecuteChanged
    {
        add => CommandManager.RequerySuggested += value;
        remove => CommandManager.RequerySuggested -= value;
    }

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

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

public sealed class OrdersViewModel : ViewModelBase
{
    private string _filter = string.Empty;

    public string Filter
    {
        get => _filter;
        set { if (Set(ref _filter, value)) SaveCommand.RaiseCanExecuteChanged(); }
    }

    public ICommand SaveCommand { get; }
    public ICommand DeleteCommand { get; }

    public OrdersViewModel(IOrderService service)
    {
        SaveCommand = new RelayCommand(
            _ => service.Save(Selected),
            _ => Selected is not null && !string.IsNullOrWhiteSpace(Filter));

        DeleteCommand = new RelayCommand(p => service.Delete((Order)p!), p => p is Order);
    }
}

<Button Content="Save"
        Command="{Binding SaveCommand}" />

<Button Content="Delete"
        Command="{Binding DeleteCommand}"
        CommandParameter="{Binding SelectedItem, ElementName=OrderGrid}" />

<ListBox x:Name="OrderGrid" ItemsSource="{Binding Orders}" />

• WPF calls CanExecute on every button bound to the command, so the enablement rule is written once in the view-model.
• RelayCommand is not built in; write the twenty lines above or use a maintained MVVM library rather than duplicating it per project.
• CommandParameter is how a command receives the row, the sender or the selected item it acts on.
• Do not make CanExecute do work. It runs often, including during unrelated re-evaluation passes.

Where commands stop being enough

// Async work needs its own guard - ICommand.Execute is void
public sealed class AsyncRelayCommand : ICommand
{
    private readonly Func<Task> _run;
    private bool _running;

    public AsyncRelayCommand(Func<Task> run) => _run = run;

    public event EventHandler? CanExecuteChanged;
    public bool CanExecute(object? parameter) => !_running;

    public async void Execute(object? parameter)
    {
        if (_running) return;
        _running = true; Raise();
        try { await _run(); }
        finally { _running = false; Raise(); }
    }

    private void Raise() => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
}

// Behaviors cover what commands cannot express
// xmlns:i="http://schemas.microsoft.com/xaml/behaviors"
// <i:Interaction.Triggers>
//   <i:EventTrigger EventName="Loaded">
//     <i:InvokeCommandAction Command="{Binding LoadCommand}" />
//   </i:EventTrigger>
// </i:Interaction.Triggers>

FAQ

Related

Data binding XAML and layout panels

Last refreshed 2026-09-18.