Comment lier une commande dans WPF

Parfois, nous avons utilisé de façons complexes, tant de fois, nous avons oublié que la plus simple des façons de faire la tâche.

Je sais comment le faire liaison de commande, mais j'ai toujours utiliser la même approche.

Créer une classe qui implémente l'interface ICommand et à partir de la vue modèle, je créer une nouvelle instance de cette classe et de liaison fonctionne comme un charme.

C'est le code que j'ai utilisé pour la liaison de commande

 public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        DataContext = this;            
        testCommand = new MeCommand(processor);
    }

    ICommand testCommand;

    public ICommand test
    {
        get { return testCommand; }
    }
    public void processor()
    {
        MessageBox.Show("hello world");
    }
}

public class MeCommand : ICommand
{
    public delegate void ExecuteMethod();
    private ExecuteMethod meth;
    public MeCommand(ExecuteMethod exec)
    {
        meth = exec;
    }

    public bool CanExecute(object parameter)
    {
        return false;
    }

    public event EventHandler CanExecuteChanged;

    public void Execute(object parameter)
    {
        meth();
    }
}

Mais je veux savoir la méthode de base pour ce faire, aucun tiers dll aucune nouvelle création de classes. Cette simple commande de liaison à l'aide d'une seule classe. Effectif de la classe met en œuvre à partir de l'interface ICommand et faire le travail.

source d'informationauteur MegaMind

c#commandbinding icommand wpf

14

Prisme déjà fourni Microsoft.Les pratiques.Prism.Commandes.DelegateCommand

Je ne suis pas sûr, est-il considéré comme de la 3ème partie. Au moins c'est officiel et documenté sur MSDN.

Certains indigènes construire-dans les commandes copier, coller implémente l'interface ICommand.
À mon humble avis il à la suite de la Ouvert(s'étend)/Fermeture(pour les changements) principe. de sorte que nous pouvons mettre en œuvre notre propre commandement.

Mise à jour

WPF Commandant documenté iciun extrait...

WPF fournit un ensemble de commandes prédéfinies. telles que Couper, BrowseBack et
BrowseForward, Play, Stop et Pause.

Si les commandes dans la commande de la bibliothèque de classes ne répondent pas à vos besoins,
ensuite, vous pouvez créer vos propres commandes. Il y a deux façons de créer une
commande personnalisée. La première est de commencer à partir de la base et de mettre en œuvre
l'interface ICommand. Dans l'autre sens, et l'approche plus commune,
est de créer un RoutedCommand ou un RoutedUICommand.

J'ai essayé RoutedCommand modèle au début et a terminé avec la mise en œuvre de ICommand.

échantillon de liaison XAML
```
<CommandBinding Command="{x:Static custom:Window1.CustomRoutedCommand}"
                    Executed="ExecutedCustomCommand"
                    CanExecute="CanExecuteCustomCommand" />
```
RoutedCommand n'est pas différent de RoutedEvent. cela semble être un meilleur bouton "Cliqué sur" gestionnaire d'événement. Il sert le but: séparer la logique d'application de la Vue, mais nécessitent quelques attacher DependencyProperty ou code-behind.

personnellement je me sens plus à l'aise avec juste de mettre en œuvre mon ICommand.

J'ai tendance à utiliser le framework MVVM light qui vient avec un RelayCommand construit en.

Vous ajoutez un ICommand bien à votre modèle d'affichage, puis attribuez-lui un relaycommand:-

ICommand ClickMeCommand {get;set;}
private void InitCommands()
{
   ClickMeCommand = new RelayCommand(()=>HasBeenClicked=true);
   //or
   ClickMeCommand = new RelayCommand(ClickMeEvent);
}
public void ClickMeEvent()
{
   HasBeenClicked=true;
}

Dans le xaml, vous avez juste normal d'utilisation de la liaison:-

<Button Content='Push me' Command='{Binding ClickMeCommand}' />

Veuillez utiliser acheminé de commande dans le cas où vous ne voulez pas créer de nouvelle classe. voici un petit extrait. J'ai créé une commande routée d'Enregistrer et de le lier à la liaison de commande de la fenêtre , soulever la commande de bouton.et voila!..... J'espère que cela peut vous aider à

 public partial class Window1 : Window
 {
    public static readonly RoutedCommand Foo = new RoutedCommand();

    public Window1()
    {
        InitializeComponent();
    }

    void Foo_CanExecute(object sender, CanExecuteRoutedEventArgs e)
    {
        //The Window gets to determine if the Foo 
        //command can execute at this time.
        e.CanExecute = true;
    }

    void Foo_Executed(object sender, ExecutedRoutedEventArgs e)
    {
        //The Window executes the command logic when the user wants to Foo.
        MessageBox.Show("The Window is Fooing...");
    }
}

 <Window.CommandBindings>
 <CommandBinding
  Command="{x:Static  local:Window1.Foo}"
  CanExecute="Foo_CanExecute"
  Executed="Foo_Executed"
  />

J'espère que j'ai compris votre problème.

PS: La nécessité de commande modèle de conception est de découpler la logique de l'exécution et de l'invocateur de commande.Les commandes de classe est un moyen d'encapsuler la logique.

1

À en juger par ce que vous faites sans exécuter le Code dans VS, votre problème est que vous appelez InitializeComponent (rendu XAML), puis définissez le DataContext sans aucune valeur dans votre test de la Propriété, et enfin définir un membre privé. Comment est l'INTERFACE utilisateur censé remarquez que votre Commande n'est pas null (qui a été la dernière valeur qu'il trouve dans la Propriété)?

Pourquoi ne pas instancier la Commande paresseusement comme suit :
```
public ICommand test
{
    get
    { 
      if(testCommand== null)
      {
         testCommand= new MeCommand(processor);
       }
      return testCommand; 
    }
}
```
De cette façon, il sera là dès que c'est nécessaire et vous n'avez pas besoin de Changer de notification (à moins de modifier la commande plus tard au moment de l'exécution).

Par le façon, il ya quelques endroits où vous avez le sentiment pas de code est exécuté dans la Liaison de Commande de scénario :

1) CanExecute() renvoie la valeur faux : il suffit de retourner la valeur true ou de l'évaluer en fonction de vos cas.

2) Les conditions de CanExecute, de sorte qu'il serait de retour vrai, mais il n'est pas appelée: Vous pouvez brancher votre Commande avec le Gestionnaire de commandes de la classe, voir ici. Assurez-vous que 1) est résolu à l'avant de l'essayer. Cela garantit que votre INTERFACE utilisateur actualiser le CanExecute assez fréquemment, et si c'est pas encore assez, l'appel à la Méthode CommandManager.InvalidateRequerySuggested() explicitement.

