wpf - commandmanager - ¿Por qué utilizar un RelayCommand o DelegateCommand en lugar de simplemente implementar ICommand?

icommand wpf

Question

Estoy aprendiendo sobre MVVM en WPF, soy completamente nuevo tanto para WPF como para MVVM (entiendo cómo funciona, pero nunca lo he usado ...)

Cada tutorial / artículo que encuentro en la web utiliza RelayCommand o DelegateCommand.

En mi opnion, estos patrones obligan a la máquina virtual a violar el principio de SRP, ya que mantendrá la lógica de comando dentro de ellos.

¿Por qué no usar una implementación personalizada de la interfaz ICommand? Solo así:

Imagine que está mostrando una persona y guardándola en la base de datos:

Mi Xaml sería este:

<StackPanel>                         
    <TextBlock Width="248" Height="24" Text="The name is:: " />
    <TextBlock Width="248" Height="24" Text="{Binding Name}">            
    </TextBlock>
    <TextBox HorizontalAlignment="Left" Name="textBox1" Width="120" Height="23" 
             VerticalAlignment="Top" Text="{Binding Name}"
             />
    <Button  Name="Salvar" VerticalAlignment="Bottom" 
            Command="{Binding SavePerson}" 
            CommandParameter="{Binding}">Save</Button>
</StackPanel>

Y esta es mi VM:

public class PersonVM: INotifyPropertyChanged
{
    private string nameValue;

    public string Name
    {
        get{
            return nameValue;
        }
        set
        {
            if (value != this.nameValue)
            {
                this.nameValue= value;
                NotifyPropertyChanged("Name");
            }
        }
    }


    public ICommand SavePerson{ get { return new SavePersonCommand(); } }
    #region INotifyPropertyChanged Members


    public event PropertyChangedEventHandler PropertyChanged;

    private void NotifyPropertyChanged(String info)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(info));
        }
    }

    #endregion
}

Y este es mi Comando:

public class SavePersonCommand: ICommand
{       
    #region ICommand Members

    public bool CanExecute(object parameter)
    {
        return (parameter as PersonVM) != null;            
    }

    public event EventHandler CanExecuteChanged;

    public void Execute(object parameter)
    {
            PersonVM person = parameter as PersonVM;
            if(person != null)
                //Actually Save the person...            
    }   


    #endregion
}

¿Cuál es el problema con mi enfoque?

Answer 1

Nada ... pero DelegateCommand es útil si tiene un Comando realmente específico solo para su ViewModel y no desea exponerlo a otros porque es realmente solo para su ViewModel. También me gustan los DelegateCommands porque no necesitan otra clase que acaba de pasar en su ViewModel, es menos código para escribir. Su enfoque es útil si su ViewModel suministrado es un ViewModel base que se comparte mucho y también permite compartir su Command.

Answer 2

Si no va a utilizar algún comando base (de un marco o su propio comando personalizado), se encontrará escribiendo el mismo código una y otra vez. Por ejemplo: no levanta evento CanExecuteChanged en su propio comando. Lo mismo ocurre con la implementación de INotifyPropertyChanged . Es por eso que todos están usando uno u otro framework MVVM.