This article is currently in the process of being translated into Dutch (~30% done).


Implementing a custom WPF Command

In het vorige hoofdstuk hebben we al gekeken naar het gebruik van commands die al in WPF gedefinieerd zijn, natuurlijk is het ook mogelijk om eigen commands te implementeren. Het is simpel en wanneer gedaan kunnen deze commands gebruikt worden op dezelfde manier als de commands die al gedefinieerd zijn.

De makkelijkste manier om eigen commando's te implementeren is met een static klasse die de commando's bevat. Elk commando kan dan aan deze klasse toegevoegd worden als static fields, ervoor zorgend dat deze gebruikt kunnen worden in je applicatie. Omdat WPF, om onduidelijke redenen, geen Exit/Quit commando implementeert, heb ik besloten deze te gaan implementeren als voorbeeld van een eigen commando. Dat ziet er als volgt uit:

<Window x:Class="WpfTutorialSamples.Commands.CustomCommandSample"
        Title="CustomCommandSample" Height="150" Width="200">
        <CommandBinding Command="self:CustomCommands.Exit" CanExecute="ExitCommand_CanExecute" Executed="ExitCommand_Executed" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
            <MenuItem Header="File">
                <MenuItem Command="self:CustomCommands.Exit" />
        <StackPanel Grid.Row="1" HorizontalAlignment="Center" VerticalAlignment="Center">
            <Button Command="self:CustomCommands.Exit">Exit</Button>
using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Input;

namespace WpfTutorialSamples.Commands
	public partial class CustomCommandSample : Window
		public CustomCommandSample()

		private void ExitCommand_CanExecute(object sender, CanExecuteRoutedEventArgs e)
			e.CanExecute = true;

		private void ExitCommand_Executed(object sender, ExecutedRoutedEventArgs e)

	public static class CustomCommands
		public static readonly RoutedUICommand Exit = new RoutedUICommand
				new InputGestureCollection()
					new KeyGesture(Key.F4, ModifierKeys.Alt)

		//Define more commands here, just like the one above

In the markup, I've defined a very simple interface with a menu and a button, both of them using our new, custom Exit command. This command is defined in Code-behind, in our own CustomCommands class, and then referenced in the CommandBindings collection of the window, where we assign the events that it should use to execute/check if it's allowed to execute.

All of this is just like the examples in the previous chapter, except for the fact that we're referencing the command from our own code (using the "self" namespace defined in the top) instead of a built-in command.

In Code-behind, we respond to the two events for our command: One event just allows the command to execute all the time, since that's usually true for an exit/quit command, and the other one calls the Shutdown method that will terminate our application. All very simple.

As already explained, we implement our Exit command as a field on a static CustomCommands class. There are several ways of defining and assigning properties on the commands, but I've chosen the more compact approach (it would be even more compact if placed on the same line, but I've added line breaks here for readability) where I assign all of it through the constructor. The parameters are the text/label of the command, the name of the command, the owner type and then an InputGestureCollection, allowing me to define a default shortcut for the command (Alt+F4).


Implementing custom WPF commands is almost as easy as consuming the built-in commands, and it allows you to use commands for every purpose in your application. This makes it very easy to re-use actions in several places, as shown in the example of this chapter.

This article has been fully translated into the following languages: Is your preferred language not on the list? Click here to help us translate this article into your language!