Синхронизация Модели с UI потоком

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        DataContext = Task.Factory.StartNew(() => new UIModel()).Result;
    }
}

public class UIModel : INotifyPropertyChanged
{
    private string currentTime = "none";
    private UICommand uiCommand;
 
    public UIModel()
        => uiCommand = new(this);
 
    public string CurrentTime
    {
        get => currentTime;
        set
        {
            currentTime = value;
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CurrentTime)));
        }
    }
 
    public event PropertyChangedEventHandler? PropertyChanged;
 
    public ICommand GetTime => uiCommand;
}

public class UICommand : ICommand
{
    private readonly UIModel _model;
    private Task? task;
 
 
    public event EventHandler? CanExecuteChanged;
 
    public UICommand(UIModel model)
        => _model = model;
 
    public bool CanExecute(object? parameter)
        => task is null;
 
    public void Execute(object? parameter)
    {
        task = Task.Run(async () => 
        {
            try
            {
                var i1 = Environment.CurrentManagedThreadId;
                await Task.Delay(TimeSpan.FromSeconds(2));
                var i2 = Environment.CurrentManagedThreadId;
                _model.CurrentTime = $"[{i1} ; {i2}] = {DateTime.Now}";
                task = null;
 
                CanExecuteChanged?.Invoke(this, EventArgs.Empty); // $exception {"The calling thread cannot access this object because a different thread owns it."} System.InvalidOperationException
            }
            catch
            {
                ;
            }
        });
        CanExecuteChanged?.Invoke(this, EventArgs.Empty);
    }
}

public async Task ExecuteAsync()
    {
        if (CanExecute())
        {
            try
            {
                _isExecuting = true; // вот кажись тут явно нужен вызов RaiseCanExecuteChanged
                await _execute();
            }
            finally
            {
                _isExecuting = false;
            }
        }
 
        RaiseCanExecuteChanged();
    }

using System;
using System.Windows.Input;
 
namespace MVVM
{
    public class RelayCommand : ICommand
    {
        private Action<object> execute;
        private Func<object, bool> canExecute;
 
        public event EventHandler CanExecuteChanged
        {
            add { CommandManager.RequerySuggested += value; }
            remove { CommandManager.RequerySuggested -= value; }
        }
 
        public RelayCommand(Action<object> execute, Func<object, bool> canExecute = null)
        {
            this.execute = execute;
            this.canExecute = canExecute;
        }
 
        public bool CanExecute(object parameter)
        {
            return this.canExecute == null || this.canExecute(parameter);
        }
 
        public void Execute(object parameter)
        {
            this.execute(parameter);
        }
    }
}

        public RelayCommand AddCommand
        {
            get
            {
                return addCommand ??
                  (addCommand = new RelayCommand(obj =>
                  {
                      Phone phone = new Phone();
                      Phones.Insert(0, phone);
                      SelectedPhone = phone;
                  }));
            }
        }

        public RelayCommand AddCommand =>addCommand ??= new RelayCommand(obj =>
        {
            Phone phone = new Phone();
            Phones.Insert(0, phone);
            SelectedPhone = phone;
         });