Cette documentation est archivée et n’est pas conservée.

RoutedCommand, classe

Defines an ICommand which is routed through the element tree.

Espace de noms: System.Windows.Input
Assembly : PresentationCore (dans presentationcore.dll)
Espace de noms XML :  http://schemas.microsoft.com/winfx/2006/xaml/presentation

[TypeConverterAttribute("System.Windows.Input.CommandConverter, PresentationFramework, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, Custom=null")] 
public class RoutedCommand : ICommand
/** @attribute TypeConverterAttribute("System.Windows.Input.CommandConverter, PresentationFramework, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, Custom=null") */ 
public class RoutedCommand implements ICommand
TypeConverterAttribute("System.Windows.Input.CommandConverter, PresentationFramework, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, Custom=null") 
public class RoutedCommand implements ICommand
<object property="predefinedCommandName"/>- or -<object property="predefinedCommandName.predefinedCommandName"/>- or -<object property="{x:Static customClassName.customCommandName}"/>
 predefinedClassName  One of the predefined command classes.  predefinedCommandName  One of the predefined commands.  prefix  The xlmns prefix which maps customClassName. customCommandName to the .NET class.  For more information, see XAML Namespaces and Namespace Mapping.   customClassName  A custom class which contains the custom command.  customCommandName  A custom command. 

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

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

// CanExecuteRoutedEventHandler that only returns true if
// the source is a control.
public 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.

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

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Microsoft .NET Framework 3.0 est pris en charge sur Windows Vista, Microsoft Windows XP SP2 et Windows Server 2003 SP1.

.NET Framework

Prise en charge dans : 3.0
Afficher: