Delegate Commands

• Jun 07, 2019
• 7 minutes to read

Delegate commands are an implementation of the System.Windows.Input.ICommand interface, so they can be used to create commands in a ViewModel. A delegate command calls methods (delegates) that you assigned to the command when the command’s Execute and CanExecute logic is invoked.

The following delegate commands are available.

• DelegateCommand<T> - Specifies a command whose Execute and CanExecute delegates accept a single parameter of type T.
• DelegateCommand - Specifies a command whose Execute and CanExecute delegates do not have any parameters.

Creating DelegateCommands

Both commands support two constructors: a constructor that accepts an Execute delegate, and a constructor that accepts Execute and CanExecute delegates.

C#

public class DelegateCommandsViewModel : ViewModelBase {
    public DelegateCommand  DelegateCommand1 { get; private set; }
    public DelegateCommand<string> DelegateCommand2 { get; private set; }

    public DelegateCommandsViewModel() {
        DelegateCommand1 = new DelegateCommand(
            () => MessageBoxService.Show("This is a DelegateCommand"));

        DelegateCommand2 = new DelegateCommand<string>(
            x => MessageBoxService.Show(x), 
            x => !string.IsNullOrEmpty(x));
    }
}

VB.NET

Public Class DelegateCommandsViewModel
    Inherits ViewModelBase

    Public Property DelegateCommand1 As DelegateCommand
    Public Property DelegateCommand2 As DelegateCommand(Of String)

    Public Sub New()
        DelegateCommand1 = New DelegateCommand(Function() MessageBoxService.Show("This is a DelegateCommand"))
        DelegateCommand2 = New DelegateCommand(Of String)(Function(x) MessageBoxService.Show(x), Function(x) Not String.IsNullOrEmpty(x))
    End Sub
End Class

CommandParameter Conversion

A DelegateCommand<T> automatically converts the command argument to the parameterized type if possible. In the example below, the CommandParameter (the “Text” string) will be automatically converted to the DocumentType parametrized type.

XAML

<Button Command="{Binding ShowDocumentCommand}" CommandParameter="Text"/>

C#

public enum DocumentType { Text, Data }

public class DelegateCommandsViewModel : ViewModelBase {
    public DelegateCommand<DocumentType> ShowDocumentCommand { get; private set; }

    public DelegateCommandsViewModel() {
        ShowDocumentCommand = new DelegateCommand<DocumentType>(ShowDocument);
    }
    void ShowDocument(DocumentType parameter) {
        if(parameter == DocumentType.Text) {
            //... 
        }
        if(parameter == DocumentType.Data) {
            //... 
        }
    }
}

VB.NET

Public Enum DocumentType
    Text
    Data
End Enum

Public Class DelegateCommandsViewModel
    Inherits ViewModelBase

    Public Property ShowDocumentCommand As DelegateCommand(Of DocumentType)

    Public Sub New()
        ShowDocumentCommand = New DelegateCommand(Of DocumentType)(AddressOf ShowDocument)
    End Sub

    Private Sub ShowDocument(ByVal parameter As DocumentType)
        If parameter = DocumentType.Text Then
        End If

        If parameter = DocumentType.Data Then
        End If
    End Sub
End Class

Updating Commands

The DelegateCommand constructors have an optional useCommandManager parameter. This parameter specifies whether a DelegateCommand uses the CommandManager to raise the CanExecuteChanged event. By default, useCommandManager is true, making it unnecessary to manually implement the disable/enable logic for your commands. Once you set the CanExecute delegate for the command, the delegate is automatically triggered when an end user interacts with the UI. When the CommandManager is used for this purpose, the CanExecute handler is called frequently, so avoid performing time-consuming operations in the delegate.

If you pass false as the last constructor argument, the CommandManager is not used. In this case, update your command by calling the RaiseCanExecuteChanged method.

C#

