WPF - Comment forcer une commande à réévaluer « CanExecute » par ses CommandBindings

Question

j'ai un Menu où chaque MenuItem dans la hiérarchie a sa Command propriété est définie sur un RoutedCommand que je l'ai défini. Le CommandBinding associé fournit un rappel pour l'évaluation de CanExecute qui contrôle l'état activé de chaque MenuItem.

Cette presque fonctionne. Les éléments de menu arrivent initialement avec les bons états activés et désactivés. Toutefois, lorsque les données que mon rappel CanExecute utilise change, j'ai besoin de la commande pour re-demander un résultat de mon rappel afin que ce nouvel état soit reflété dans l'interface utilisateur. Il ne semble y avoir aucune méthode publique sur RoutedCommand ou CommandBinding pour cela.

Notez que le rappel est utilisé à nouveau lorsque je clique ou tape dans le contrôle (je suppose qu'il est déclenché en entrée car le survol ne provoque pas l'actualisation).

Answer 1

Pas la plus jolie dans le livre, mais vous pouvez utiliser le CommandManager pour invalider tous CommandBinding:

CommandManager.InvalidateRequerySuggested(); 

Voir plus d'informations sur MSDN

Answer 2

Pour toute personne qui vient à travers plus tard; Si vous utilisez MVVM et Prism, l'implémentation DelegateCommand de Prism de ICommand fournit une méthode .RaiseCanExecuteChanged() pour ce faire.

Answer 3

Je ne pouvais pas utiliser CommandManager.InvalidateRequerySuggested(); parce que je recevais un coup de performance.

J'ai utilisé la commande Delegating de MVVM Helper, qui ressemble à ci-dessous (je l'ai un peu modifié pour notre req). vous devez appeler command.RaiseCanExecuteChanged() de VM

public event EventHandler CanExecuteChanged 
{ 
    add 
    { 
     _internalCanExecuteChanged += value; 
     CommandManager.RequerySuggested += value; 
    } 
    remove 
    { 
     _internalCanExecuteChanged -= value; 
     CommandManager.RequerySuggested -= value; 
    } 
} 

/// <summary> 
/// This method can be used to raise the CanExecuteChanged handler. 
/// This will force WPF to re-query the status of this command directly. 
/// </summary> 
public void RaiseCanExecuteChanged() 
{ 
    if (canExecute != null) 
     OnCanExecuteChanged(); 
} 

/// <summary> 
/// This method is used to walk the delegate chain and well WPF that 
/// our command execution status has changed. 
/// </summary> 
protected virtual void OnCanExecuteChanged() 
{ 
    EventHandler eCanExecuteChanged = _internalCanExecuteChanged; 
    if (eCanExecuteChanged != null) 
     eCanExecuteChanged(this, EventArgs.Empty); 
} 

Answer 4

J'ai mis en place une solution pour gérer la dépendance de la propriété sur les commandes, voici le lien https://stackoverflow.com/a/30394333/1716620

grâce à vous finirez par avoir une commande comme ceci:

this.SaveCommand = new MyDelegateCommand<MyViewModel>(this, 
    //execute 
    () => { 
     Console.Write("EXECUTED"); 
    }, 
    //can execute 
    () => { 
     Console.Write("Checking Validity"); 
     return PropertyX!=null && PropertyY!=null && PropertyY.Length < 5; 
    }, 
    //properties to watch 
    (p) => new { p.PropertyX, p.PropertyY } 
); 

Answer 5

Si vous avez roulé votre propre classe qui implémente ICommand vous pouvez perdre beaucoup de mises à jour automatiques de statut qui vous oblige à compter sur rafraîchissante manuel plus devrait être nécessaire. Il peut également casser InvalidateRequerySuggested(). Le problème est qu'une simple implémentation ICommand ne parvient pas à lier la nouvelle commande au CommandManager.

La solution est d'utiliser les éléments suivants:

public event EventHandler CanExecuteChanged 
    { 
     add { CommandManager.RequerySuggested += value; } 
     remove { CommandManager.RequerySuggested -= value; } 
    } 

    public void RaiseCanExecuteChanged() 
    { 
     CommandManager.InvalidateRequerySuggested(); 
    } 

Ce abonnés façon à joindre CommandManager plutôt que votre classe et peuvent bien participer à des changements d'état de la commande.