Question

I am trying to use a RoutedCommand on my view so that I can use the CanExecute functionality, but the only way I can get it to work is with a DelegateCommand from Prism. When I try to use the RoutedCommand the button stays inactive and the CanExecute function never gets used.

I’ve tried putting a CommandBinding on my XAML but that gives a “Only instance methods on the generated or code-behind class are valid.” error. Here is that code:

<Window.CommandBindings>
    <CommandBinding Command="AddCommand"
                Executed="my:SettingsDialogViewModel.AddCommandMethod"
                CanExecute="my:SettingsDialogViewModel.AddCommandMethodCanExecute" />
</Window.CommandBindings>

I’ve also tried setting up a CommandBinding in code, but that doesn’t help either. I’m just not sure how to get it to work, short of sticking it in the code-behind, or implementing some ridiculously complicated looking thing I’ve found on the web.

Thanks for any help 🙂

EDIT:
Here are the methods I am trying to use:

public void AddCommandMethod()
{
    if (SelectedMain != null)
    {
        SelectedMain.IsDirty = true;
        _faveAppList.Add(SelectedMain);
        SelectedMain.ListOrder = _faveAppList.Count;
        _mainAppList.Remove(SelectedMain);
        _listDirty = true;
    }
}
public void AddCommandMethodCanExecute(object sender, CanExecuteRoutedEventArgs e)
{
    e.CanExecute = true;
}

Answer 1

That isn’t the proper MVVM notation. I’ll provide one way of doing this.

// MyView.cs
public class MyView : UserControl
{ 
    public MyViewViewModel ViewModel 
    { 
        get { return (MyViewViewModel) DataContext;}
        set { DataContext = value; }
    }
}

// DelegateCommand.cs
public class DelegateCommand : ICommand
{
      private readonly Predicate<object> _canExecute;
      private readonly Action<object> _execute;

      public DelegateCommand(Action<object> execute)
           : this(execute, null) {}

      public DelegateCommand(Action<object> execute, Predicate<object> canExecute)
      {
           _execute = execute;
           _canExecute = canExecute;
      }

      public override bool CanExecute(object parameter)
      {
          if (_canExecute == null)
          {
            return true;
          }
          return _canExecute(parameter);
      }

      public override void Execute(object parameter)
      {
        _execute(parameter);
      }     
 }

 // MyViewViewModel.cs
 public class MyViewViewModel 
 {
    public ICommand AddCommand {get;set;}

    public MyViewViewModel()
    {
          AddCommand = new DelegateCommand (AddCommandMethod, AddCommandMethodCanExecute);
    }

    private void AddCommandMethod (object parameter)
    {

    }

    private bool AddCommandMethodCanExecute(object parameter)
    {
         // Logic here
         return true;
    }
 }

 // MyView.xaml

 <Button Command="{Binding AddCommand}" />