WPF MVVM : les Commandes sont faciles. Comment Connecter la Vue et ViewModel avec RoutedEvent

Une option consiste à étendre le contrôle en question et ajouter le support pour la commande dont vous avez besoin. Par exemple, j'ai modifié liste avant de à l'appui de la ItemActivated de l'événement et de commandement.

OriginalL'auteur Kent Boogaart

Étendre le contrôle à l'appui de ICommandSource et décider de l'action qui doit déclencher la commande.

Je l'ai fait avec la Boîte Combo et utilisé OnSelectionChanged comme le déclencheur de la commande. Je vais d'abord vous montrer en XAML comment je la lie de la commande à l'étendue du Contrôle zone de liste déroulante que j'ai appelé CommandComboBox, alors je vais vous montrer le code pour CommandComboBox qui ajoute le support pour le ICommandSource de zone de liste déroulante.

1) à l'Aide de CommandComboBox dans votre code XAML:

Dans votre espace de noms XAML déclarations comprennent

   xmlns:custom="clr-namespace:WpfCommandControlsLibrary;assembly=WpfCommandControlsLibrary">

Utiliser le CommandComboBox en place de la zone de liste déroulante et lier la commande à elle de la sorte: Notez que dans cet exemple, j'ai défini une commande appelée SetLanguageCommand im mon ViewModel et je suis de passage de la valeur sélectionnée pour cette zone de liste déroulante en tant que paramètre à la commande.

 <custom:CommandComboBox 
    x:Name="ux_cbSelectLanguage"
    ItemsSource="{Binding Path = ImagesAndCultures}"
    ItemTemplate="{DynamicResource LanguageComboBoxTemplate}"           
    Command="{Binding Path=SetLanguageCommand, Mode=Default}"
    CommandParameter="{Binding RelativeSource={x:Static RelativeSource.Self}, Path=SelectedValue, Mode=Default}"
    IsSynchronizedWithCurrentItem="True" 
    HorizontalAlignment="Right" 
    VerticalAlignment="Center" 
    Grid.Column="1" Margin="0,0,20,0" Style="{DynamicResource GlassyComboBox}" ScrollViewer.IsDeferredScrollingEnabled="True"
 />

2) Le code CommandComboBox

