DelegatingCommand.cs

using Bovender.Mvvm.ViewModels;
/* DelegatingCommand.cs
 * part of Daniel's XL Toolbox NG
 * 
 * Copyright 2014-2018 Daniel Kraus
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq.Expressions;
using System.Windows.Input;
using System.Windows.Threading;

namespace Bovender.Mvvm
{
    public class DelegatingCommand : ICommand
    {
        #region Constructors

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

        public DelegatingCommand(Action<object> execute, ViewModelBase viewModel)
            : this(execute)
        {
            _viewModel = viewModel;
        }

        public DelegatingCommand(Action<object> execute, Predicate<object> canExecute)
        {
            if (execute == null)
                throw new ArgumentNullException("execute");

            _execute = execute;
            _canExecute = canExecute;
        }

        public DelegatingCommand(Action<object> execute, Predicate<object> canExecute,
             ViewModelBase viewModel)
            : this(execute, canExecute)
        {
            _viewModel = viewModel;
        }

        #endregion

        #region ICommand Members

        public bool CanExecute(object parameter)
        {
            return _canExecute == null ? true : _canExecute(parameter);
        }

        public event EventHandler CanExecuteChanged
        {
            add
            {
                CommandManager.RequerySuggested += value;
                CommandManagerHelper.AddWeakReferenceHandler(ref _canExecuteChangedHandlers, value, 2);
            }
            remove
            {
                CommandManager.RequerySuggested -= value;
                CommandManagerHelper.RemoveWeakReferenceHandler(_canExecuteChangedHandlers, value);
            }
        }

        public void Execute(object parameter)
        {
            try
            {
                _execute(parameter);
            }
            catch (Exception e)
            {
                // Let the central exception manager do its work.
                // If the exception was not managed, rethrow it.
                if (!ExceptionHandler.CentralHandler.Manage(this, e))
                {
                    throw;
                }
            }
        }

        #endregion // ICommand Members

        #region Public methods

        public DelegatingCommand ListenOn(string propertyName)
        {
            if (_viewModel == null)
            {
                throw new InvalidOperationException(
                    "To execute 'ListenOn', construct this DelegatingCommand with the parent view model.");
            }
            _viewModel.PropertyChanged += (object sender, PropertyChangedEventArgs e) =>
            {
                if (e.PropertyName == propertyName)
                {
                    if (_viewModel.ViewDispatcher != null)
                    {
                        _viewModel.ViewDispatcher.BeginInvoke(
                            new Action(
                                () => this.OnCanExecuteChanged()
                                )
                            );
                    }
                    else
                    {
                        this.OnCanExecuteChanged();
                    }
                }
            };

            return this;
        }

        #endregion

        #region Protected methods

        protected virtual void OnCanExecuteChanged()
        {
            CommandManagerHelper.CallWeakReferenceHandlers(_canExecuteChangedHandlers);
        }

        #endregion

        #region Private properties

        readonly Action<object> _execute;
        readonly Predicate<object> _canExecute;
        readonly ViewModelBase _viewModel;
        private List<WeakReference> _canExecuteChangedHandlers;

        #endregion
    }
}