¿Alguna implementación de WinRT iCommand/CommandBinding por ahí?

Question

Resumiendo comandos en el Modelo de Vista es una práctica valiosa con proyectos XAML/MVVM. Lo entiendo. Y, veo ICommand en WinRT; pero, ¿cómo lo implementamos? No he encontrado una muestra que realmente funcione. ¿Nadie sabe?

Answer 1

Mi favorito de todos los tiempos tiene que ser el DelegateCommand proporcionado por el equipo de PnP. Se le permite crear un comando escrito:

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

También permite que proporciona una manera de provocar el evento CanExecuteChanged (para activar/desactivar el comando)

MyCommand.RaiseCanExecuteChanged(); 

Aquí está el código:

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 
}