Le code pour le fichier CommandComboBox.cs est inclus ci-dessous. J'ai ajouté ce fichier dans une Bibliothèque de Classe appelé WpfCommandControlsLibrary et en a fait un projet à part donc je pourrais facilement ajouter n'importe étendre les commandes quelle que soit la solution nécessaire pour les utiliser, et donc je pourrais facilement ajouter d'autres Contrôles WPF et de les étendre à l'appui de la ICommandSource inteface.

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace WpfCommandControlsLibrary
{
   ///<summary>
   ///Follow steps 1a or 1b and then 2 to use this custom control in a XAML file.
   ///
   ///Step 1a) Using this custom control in a XAML file that exists in the current project.
   ///Add this XmlNamespace attribute to the root element of the markup file where it is 
   ///to be used:
   ///
   ///    xmlns:MyNamespace="clr-namespace:WpfCommandControlsLibrary"
   ///
   ///
   ///Step 1b) Using this custom control in a XAML file that exists in a different project.
   ///Add this XmlNamespace attribute to the root element of the markup file where it is 
   ///to be used:
   ///
   ///    xmlns:MyNamespace="clr-namespace:WpfCommandControlsLibrary;assembly=WpfCommandControlsLibrary"
   ///
   ///You will also need to add a project reference from the project where the XAML file lives
   ///to this project and Rebuild to avoid compilation errors:
   ///
   ///    Right click on the target project in the Solution Explorer and
   ///    "Add Reference"->"Projects"->[Select this project]
   ///
   ///
   ///Step 2)
   ///Go ahead and use your control in the XAML file.
   ///
   ///    <MyNamespace:CustomControl1/>
   ///
   ///</summary>

   public class CommandComboBox : ComboBox, ICommandSource
   {
      public CommandComboBox() : base()
      {
      }

  #region Dependency Properties
  //Make Command a dependency property so it can use databinding.
  public static readonly DependencyProperty CommandProperty =
      DependencyProperty.Register(
          "Command",
          typeof(ICommand),
          typeof(CommandComboBox),
          new PropertyMetadata((ICommand)null,
          new PropertyChangedCallback(CommandChanged)));

  public ICommand Command
  {
     get
     {
        return (ICommand)GetValue(CommandProperty);
     }
     set
     {
        SetValue(CommandProperty, value);
     }
  }

  //Make CommandTarget a dependency property so it can use databinding.
  public static readonly DependencyProperty CommandTargetProperty =
      DependencyProperty.Register(
          "CommandTarget",
          typeof(IInputElement),
          typeof(CommandComboBox),
          new PropertyMetadata((IInputElement)null));

  public IInputElement CommandTarget
  {
     get
     {
        return (IInputElement)GetValue(CommandTargetProperty);
     }
     set
     {
        SetValue(CommandTargetProperty, value);
     }
  }

  //Make CommandParameter a dependency property so it can use databinding.
  public static readonly DependencyProperty CommandParameterProperty =
      DependencyProperty.Register(
          "CommandParameter",
          typeof(object),
          typeof(CommandComboBox),
          new PropertyMetadata((object)null));

  public object CommandParameter
  {
     get
     {
        return (object)GetValue(CommandParameterProperty);
     }
     set
     {
        SetValue(CommandParameterProperty, value);
     }
  }

  #endregion

  //Command dependency property change callback.
  private static void CommandChanged(DependencyObject d,
      DependencyPropertyChangedEventArgs e)
  {
     CommandComboBox cb = (CommandComboBox)d;
     cb.HookUpCommand((ICommand)e.OldValue, (ICommand)e.NewValue);
  }

  //Add a new command to the Command Property.
  private void HookUpCommand(ICommand oldCommand, ICommand newCommand)
  {
     //If oldCommand is not null, then we need to remove the handlers.
     if (oldCommand != null)
     {
        RemoveCommand(oldCommand, newCommand);
     }
     AddCommand(oldCommand, newCommand);
  }

  //Remove an old command from the Command Property.
  private void RemoveCommand(ICommand oldCommand, ICommand newCommand)
  {
     EventHandler handler = CanExecuteChanged;
     oldCommand.CanExecuteChanged -= handler;
  }

  //Add the command.
  private void AddCommand(ICommand oldCommand, ICommand newCommand)
  {
     EventHandler handler = new EventHandler(CanExecuteChanged);
     canExecuteChangedHandler = handler;
     if (newCommand != null)
     {
        newCommand.CanExecuteChanged += canExecuteChangedHandler;
     }
  }
  private void CanExecuteChanged(object sender, EventArgs e)
  {

     if (this.Command != null)
     {
        RoutedCommand command = this.Command as RoutedCommand;

        //If a RoutedCommand.
        if (command != null)
        {
           if (command.CanExecute(CommandParameter, CommandTarget))
           {
              this.IsEnabled = true;
           }
           else
           {
              this.IsEnabled = false;
           }
        }
        //If a not RoutedCommand.
        else
        {
           if (Command.CanExecute(CommandParameter))
           {
              this.IsEnabled = true;
           }
           else
           {
              this.IsEnabled = false;
           }
        }
     }
  }

  //If Command is defined, selecting a combo box item will invoke the command;
  //Otherwise, combo box will behave normally.
  protected override void OnSelectionChanged(SelectionChangedEventArgs e)
  {
     base.OnSelectionChanged(e);

     if (this.Command != null)
     {
        RoutedCommand command = Command as RoutedCommand;

        if (command != null)
        {
           command.Execute(CommandParameter, CommandTarget);
        }
        else
        {
           ((ICommand)Command).Execute(CommandParameter);
        }
     }
  }

  //Keep a copy of the handler so it doesn't get garbage collected.
  private static EventHandler canExecuteChangedHandler;

  }
}

OriginalL'auteur eesh

Bien, personne n'a répondu.
J'ai donc renoncé et a déménagé à la mise en œuvre de la Vue sur l'extérieur, le Dictionnaire en un UserControl, j'ai injecté de lui une référence pour le ViewModel.

Maintenant, quand la ListBox feu de l'Événement qu'il appelle le ViewModel et à partir de là, tout est à nouveau possible.

Ariel

OriginalL'auteur ArielBH

Essayez d'utiliser Prism 2.

Il est livré avec des extensions commandant et ouvre de nombreuses nouvelles posibilites (comme les commandes à être attaché à l'arbre visuel).

OriginalL'auteur Jarek Kardas