2 out of 3 rated this helpful - Rate this topic

RoutedCommand Class

Defines a command that implements ICommand and is routed through the element tree.

System.Object
  System.Windows.Input.RoutedCommand
    System.Windows.Input.RoutedUICommand

Namespace:  System.Windows.Input
Assembly:  PresentationCore (in PresentationCore.dll)
XMLNS for XAML: http://schemas.microsoft.com/winfx/2006/xaml/presentation, http://schemas.microsoft.com/netfx/2007/xaml/presentation
[TypeConverterAttribute("System.Windows.Input.CommandConverter, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, Custom=null")]
public class RoutedCommand : ICommand
<RoutedCommand .../>
<object property="predefinedCommandName"/>- or -<object property="predefinedClassName.predefinedCommandName"/>- or -<object property="{x:Static customClassName.customCommandName}"/>

XAML Values

predefinedClassName

One of the predefined command classes.

predefinedCommandName

One of the predefined commands.

customClassName

A custom class which contains the custom command. Custom classes generally require an xlmns prefix mapping; see XAML Namespaces and Namespace Mapping for WPF XAML.

customCommandName

A custom command.

The RoutedCommand type exposes the following members.

  Name Description
Public method RoutedCommand() Initializes a new instance of the RoutedCommand class.
Public method RoutedCommand(String, Type) Initializes a new instance of the RoutedCommand class with the specified name and owner type.
Public method RoutedCommand(String, Type, InputGestureCollection) Initializes a new instance of the RoutedCommand class with the specified name, owner type, and collection of gestures.
Top
  Name Description
Public property InputGestures Gets the collection of InputGesture objects that are associated with this command.
Public property Name Gets the name of the command.
Public property OwnerType Gets the type that is registered with the command.
Top
  Name Description
Public method CanExecute Determines whether this RoutedCommand can execute in its current state.
Public method Equals(Object) Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Public method Execute Executes the RoutedCommand on the current command target.
Protected method Finalize Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.)
Public method GetHashCode Serves as a hash function for a particular type. (Inherited from Object.)
Public method GetType Gets the Type of the current instance. (Inherited from Object.)
Protected method MemberwiseClone Creates a shallow copy of the current Object. (Inherited from Object.)
Public method ToString Returns a string that represents the current object. (Inherited from Object.)
Top
  Name Description
Public event CanExecuteChanged Occurs when changes to the command source are detected by the command manager. These changes often affect whether the command should execute on the current command target.
Top
  Name Description
Explicit interface implemetation Private method ICommand.CanExecute For a description of this members, see CanExecute.
Explicit interface implemetation Private method ICommand.Execute For a description of this members, see Execute.
Top

The Execute and CanExecute methods on a RoutedCommand do not contain the application logic for the command as is the case with a typical ICommand, but rather, these methods raise events that traverse the element tree looking for an object with a CommandBinding. The event handlers attached to the CommandBinding contain the command logic.

The Execute method raises the PreviewExecuted and Executed events. The CanExecute method raises the PreviewCanExecute and CanExecute events.

This example shows how to create a custom RoutedCommand and how to implement the custom command by creating a ExecutedRoutedEventHandler and a CanExecuteRoutedEventHandler and attaching them to a CommandBinding. For more information on commanding, see the Commanding Overview.

The first step in creating a RoutedCommand is defining the command and instantiating it.


public static RoutedCommand CustomRoutedCommand = new RoutedCommand();


In order to use the command in an application, event handlers which define what the command does must be created


private void ExecutedCustomCommand(object sender,
    ExecutedRoutedEventArgs e)
{
    MessageBox.Show("Custom Command Executed");
}



// CanExecuteRoutedEventHandler that only returns true if
// the source is a control.
private void CanExecuteCustomCommand(object sender, 
    CanExecuteRoutedEventArgs e)
{
    Control target = e.Source as Control;

    if(target != null)
    {
        e.CanExecute = true;
    }
    else
    {
        e.CanExecute = false;
    }
}


Next, a CommandBinding is created which associates the command with the event handlers. The CommandBinding is created on a specific object. This object defines the scope of the CommandBinding in the element tree


<Window x:Class="SDKSamples.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:custom="clr-namespace:SDKSamples"
    Height="600" Width="800"
    >
  <Window.CommandBindings>
    <CommandBinding Command="{x:Static custom:Window1.CustomRoutedCommand}"
                    Executed="ExecutedCustomCommand"
                    CanExecute="CanExecuteCustomCommand" />
  </Window.CommandBindings>



CommandBinding customCommandBinding = new CommandBinding(
    CustomRoutedCommand, ExecutedCustomCommand, CanExecuteCustomCommand);

// attach CommandBinding to root window
this.CommandBindings.Add(customCommandBinding);


The final step is invoking the command. One way to invoke a command is to associate it with a ICommandSource, such as a Button.


<StackPanel>
  <Button Command="{x:Static custom:Window1.CustomRoutedCommand}"
          Content="CustomRoutedCommand"/>
</StackPanel>



// create the ui
StackPanel CustomCommandStackPanel = new StackPanel();
Button CustomCommandButton = new Button();
CustomCommandStackPanel.Children.Add(CustomCommandButton);

CustomCommandButton.Command = CustomRoutedCommand;


When the Button is clicked, the Execute method on the custom RoutedCommand is called. The RoutedCommand raises the PreviewExecuted and Executed routed events. These events traverse the element tree looking for a CommandBinding for this particular command. If a CommandBinding is found, the ExecutedRoutedEventHandler associated with CommandBinding is called.

.NET Framework

Supported in: 4, 3.5, 3.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Windows 7, Windows Vista SP1 or later, Windows XP SP3, Windows Server 2008 (Server Core not supported), Windows Server 2008 R2 (Server Core supported with SP1 or later), Windows Server 2003 SP2

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.
Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.
Did you find this helpful?
(1500 characters remaining)
Community Content Add
Annotations FAQ
e.Handled is ignored
Note that even though the ExecutedRoutedEventArgs exposes a Handled property, the value is ignored. As soon as any handler is found, the routing stops.