MVVM Acheminés et Relais de Commande

Concernant l'utilisation de RelayCommand et RoutedCommand dans MVVM la principale différence pour moi est la suivante:

Emplacement du code

RelayCommand permet de mettre en oeuvre la commande dans n'importe quelle classe (ICommand-propriété avec des délégués), qui est ensuite classiquement lié aux données pour le contrôle, qui appelle la commande. Cette classe est la ViewModel.
Si vous utilisez une commande routée, vous aurez à mettre en œuvre les méthodes liées à la commande dans le codebehind du contrôle, parce que les méthodes sont spécifiées par les attributs de la CommandBinding-élément. Supposé que le strict MVVM signifie avoir un "vide" codebehind-fichier, il n'existe pas de possibilité d'utiliser la norme acheminé commandes avec MVVM.

Ce que RS Conley a dit, que RelayCommand vous permet de définir la RelayCommand à l'extérieur de ce Dernier est de droite, mais tout d'abord il vous permet de définir à l'intérieur de le ViewModel, qui RoutedCommand ne le fait pas.

De routage

D'autre part, RelayCommands ne prennent pas en charge le routage grâce à l'arbre (comme dit précédemment), ce qui n'est pas un problème, tant que votre interface est basée sur un seul viewModel. Si elle n'est pas, par exemple, si vous avez une collection d'éléments avec leur propre viewmodel et souhaitez invoquer une commande de l'enfant ViewModel pour chaque élément de l'élément parent à la fois, vous devrez utiliser le routage (voir aussi CompositeCommands).

Dans l'ensemble, je dirais que la norme RoutedCommands ne sont pas utilisables dans le strict MVVM. RelayCommands sont parfaits pour MVVM mais ne prennent pas en charge le routage, qui vous pourriez avoir besoin.

Je dirais que RoutedCommands sont parfaitement légales dans le strict MVVM. Bien que RelayCommands sont souvent préférables pour leur simplicité, RoutedCommands offrent parfois des avantages organisationnels. Par exemple, vous pourriez voulez que plusieurs vues différentes pour se connecter à une salle de ICommand instance sans exposer directement à la commande de la sous-Viewmodel.

Comme une note de côté, n'oubliez pas que le strict MVVM n'interdit pas l'utilisation de code-behind. Si cela était vrai, alors vous pourriez ne jamais définir des propriétés de dépendance à votre point de vue!

Afin d'utiliser un RoutedCommand dans un strict MVVM cadre vous pourriez suivre ces étapes:

1. Déclarer statique RoutedCommand instance pour la réalisation de votre commande. Vous pouvez ignorer cette étape si vous prévoyez d'utiliser une commande prédéfinie de la ApplicationCommands classe. Par exemple:

   public static class MyCommands {
       public static RoutedCommand MyCustomCommand = new RoutedCommand();
   }

2. Joindre souhaité en vue du RoutedCommand en utilisant XAML:

   <Button Command="{x:Static local:MyCommands.MyCustomCommand}" />

3. L'un de vos points de vue, qui est lié à une ViewModel (c'est à dire selon le ViewModel implémente la fonctionnalité de commande) doit exposer une coutume DependencyProperty qui sera lié à votre ViewModel de la mise en œuvre:

   public partial class MainView : UserControl
   {
       public static readonly DependencyProperty MyCustomCommandProperty =
           DependencyProperty.Register("MyCustomCommand",
           typeof(ICommand), typeof(MainView), new UIPropertyMetadata(null));
   
       public ICommand MyCustomCommand {
           get { return (ICommand)GetValue(MyCustomCommandProperty); }
           set { SetValue(MyCustomCommandProperty, value); }
       }

4. Le même point de vue doit se lier à la RoutedCommand à partir de l'étape 1. Dans le code XAML:

   <UserControl.CommandBindings>
       <CommandBinding Command="{x:Static local:MyCommands.MyCustomCommand}"
                       CanExecute="MyCustomCommand_CanExecute"
                       Executed="MyCustomCommand_Executed"
                       />
   </UserControl.CommandBindings>

   Dans le code-behind de la vue, l'événement associé gestionnaires juste délégué à la ICommand de la propriété de dépendance déclarée à l'étape 3:

   private void MyCustomCommand_CanExecute(object sender, CanExecuteRoutedEventArgs e) {
       var command = this.MyCustomCommand;
       if (command != null) {
           e.Handled = true;
           e.CanExecute = command.CanExecute(e.Parameter);
       }
   }
   private void MyCustomCommand_Executed(object sender, ExecutedRoutedEventArgs e) {
       var command = this.MyCustomCommand;
       if (command != null) {
           e.Handled = true;
           command.Execute(e.Parameter);
       }
   }

5. Enfin, lier votre ViewModel de la commande de mise en œuvre (ce qui devrait être un ICommand) à la coutume de la propriété de dépendance dans le code XAML:

   <local:MainView DataContext="{Binding MainViewModel}"
                   MyCustomCommand="{Binding CustomCommand}" />

L'avantage de cette approche est que votre ViewModel ne doit fournir qu'une seule mise en œuvre de l'interface ICommand (et il peut même être un RelayCommand), alors que n'importe quel nombre de Vues pouvez la joindre par l'intermédiaire de l'RoutedCommand sans avoir besoin d'être directement lié à ce Dernier.

Malheureusement, il n'est pas un inconvénient que le ICommand.Événement CanExecuteChanged ne fonctionnera pas. Lorsque votre ViewModel veut le point de Vue d'actualiser la CanExecute propriété, alors vous devez appeler le Gestionnaire de commandes.InvalidateRequerySuggested().