Beliebige WinRT iCommand/CommandBinding Implementierungen sind da draußen?

Question

Das Abstrahieren von Befehlen in das Ansichtsmodell ist eine wertvolle Übung bei XAML/MVVM-Projekten. Ich verstehe das. Und ich sehe ICommand in WinRT; aber wie implementieren wir es? Ich habe keine Probe gefunden, die tatsächlich funktioniert. Weiß jemand?

Answer 1

Mein Favorit aller Zeiten ist der DelegateCommand, der vom PnP-Team bereitgestellt wird. Es ermöglicht Ihnen, eine typisierte Befehl zu erstellen:

MyCommand = new DelegateCommand<MyEntity>(OnExecute); 
... 
private void OnExecute(MyEntity entity) 
{...} 

Es ermöglicht auch eine Möglichkeit bietet, die CanExecuteChanged Ereignis (deaktivieren/aktivieren Sie den Befehl)

MyCommand.RaiseCanExecuteChanged(); 

Hier ist der Code zu erhöhen:

public class DelegateCommand<T> : ICommand 
{ 
    private readonly Func<T, bool> _canExecuteMethod; 
    private readonly Action<T> _executeMethod; 

    #region Constructors 

    public DelegateCommand(Action<T> executeMethod) 
     : this(executeMethod, null) 
    { 
    } 

    public DelegateCommand(Action<T> executeMethod, Func<T, bool> canExecuteMethod) 
    { 
     _executeMethod = executeMethod; 
     _canExecuteMethod = canExecuteMethod; 
    } 

    #endregion Constructors 

    #region ICommand Members 

    public event EventHandler CanExecuteChanged; 

    bool ICommand.CanExecute(object parameter) 
    { 
     try 
     { 
      return CanExecute((T)parameter); 
     } 
     catch { return false; } 
    } 

    void ICommand.Execute(object parameter) 
    { 
     Execute((T)parameter); 
    } 

    #endregion ICommand Members 

    #region Public Methods 

    public bool CanExecute(T parameter) 
    { 
     return ((_canExecuteMethod == null) || _canExecuteMethod(parameter)); 
    } 

    public void Execute(T parameter) 
    { 
     if (_executeMethod != null) 
     { 
      _executeMethod(parameter); 
     } 
    } 

    public void RaiseCanExecuteChanged() 
    { 
     OnCanExecuteChanged(EventArgs.Empty); 
    } 

    #endregion Public Methods 

    #region Protected Methods 

    protected virtual void OnCanExecuteChanged(EventArgs e) 
    { 
     var handler = CanExecuteChanged; 
     if (handler != null) 
     { 
      handler(this, e); 
     } 
    } 

    #endregion Protected Methods 
}