命令的CanExecute在列表框中不起作用

Question

I've a listbox that contains some "Application" objects. An "Application" object can be started or stopped.

For each element in my Listbox I've 2 buttons, the first to start application and the second to stop the application.

But, when I click on Start button, the CanExecute of command "Stop" isn't reevaluated until I click inside the application, despite the "CommandManager.InvalidateRequerySuggested();"

            <ListBox Grid.Row="1"  ItemsSource="{Binding Applications}" Grid.ColumnSpan="3" BorderThickness="0" Background="#FFE8E8E8" HorizontalContentAlignment="Stretch">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <Button Margin="5,0" Content = "Start" 
                            Command="{Binding StartCommand}"
                             Visibility="{Binding IsRunning, Converter={Converters:InvertedBoolToVisibilityConverter}}"/>
                    <Button Margin="5,0"  Content = "Stop" 
                            Command="{Binding StopCommand}"
                            Visibility="{Binding IsRunning, Converter={Converters:BoolToVisibilityConverter}}"/>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>

On ApplicationViewModel :

public bool IsRunning
{
  get
  {
    return this.m_IsRunning;
  }
  set
  {
    this.m_IsRunning = value;
    this.OnPropertyChanged("IsRunning");
    CommandManager.InvalidateRequerySuggested();
  }
}
public ICommand StartCommand
{
  get
  {
    if (this.m_StartCommand == null)
    {
      this.m_StartCommand = new RelayCommand(p => !this.IsRunning, p => this.Start());
    }
    return this.m_StartCommand;
  }
}

public ICommand StopCommand
{
  get
  {
    if (this.m_StopCommand == null)
    {
      this.m_StopCommand = new RelayCommand(p => this.IsRunning, p => this.Stop());
    }
    return this.m_StopCommand;
  }
}

My RelayCommand Class :

public class RelayCommand : ICommand
{
    #region Member Fields

    /// <summary>
    /// Contains the list of actions.
    /// </summary>
    private readonly Action<object> _execute;

    /// <summary>
    /// Contains the predicate _canExecute.
    /// </summary>
    private readonly Predicate<object> _canExecute;

    #endregion

    #region Constructors

    /// <summary>
    /// Initializes a new instance of the <see cref="RelayCommand"/> class.
    /// </summary>
    /// <param name="execute">The execute.</param>
    public RelayCommand(Action<object> execute)
      : this(null, execute)
    {
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="RelayCommand"/> class.
    /// </summary>
    /// <param name="canExecute">The can execute.</param>
    /// <param name="execute">The execute.</param>
    public RelayCommand(Predicate<object> canExecute, Action<object> execute)
    {
      if (execute == null)
      {
        throw new ArgumentNullException("execute");
      }

      this._execute = execute;
      this._canExecute = canExecute;
    }
    #endregion // Constructors

    #region ICommand Members

    /// <summary>
    /// Occurs when changes occur that affect whether or not the command should execute.
    /// </summary>
    public event EventHandler CanExecuteChanged
    {
      add { CommandManager.RequerySuggested += value; }
      remove { CommandManager.RequerySuggested -= value; }
    }

    /// <summary>
    /// Defines the method that determines whether the command can execute in its current state.
    /// </summary>
    /// <param name="parameter">Data used by the command.  If the command does not require data to be passed, this object can be set to null.</param>
    /// <returns>
    /// true if this command can be executed; otherwise, false.
    /// </returns>
    [DebuggerStepThrough]
    public bool CanExecute(object parameter)
    {
      return this._canExecute == null ? true : this._canExecute(parameter);
    }

    /// <summary>
    /// Defines the method to be called when the command is invoked.
    /// </summary>
    /// <param name="parameter">Data used by the command.  If the command does not require data to be passed, this object can be set to null.</param>
    public void Execute(object parameter)
    {
      this._execute(parameter);
    }
    #endregion
}

Answer 1

Try RaiseCanExecuteChanged() of your StopCommand directly in your handler of StartCommand .

If you have implemented the your Command yourself, then you can add RaiseCanExecuteChanged to it like. It will call CanExecuteChanged event

    public void RaiseCanExecuteChanged()
    {
        if (CanExecuteChanged != null)
        {
            CanExecuteChanged(this, EventArgs.Empty);
        }
    }