public class DelegateCommandsViewModel : ViewModelBase {
    public DelegateCommand GoBackCommand{ get; private set; }
    public DelegateCommand GoForwardCommand { get; private set; }

    public DelegateCommandsViewModel() {
        GoBackCommand = new DelegateCommand(GoBack, CanGoBack, false);
        GoForwardCommand = new DelegateCommand(GoForward, CanGoForward, false);
    }

    void GoBack() {
        //... 
        UpdateCommandsState();
    }
    void GoForward() {
        //... 
        UpdateCommandsState();
    }
    bool CanGoBack() {
        //... 
    }
    bool CanGoForward() {
        //... 
    }
    void UpdateCommandsState() {
        GoBackCommand.RaiseCanExecuteChanged();
        GoForwardCommand.RaiseCanExecuteChanged();
    }
}

VB.NET

Public Class DelegateCommandsViewModel
    Inherits ViewModelBase

    Public Property GoBackCommand As DelegateCommand
    Public Property GoForwardCommand As DelegateCommand

    Public Sub New()
        GoBackCommand = New DelegateCommand(AddressOf GoBack, AddressOf CanGoBack, False)
        GoForwardCommand = New DelegateCommand(AddressOf GoForward, AddressOf CanGoForward, False)
    End Sub

    Private Sub GoBack()
        UpdateCommandsState()
    End Sub

    Private Sub GoForward()
        UpdateCommandsState()
    End Sub

    Private Function CanGoBack() As Boolean
    End Function

    Private Function CanGoForward() As Boolean
    End Function

    Private Sub UpdateCommandsState()
        GoBackCommand.RaiseCanExecuteChanged()
        GoForwardCommand.RaiseCanExecuteChanged()
    End Sub
End Class

DelegateCommands in POCO

In a POCO View Model, DelegateCommands can be automatically generated based on public methods (with one parameter or none) of your View Model.

For instance, for the following Save and CanSave methods…

C#

[POCOViewModel]
public class ViewModel {
    public void Save(string fileName) {
        //... 
    }
    public bool CanSave(string fileName) {
        return !string.IsNullOrEmpty(fileName);
    }
}

VB.NET

<POCOViewModel>
Public Class ViewModel
    Public Sub Save(fileName As String)
        '...
    End Sub
    Public Function CanSave(fileName As String) As Boolean
        Return Not String.IsNullOrEmpty(fileName)
    End Function
End Class

…the following SaveCommand property is automatically generated.

C#

DelegateCommand<string> saveCommand;
public DelegateCommand<string> SaveCommand {
    get {
        return saveCommand ?? 
            (saveCommand = new DelegateCommand<string>(Save, CanSave));
    }
}

VB.NET

Dim _SaveCommand As DelegateCommand(Of String)
Public ReadOnly Property SaveCommand
    Get
        If (_SaveCommand Is Nothing) Then
            _SaveCommand = New DelegateCommand(Of String)(AddressOf Save, AddressOf CanSave)
        End If
        Return _SaveCommand
    End Get
End Property

To update an automatically generated command in a POCO View Model, use the RaiseCanExecuteChanged extension method available from the DevExpress.Mvvm.POCO.POCOViewModelExtensions class.

C#

[POCOViewModel]
public class ViewModel {
    public void GoBack(){
        //...
    }
    public bool CanGoBack(){
        //...
    }
    public void UpdateSaveCommand(){
        this.RaiseCanExecuteChanged(c => c.GoBack());
    }
}

VB.NET

<POCOViewModel>
Public Class ViewModel
    Public Sub GoBack()
        '...
    End Sub
    Public Function CanGoBack() As Boolean
        '...
    End Function
    Public Sub UpdateSaveCommand()
        Me.RaiseCanExecuteChanged(Sub(c) c.GoBack())
    End Sub
End Class

Example

This example demonstrates how to create commands with the DelegateCommand class.

Note

A complete sample project is available at https://github.com/DevExpress-Examples/how-to-use-delegatecommand-e5165.

MainView.Wpf.xaml

