Can execute question using delegate commands in prism

This seems like a dumb question but I have looked through the docs for prism and searched the internet and can't find an example... Here is the deal.

I am using a DelegateCommand in Prism, it is working fine except when I assign a delegate to the can execute to the CanExecute method. in another view model I have a event that takes a bool that I am publishing too and I can see that the event is firing and that the bool is getting passed to my view model with the command in it no problem but this is what I don't understand... How does can execute know that the state has changed? Here is some code for the example.

from the view models ctor

eventAggregator.GetEvent<NavigationEnabledEvent>().Subscribe(OnNavigationEnabledChange, ThreadOption.UIThread);

NavigateCommand = new DelegateCommand(OnNavigate, () => nextButtonEnabled);

Now - here is the OnNavigationEnableChange event.

private v开发者_JAVA技巧oid OnNavigationEnabledChange(bool navigationState)
    {
      nextButtonEnabled = navigationState;
    }
enter code here

Like - I am totally missing something here - how does the command know that nextButtonEnabled is no true?

If someone could point me to a working example that would be awesome.

OK - thanks!

---

This is why I don't use the implementation of DelegateCommand in Prism. I've always hated the callback-based approach for enabling/disabling commands. It's entirely unnecessary, and as far as I can tell, its only (and rather doubtful) 'benefit' is that it's consistent with how execution itself is handled. But that has always seemed pointless to me because execution and enabling/disabling are clearly very different: a button knows when it wants to execute a command but doesn't know when the command's status might have changed.

So I always end up writing something like this:

public class RelayCommand : ICommand
{
    private bool _isEnabled;
    private Action _onExecute;

    public RelayCommand(Action executeHandler)
    {
        _isEnabled = true;
        _onExecute = executeHandler;
    }

    public bool IsEnabled
    {
        get { return _isEnabled; }
        set
        {
            _isEnabled = value;
            if (CanExecuteChanged != null)
            {
                CanExecuteChanged(this, EventArgs.Empty);
            }
        }
    }


    public bool CanExecute(object parameter)
    {
        return _isEnabled;
    }

    public event EventHandler CanExecuteChanged;

    public void Execute(object parameter)
    {
        _onExecute();
    }
}

(If necessary you could modify this to use weak references to execute change event handlers, like Prism does.)

But to answer your question: how is the callback approach even meant to work? Prism's DelegateCommand offers a RaiseCanExecuteChanged method you can invoke to ask it to raise the event that'll cause command invokers to query your command's CanExecute. Given that you have to tell the DelegateCommand any time your enabled status changes, I don't see any meaningful benefit of a callback-based approach. (Sometimes you see a broadcast model though - arranging so that any change in status anywhere notifies all command invokers! In that case, a callback is useful because it means it doesn't matter if you don't know what actually changed. But requerying every single command seems unpleasant to me.)

---

Answering your question how does the command know that it is now enabled:

NavigateCommand = new DelegateCommand(OnNavigate, () => nextButtonEnabled);

This overload of the DelegateCommand constructor takes 2 parameters: The first is the command action and the second is the CanExecute delegate that returns bool. in your example your CanExecute action always returns nextButtonEnabled

eventAggregator.GetEvent<NavigationEnabledEvent>().Subscribe(OnNavigationEnabledChange, ThreadOption.UIThread);

triggers OnNavigationEnabledChange that changes nextButtonEnabled this is how it works...