Отключить кнопку на время выполнения команды

public class MainWindowVM 
    {
        private bool IsButtonEnabled { get; set; }
        public RelayCommand RunMethodCommand { get; }
 
        public ObservableCollection<Number> Numbers { get; set; }
 
        public MainWindowVM()
        {
            IsButtonEnabled = true;
 
            RunMethodCommand = new RelayCommand(x => RunMethod(), x => RunCanMethod());
 
            Numbers = new ObservableCollection<Number>();
        }
 
        private bool RunCanMethod() => IsButtonEnabled;
        private async void RunMethodAsync()
        {
            IsButtonEnabled = false;
            RunMethodCommand.Invalidate();
 
            await Task.Run(() => RunMethod());
 
            IsButtonEnabled = true;
            RunMethodCommand.Invalidate();
        }
 
        private void RunMethod()
        {
            for (int i = 0; i < 9; i++)
            {
                Numbers.Add(new Number() { Value = i });
                Thread.Sleep(500);
            }
        }
    }

#region Делегаты для методов WPF команд
    public delegate void ExecuteHandler(object parameter);
    public delegate bool CanExecuteHandler(object parameter);
    #endregion
 
    #region Класс команд - RelayCommand
    /// <summary>Класс реализующий интерфейс ICommand для создания WPF команд</summary>
    public class RelayCommand : ICommand
    {
        private readonly CanExecuteHandler _canExecute;
        private readonly ExecuteHandler _onExecute;
        private readonly EventHandler _requerySuggested;
 
        /// <summary>Событие извещающее об изменении состояния команды</summary>
        public event EventHandler CanExecuteChanged;
 
        /// <summary>Конструктор команды</summary>
        /// <param name="execute">Выполняемый метод команды</param>
        /// <param name="canExecute">Метод разрешающий выполнение команды</param>
        public RelayCommand(ExecuteHandler execute, CanExecuteHandler canExecute = null)
        {
            _onExecute = execute;
            _canExecute = canExecute;
 
            _requerySuggested = (o, e) => Invalidate();
            CommandManager.RequerySuggested += _requerySuggested;
        }
 
        public void Invalidate()
            => Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                CanExecuteChanged?.Invoke(this, EventArgs.Empty);
            }), null);
 
        /// <summary>Вызов разрешающего метода команды</summary>
        /// <param name="parameter">Параметр команды</param>
        /// <returns>True - если выполнение команды разрешено</returns>
        public bool CanExecute(object parameter) => _canExecute == null ? true : _canExecute.Invoke(parameter);
 
        /// <summary>Вызов выполняющего метода команды</summary>
        /// <param name="parameter">Параметр команды</param>
        public void Execute(object parameter) => _onExecute?.Invoke(parameter);
    }
    #endregion

RunMethodCommand = new RelayCommand(x => RunMethodAsync(), x => RunCanMethod());

private void RunMethod()
        {
            for (int i = 0; i < 9; i++)
            {
                Action action = new Action(() => Numbers.Add(new Number() { Value = i }));
                Application.Current.Dispatcher.BeginInvoke(action, null);
                
                Thread.Sleep(500);
            }
        }

            ConnectToServerCommand = new RelayCommand(x => ConnectToServer(),
                x => IsConnection == false ? true : false);