CommandGroup CanExecute只能偶尔出现

Question

I have been trying to track this down for quite a while now and am drawing a total blank, so maybe there is something I am missing that others might see? NOTE: this is currently only being seen on one QA machine, thus why I cannot debug this like normal

I am using the Command Group code from Josh Smith's code project with CommandReference implemented at the bottom of this post.

The problem is that the button that is bound to the CommandGroup is disabled, however the other two are not. Notice that the CommandGroup button is just a concatenation of the other two. So, it stands that if both are enabled, then so should the CommandGroup button. So, I am guessing this has to do with either the CommandGroup or CommandReference ...any ideas would be helpful.

My current working hypothesis is that ApplicationCommands.Close being treated as an ICommand in the CommandGroup versus its normal RoutedUICommand is the problem. Especially as I can create an imbalance between two buttons bound to the same command by calling ApplicationCommands.Close.CanExecute(null) directly. But, I am not sure how to resolve this...

RoutedCommand 's CanExecute uses this FilterInputElement(Keyboard.FocusedElement) if CanExecute is called without an IInputElement ....but in the case I am trying just above, I am calling ApplicationCommands.Close the same no matter where it's origin is from

CommandGroup

<Button Content="OK" IsDefault="True">
  <Button.Resources>
    <commonCommands:CommandReference x:Key="SaveCommand" Command="{Binding SaveDeviceCommand}"/>
  </Button.Resources>
  <Button.Command>
    <commonCommands:CommandGroup>
      <commonCommands:CommandGroup.Commands>
        <commonCommands:CommandReference Command="{StaticResource SaveCommand}"/>
        <x:Static Member="ApplicationCommands.Close"/>
      </commonCommands:CommandGroup.Commands>
    </commonCommands:CommandGroup>
  </Button.Command>
</Button>
<Button Content="Cancel" Command="ApplicationCommands.Close" IsCancel="True"/>
<Button Content="Apply" Command="{Binding SaveDeviceCommand}"/>

Command Reference:

public class CommandReference : Freezable, ICommand
{

public static readonly DependencyProperty CommandProperty =
  DependencyProperty.Register("Command", typeof (ICommand), typeof (CommandReference), new PropertyMetadata(OnCommandChanged));

public ICommand Command
{
  get { return (ICommand) GetValue(CommandProperty); }
  set { SetValue(CommandProperty, value); }
}

#region ICommand Members

public bool CanExecute(object parameter)
{
  return Command != null && Command.CanExecute(parameter);
}

public void Execute(object parameter)
{
  Command.Execute(parameter);
}

public event EventHandler CanExecuteChanged;

private static void OnCommandChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs eventArgs)
{
  var commandReference = dependencyObject as CommandReference;
  if (commandReference == null) return;
  var oldCommand = eventArgs.OldValue as ICommand;
  var newCommand = eventArgs.NewValue as ICommand;

  if (oldCommand != null)
    oldCommand.CanExecuteChanged -= commandReference.CanExecuteChanged;
  if (newCommand != null)
    newCommand.CanExecuteChanged += commandReference.CanExecuteChanged;
}

#endregion

#region Freezable

protected override Freezable CreateInstanceCore()
{
  throw new NotImplementedException();
}

#endregion
}

Answer 1

I am still waiting on QA to verify this, however I was able to get a similar issue that I could reproduce, and it turned out that my ICommand needed to be set up as

public event EventHandler CanExecuteChanged
{
  add { CommandManager.RequerySuggested += value; }
  remove { CommandManager.RequerySuggested -= value; }
}

instead of

public event EventHandler CanExecuteChanged;

public void RaiseCanExecuteChanged()...