Button doesn't become disabled when command CanExecute is false
command, mvvm, prism, wpf
Solution
I see you're using Prism and its `NotificationObject` and `DelegateCommand`, so we should expect there not to be a bug in RaiseCanExecuteChanged().
However, the reason for the behaviour is that Prism's RaiseCanExecuteChanged operates synchronously, so `CanDoStuff()` is called while we're still inside the implementation of `ICommand.Execute()` and the result then appears to be ignored.
If you create another button with its own command and call `_myCommand.RaiseCanExecuteChanged()` from that command/button, the first button will be enabled/disabled as you expect.
Or, if you try the same thing with MVVM Light and RelayCommand your code will work because MVVM Light's `RaiseCanExecuteChanged` calls `CommandManager.InvalidateRequerySuggested()` which invokes the callback to `CanDoStuff` asynchronously using `Dispatcher.CurrentDispatcher.BeginInvoke`, avoiding the behaviour you're seeing with Prism's implementation.
Problem
I have a simple-as-can be window with a button tied to a ViewModel with a command. I expect the button to be disabled if MyCommand.CanExecute() is false. But it seems that WPF will only set the IsEnabled property when the window is first drawn. Any subsequent action does not effect the button's visible state. I am using a DelegateCommand from Prism. My View: ``` <Window x:Class="WpfApplication1.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="MainWindow" Height="350" Width="525"> <Grid> <Button Content="Click Here" Command="{Binding MyCommand}" Width="100" Height="50"/> </Grid> ``` and my ViewModel: ``` public class MyVM : NotificationObject { public MyVM() { _myCommand = new DelegateCommand(DoStuff, CanDoStuff); } private void DoStuff() { Console.WriteLine("Command Executed"); _myCommand.RaiseCanExecuteChanged(); } private bool CanDoStuff() { var result = DateTime.Now.Second % 2 == 0; Console.WriteLine("CanExecute is {0}", result); return result; } private DelegateCommand _myCommand; public ICommand MyCommand { get { return _myCommand; } } } ``` 50% of the time, when my application loads, the button is properly disabled. However, if it's enabled when the window loads, and I click the button to execute the command, I expect 50% of the time for the button to become disabled, but it never does. The command does not execute, but I can still click the button. How do I get WPF to understand that the button should be disabled when CanExecute() is false?