RelayCommand.cs

Go to the documentation of this file.

using System;
using System.Threading;
using System.Windows.Input;
 
namespace Dreamine.MVVM.ViewModels
{
    public sealed class RelayCommand : ICommand
    {
        private readonly Action _execute;
        private readonly Func<bool>? _canExecute;
 
        private readonly SynchronizationContext? _syncContext;

        public RelayCommand(Action execute, Func<bool>? canExecute = null)
        {
            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
            _canExecute = canExecute;

            _syncContext = SynchronizationContext.Current;
        }

        public bool CanExecute(object? parameter)
        {
            return _canExecute?.Invoke() ?? true;
        }

        public void Execute(object? parameter)
        {
            _execute();
        }

        public event EventHandler? CanExecuteChanged;

        public void RaiseCanExecuteChanged()
        {
            var handler = CanExecuteChanged;
            if (handler is null)
                return;

            if (_syncContext != null && !ReferenceEquals(SynchronizationContext.Current, _syncContext))
            {
                _syncContext.Post(static state =>
                {
                    var tuple = ((RelayCommand cmd, EventHandler evt))state!;
                    tuple.evt.Invoke(tuple.cmd, EventArgs.Empty);
                }, (this, handler));
 
                return;
            }

            handler.Invoke(this, EventArgs.Empty);
        }
    }

    public sealed class RelayCommand<T> : ICommand
    {
        private readonly Action<T> _execute;
        private readonly Func<T, bool>? _canExecute;
 
        private readonly SynchronizationContext? _syncContext;

        public RelayCommand(Action<T> execute, Func<T, bool>? canExecute = null)
        {
            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
            _canExecute = canExecute;

            _syncContext = SynchronizationContext.Current;
        }

        public bool CanExecute(object? parameter)
        {
            if (_canExecute is null)
                return true;

            if (!TryGetParameter(parameter, out var value))
                return false;
 
            return _canExecute.Invoke(value);
        }

        public void Execute(object? parameter)
        {
            if (!TryGetParameter(parameter, out var value))
                throw new ArgumentException($"Command parameter is not assignable to {typeof(T).FullName}.", nameof(parameter));
 
            _execute(value);
        }

        public event EventHandler? CanExecuteChanged;

        public void RaiseCanExecuteChanged()
        {
            var handler = CanExecuteChanged;
            if (handler is null)
                return;

            if (_syncContext != null && !ReferenceEquals(SynchronizationContext.Current, _syncContext))
            {
                _syncContext.Post(static state =>
                {
                    var tuple = ((RelayCommand<T> cmd, EventHandler evt))state!;
                    tuple.evt.Invoke(tuple.cmd, EventArgs.Empty);
                }, (this, handler));
 
                return;
            }
 
            handler.Invoke(this, EventArgs.Empty);
        }

        private static bool TryGetParameter(object? parameter, out T value)
        {
            if (parameter is null)
            {
                if (default(T) is null)
                {
                    value = default!;
                    return true;
                }

                value = default!;
                return false;
            }

            if (parameter is T t)
            {
                value = t;
                return true;
            }

            value = default!;
            return false;
        }
    }
}