WPF - Come forzare un comando per rivalutare 'CanExecute' attraverso i suoi CommandBindings

Question

ho un Menu dove ogni MenuItem nella gerarchia ha la proprietà Command impostata su un RoutedCommand ho definito. L'associato CommandBinding fornisce un callback per la valutazione di CanExecute che controlla lo stato abilitato di ogni MenuItem.

Questo quasi funziona. Le voci di menu inizialmente presentano gli stati abilitati e disabilitati corretti. Tuttavia, quando i dati che la mia callback CanExecute utilizza modifiche, ho bisogno del comando per ri-richiedere un risultato dal mio callback affinché questo nuovo stato si rifletta nell'interfaccia utente.

Non sembrano esserci metodi pubblici su RoutedCommand o CommandBinding per questo.

Si noti che la richiamata viene utilizzata di nuovo quando si fa clic o si digita nel controllo (suppongo che sia attivato in input perché il passaggio del mouse non causa l'aggiornamento).

Answer 1

Non

la più bella del libro, ma è possibile utilizzare il CommandManager di invalidare tutte CommandBinding:

CommandManager.InvalidateRequerySuggested(); 

Tutte le informazioni MSDN

Answer 2

Per chi si imbatte in questo più tardi; Se si utilizza MVVM e Prism, l'implementazione di DelegateCommand di Prism ICommand fornisce un metodo .RaiseCanExecuteChanged() per farlo.

Answer 3

Non ho potuto utilizzare CommandManager.InvalidateRequerySuggested(); perché stavo ottenendo un successo in termini di prestazioni.

Ho usato il comando di Delegazione MVVM Helper, che appare come di seguito (l'ho ottimizzato un po 'per il nostro req). devi chiamare command.RaiseCanExecuteChanged() da 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

Ho implementato una soluzione per gestire le proprietà di dipendenza sui comandi, qui il link https://stackoverflow.com/a/30394333/1716620

grazie a che si finirà per avere un comando come questo:

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

Se si è rotolato la propria classe che implementa ICommand si può perdere un sacco di aggiornamenti automatici di stato ti costringe a fare affidamento su rinfrescante manuale più che dovrebbe essere necessario. Può anche rompere InvalidateRequerySuggested(). Il problema è che una semplice implementazione ICommand non riesce a collegare il nuovo comando allo CommandManager.

La soluzione è quella di utilizzare il seguente: gli abbonati

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

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

questo modo attribuiscono alla CommandManager piuttosto che la vostra classe e possono adeguatamente partecipare a cambiamenti di stato di comando.