Моментальный переход страниц назад/вперед mvvm

abstract class StateVM<TParent> : BaseVM, IState<TParent>
    {
        private IAsyncCommand _goBackCommand;
        private IAsyncCommand _goForwardCommand;
 
        // Сообщает StateNavigator сохранять ли стейт в истории перемещений,
        // чтобы вернуться на него по GoBack() или GoForward()
        public abstract bool IsHistoryPart { get; }
 
        public TParent Parent { get; set; }
        public IStateNavigator<TParent> Navigator { get; set; }
 
        public IAsyncCommand GoBackCommand
        {
            get { return _goBackCommand ?? (_goBackCommand = new AsyncDelegateCommand(GoBack, CanGoBack)); }
        }
        
        public IAsyncCommand GoForwardCommand
        {
            get { return _goForwardCommand ?? (_goForwardCommand = new AsyncDelegateCommand(GoForward, CanGoForward)); }
        }
 
        protected virtual async Task GoBack()
        {
            await Navigator.GoBack();
        }
 
        protected  virtual bool CanGoBack()
        {
            return Navigator.CanGoBack;
        }
 
        protected virtual async Task GoForward()
        {
            await Navigator.GoForward();
        }
 
        protected virtual bool CanGoForward()
        {
            return Navigator.CanGoForward;
        }

private IAsyncCommand _goBackCommand;
 public IAsyncCommand GoBackCommand
        {
            get { return _goBackCommand ?? (_goBackCommand = new AsyncDelegateCommand(GoBack, CanGoBack)); }
        }
protected virtual async Task GoBack()
        {
            bool enable = false;
            await Navigator.GoBack();
            enable = true;
        }
 
        protected  virtual bool CanGoBack()
        {
            return Navigator.CanGoBack;
        }

abstract class StateVM<TParent> : BaseVM, IState<TParent>
    {
        protected bool isTransition = false;
        protected virtual async Task GoBack()
        {
            if (isTransition)
                 return;
            isTransition = true;
            await Navigator.GoBack();
            isTransition = false;
        }
 
        protected  virtual bool CanGoBack()
        {
            return !isTransition && Navigator.CanGoBack;
        }
 
        protected virtual async Task GoForward()
        {
            if (isTransition)
                 return;
            isTransition = true;
            await Navigator.GoForward();
            isTransition = false;
        }
 
        protected virtual bool CanGoForward()
        {
            return !isTransition && Navigator.CanGoForward;
        }

private bool isTransitionProcessing = false;
 
private ICommand _goCommand;
 
public ICommand GoCommand
{
    get { return _goCommand ?? (_goCommand = new AsyncDelegateCommand(Go, CanGo)); }
}
 
private async Task Go()
{
    isTransitionProcessing = true;
    await Navigator.GoForward();
    isTransitionProcessing = false;
}
 
private bool CanGo()
{
    return !isTransitionProcessing && Navigator.CanGoForward; 
}

    public class TestInvalidateTaskVM : OnPropertyChangedClass
    {
        private string _message;
        private bool _isCanInvalidate;
        private bool _isEnabled;
        private RelayCommand _taskRunCommand;
 
        public string Message { get => _message; set { _message = value; OnPropertyChanged(); } }
        public bool IsCanInvalidate { get => _isCanInvalidate; set { _isCanInvalidate = value; OnPropertyChanged(); } }
 
        public bool IsEnabled
        {
            get => _isEnabled;
            set
            {
                _isEnabled = value;
                OnPropertyChanged();
                Message = IsEnabled ? "Активна" : "Не активна";
                if (IsCanInvalidate)
                    TaskRunCommand.Invalidate();
            }
        }
 
        public RelayCommand TaskRunCommand => _taskRunCommand ?? (_taskRunCommand = new RelayCommand(TaskRunMetodAsync, p => IsEnabled));
 
        private async void TaskRunMetodAsync(object parameter)
        {
            await Task.Run(() => TaskRunMetod(parameter)); ;
        }
 
        private void TaskRunMetod(object parameter)
        {
            IsEnabled = false;
            Thread.Sleep(5000);
            IsEnabled = true;
        }
        public TestInvalidateTaskVM() => IsEnabled = true;
    }

        public RelayCommand TaskRunCommand => _taskRunCommand ?? (_taskRunCommand = new RelayCommand(TaskRunMetodAsync));