<UserControl x:Class="Example.View.MainView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:ViewModel="clr-namespace:Example.ViewModel"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d" d:DesignHeight="500" d:DesignWidth="600">
    <UserControl.DataContext>
        <ViewModel:MainViewModel/>
    </UserControl.DataContext>

    <Grid x:Name="LayoutRoot" Background="White">
        <StackPanel Orientation="Vertical">
            <StackPanel Orientation="Horizontal" Margin="10">
                <Button Content="AutoUpdateCommand" Command="{Binding AutoUpdateCommand}" 
                        Margin="3" VerticalAlignment="Center"/>
                <CheckBox Content="IsAutoUpdateCommandEnabled" IsChecked="{Binding IsAutoUpdateCommandEnabled, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
                          Margin="3" VerticalAlignment="Center"/>
            </StackPanel>
            <StackPanel Orientation="Horizontal" Margin="10">
                <Button Content="ManualUpdateCommand" Command="{Binding ManualUpdateCommand}"
                        Margin="3" VerticalAlignment="Center"/>
                <CheckBox Content="IsManualUpdateCommandEnabled" IsChecked="{Binding IsManualUpdateCommandEnabled, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
                          Margin="3" VerticalAlignment="Center"/>
                <Button Content="ForceUpdateManualUpdateCommand" Command="{Binding ForceUpdateManualUpdateCommand}"
                        Margin="3" VerticalAlignment="Center"/>
            </StackPanel>
            <StackPanel Orientation="Horizontal" Margin="10">
                <TextBox Text="Message" x:Name="message" Width="80"/>
                <Button Content="CommandWithParameter" Command="{Binding CommandWithParameter}" CommandParameter="{Binding ElementName=message, Path=Text}"
                        Margin="3" VerticalAlignment="Center"/>
            </StackPanel>
        </StackPanel>
    </Grid>
</UserControl>

MainViewModel.Wpf.cs

using DevExpress.Mvvm;
using System.Windows;

namespace Example.ViewModel {
    public class MainViewModel : ViewModelBase {
        public DelegateCommand AutoUpdateCommand { get; private set; }
        public bool IsAutoUpdateCommandEnabled {
            get { return GetProperty(() => IsAutoUpdateCommandEnabled); }
            set { SetProperty(() => IsAutoUpdateCommandEnabled, value); }
        }
        void AutoUpdateCommandExecute() {
            MessageBox.Show("Hello");
        }
        bool AutoUpdateCommandCanExecute() {
            return IsAutoUpdateCommandEnabled;
        }

        public DelegateCommand ManualUpdateCommand { get; private set; }
        public bool IsManualUpdateCommandEnabled {
            get { return GetProperty(() => IsManualUpdateCommandEnabled); }
            set { SetProperty(() => IsManualUpdateCommandEnabled, value); }
        }
        void ManualUpdateCommandExecute() {
            MessageBox.Show("Hello");
        }
        bool ManualUpdateCommandCanExecute() {
            return IsManualUpdateCommandEnabled;
        }
        public DelegateCommand ForceUpdateManualUpdateCommand { get; private set; }
        void ForceUpdateManualUpdateCommandExecute() {
            ManualUpdateCommand.RaiseCanExecuteChanged();
        }

        public DelegateCommand<string> CommandWithParameter { get; private set; }
        void CommandWithParameterExecute(string parameter) {
            MessageBox.Show(parameter);
        }
        bool CommandWithParameterCanExecute(string parameter) {
            return !string.IsNullOrEmpty(parameter);
        }

        public MainViewModel() {
            AutoUpdateCommand = new DelegateCommand(AutoUpdateCommandExecute, AutoUpdateCommandCanExecute);
            ManualUpdateCommand = new DelegateCommand(ManualUpdateCommandExecute, ManualUpdateCommandCanExecute, false);
            ForceUpdateManualUpdateCommand = new DelegateCommand(ForceUpdateManualUpdateCommandExecute);
            CommandWithParameter = new DelegateCommand<string>(CommandWithParameterExecute, CommandWithParameterCanExecute);
        }
    }
}