3) Votre Liaison est mauvaise. Modifier le code de liaison de la sorte:
```
Command="{Binding Path=test, PresentationTraceSources.TraceLevel=High}"
```
Ce sera le spam de votre fenêtre de sortie lorsque la valeur de la liaison est tiré ou poussé. Regarder dehors pour le terme "utilisation de la valeur finale". Si c'est null, votre Commande n'est pas là où il est censé être (encore).
0

Bien, vous avez presque lui. Assurez-vous juste que CanExecute() renvoie true, sinon, votre code ne sera pas exécuté. (Je pense qu'il le sera, mais quand même). Assurez-vous également que ajouter "NotifyPropertyChanged('yourCommand')" à
```
   public ICommand test
    {
        get { return testCommand; }
        set { testCOmmand = value; NotifyPropertyChanged("test"); }
    }
```
ici.

Vous pouvez également faire
test = new MeCOmmand();
DataContext = ce;

Dans la Fenêtre WPF constructeur, pour associer un raccourci clavier, il suffit d'ajouter une liaison avec un délégué, et de l'associer avec l'un des principaux geste.

public YourWindow() //your constructor
{
   ...
   //bind keyboard command shortcuts
   InputBindings.Add(new KeyBinding( //add a new key-binding, bind it to your command object which takes a delegate
      new WindowCommand(this)
      {
         ExecuteDelegate = TogglePause //REPLACE TogglePause with your method delegate
      }, new KeyGesture(Key.P, ModifierKeys.Control)));
   ...
}

Créer un simple WindowCommand classe qui prend une exécution délégué à l'incendie au large de la méthode, fixés sur elle.

public class WindowCommand : ICommand
{
    private MainWindow _window;
    public Action ExecuteDelegate { get; set; }

    public WindowCommand(MainWindow window)
    {
        _window = window;
    }

    public bool CanExecute(object parameter)
    {
        return true;
    }

    public event EventHandler CanExecuteChanged;

    public void Execute(object parameter)
    {
        if (ExecuteDelegate != null)
        {
            ExecuteDelegate();
        }
        else
        {
            throw new InvalidOperationException();
        }
    }
}

Vous devez vous connecter pour publier un commentaire.

Mise à jour