Application.xaml

<Application x:Class="Example.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Application.Resources>

    </Application.Resources>
</Application>

MainViewModel.Wpf.vb

Imports DevExpress.Mvvm
Imports System.Windows

Namespace Example.ViewModel
    Public Class MainViewModel
        Inherits ViewModelBase

        Private privateAutoUpdateCommand As DelegateCommand
        Public Property AutoUpdateCommand() As DelegateCommand
            Get
                Return privateAutoUpdateCommand
            End Get
            Private Set(ByVal value As DelegateCommand)
                privateAutoUpdateCommand = value
            End Set
        End Property
        Public Property IsAutoUpdateCommandEnabled() As Boolean
            Get
                Return GetProperty(Function() IsAutoUpdateCommandEnabled)
            End Get
            Set(ByVal value As Boolean)
                SetProperty(Function() IsAutoUpdateCommandEnabled, value)
            End Set
        End Property
        Private Sub AutoUpdateCommandExecute()
            MessageBox.Show("Hello")
        End Sub
        Private Function AutoUpdateCommandCanExecute() As Boolean
            Return IsAutoUpdateCommandEnabled
        End Function

        Private privateManualUpdateCommand As DelegateCommand
        Public Property ManualUpdateCommand() As DelegateCommand
            Get
                Return privateManualUpdateCommand
            End Get
            Private Set(ByVal value As DelegateCommand)
                privateManualUpdateCommand = value
            End Set
        End Property
        Public Property IsManualUpdateCommandEnabled() As Boolean
            Get
                Return GetProperty(Function() IsManualUpdateCommandEnabled)
            End Get
            Set(ByVal value As Boolean)
                SetProperty(Function() IsManualUpdateCommandEnabled, value)
            End Set
        End Property
        Private Sub ManualUpdateCommandExecute()
            MessageBox.Show("Hello")
        End Sub
        Private Function ManualUpdateCommandCanExecute() As Boolean
            Return IsManualUpdateCommandEnabled
        End Function
        Private privateForceUpdateManualUpdateCommand As DelegateCommand
        Public Property ForceUpdateManualUpdateCommand() As DelegateCommand
            Get
                Return privateForceUpdateManualUpdateCommand
            End Get
            Private Set(ByVal value As DelegateCommand)
                privateForceUpdateManualUpdateCommand = value
            End Set
        End Property
        Private Sub ForceUpdateManualUpdateCommandExecute()
            ManualUpdateCommand.RaiseCanExecuteChanged()
        End Sub

        Private privateCommandWithParameter As DelegateCommand(Of String)
        Public Property CommandWithParameter() As DelegateCommand(Of String)
            Get
                Return privateCommandWithParameter
            End Get
            Private Set(ByVal value As DelegateCommand(Of String))
                privateCommandWithParameter = value
            End Set
        End Property
        Private Sub CommandWithParameterExecute(ByVal parameter As String)
            MessageBox.Show(parameter)
        End Sub
        Private Function CommandWithParameterCanExecute(ByVal parameter As String) As Boolean
            Return Not String.IsNullOrEmpty(parameter)
        End Function

        Public Sub New()
            AutoUpdateCommand = New DelegateCommand(AddressOf AutoUpdateCommandExecute, AddressOf AutoUpdateCommandCanExecute)
            ManualUpdateCommand = New DelegateCommand(AddressOf ManualUpdateCommandExecute, AddressOf ManualUpdateCommandCanExecute, False)
            ForceUpdateManualUpdateCommand = New DelegateCommand(AddressOf ForceUpdateManualUpdateCommandExecute)
            CommandWithParameter = New DelegateCommand(Of String)(AddressOf CommandWithParameterExecute, AddressOf CommandWithParameterCanExecute)
        End Sub
    End Class
End Namespace