Платформо-Независимая ViewModel

    public class Notifier : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged = delegate { };
 
        protected void NotifyPropertyChanged(
            string propertyName)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    private readonly EventHandler _requerySuggested;
 
    /// <summary>Событие извещающее об измении состояния команды</summary>
    public event EventHandler CanExecuteChanged;
 
    /// <summary>Конструктор команды</summary>
    /// <param name="execute">Выполняемый метод команды</param>
    /// <param name="canExecute">Метод разрешающий выполнение команды</param>
    public RelayCommand(Action<object> execute, Func<object, bool> canExecute = null)
    {
        _onExecute = execute;
        _canExecute = canExecute;
 
        _requerySuggested = (o, e) => Invalidate();
        CommandManager.RequerySuggested += _requerySuggested;
    }
 
    public void Invalidate() => CanExecuteChanged?.Invoke(this, EventArgs.Empty);

namespace Simplified
{
    #region Делегаты для методов WPF команд
    public delegate void ExecuteHandler(object parameter);
    public delegate bool CanExecuteHandler(object parameter);
    #endregion
 
    #region Класс команд - RelayCommand
    /// <summary>Класс реализующий <see cref="ICommand"/>.<br/>
    /// Реализация взята из <see href="https://www.cyberforum.ru/wpf-silverlight/thread2390714-page4.html#post13535649"/>
    /// и дополнена конструктором для методов без параметра.</summary>
    public class RelayCommand : ICommand
    {
        private readonly CanExecuteHandler canExecute;
        private readonly ExecuteHandler execute;
        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)
            :this()
        {
            this.execute = execute ?? throw new ArgumentNullException(nameof(execute));
            this.canExecute = canExecute;
 
            requerySuggested = (o, e) => Invalidate();
            CommandManager.RequerySuggested += requerySuggested;
        }
 
        /// <inheritdoc cref="RelayCommand(ExecuteHandler, CanExecuteHandler)"/>
        public RelayCommand(Action execute, Func<bool> canExecute = null)
                : this
                (
                      p => execute(),
                      p => canExecute?.Invoke() ?? true
                )
        { }
 
        private RelayCommand()
            => dispatcher = Application.Current.Dispatcher;
 
        private readonly Dispatcher dispatcher;
 
        /// <summary>Метод, подымающий событие <see cref="CanExecuteChanged"/>.</summary>
        public void RaiseCanExecuteChanged()
        {
            if (dispatcher.CheckAccess())
                Invalidate();
            else
                dispatcher.BeginInvoke((Action)Invalidate);
        }
        private void Invalidate()
            => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
 
        /// <summary>Вызов метода, возвращающего состояние команды.</summary>
        /// <param name="parameter">Параметр команды.</param>
        /// <returns><see langword="true"/> - если выполнение команды разрешено.</returns>
        public bool CanExecute(object parameter) => canExecute?.Invoke(parameter) ?? true;
 
        /// <summary>Вызов выполняющего метода команды.</summary>
        /// <param name="parameter">Параметр команды.</param>
        public void Execute(object parameter) => execute?.Invoke(parameter);
    }
    #endregion
}

using System;
using System.Diagnostics;
using System.Threading.Tasks;
 
namespace StandardModel
{
    public class AsyncModel
    {
        private int number;
 
        public AsyncModel()
        {
            Task.Run(RefreshAsync);
        }
 
        public event EventHandler<NumberChangedArgs> NumberChanged;
 
        private async void RefreshAsync()
        {
            while (true)
            {
                await Task.Delay(1_000);
 
                number++;
                NumberChangedArgs args = new NumberChangedArgs(number);
 
 
                if (args != null)
                {
                    try
                    {
                        NumberChanged?.Invoke(this, args);
                    }
                    catch (Exception exp)
                    {
                        Debug.WriteLine(exp.Message);
                    }
                }
            }
        }
    }
}

    public class ViewModel : ViewModelBase
    {
        public readonly AsyncModel model = new AsyncModel();
        private int _number;
 
        public int Number { get => _number; set => Set(ref _number, value); }
 
        public RelayCommand SomeCommand { get; }
        public ViewModel()
        {
            model.NumberChanged += OnValuesChanged;
            SomeCommand = new RelayCommand(() => { }, () => (Number & 1) == 0);
        }
 
        private void OnValuesChanged(object? sender, NumberChangedArgs e)
        {
            Number = e.NewNumber;
            SomeCommand.RaiseCanExecuteChanged();
        }
    }

        protected void RaisePropertyChanged([CallerMemberName] string? propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName ?? string.Empty));
        }

        public CoreDispatcher Dispatcher { get; } = CoreApplication.MainView.CoreWindow.Dispatcher;
 
        protected void RaisePropertyChanged([CallerMemberName] string propertyName = null)
        {
            if (Dispatcher.HasThreadAccess)
            {
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName ?? string.Empty));
            }
            else
            {
                Dispatcher
                    .RunAsync
                    (
                        CoreDispatcherPriority.Normal,
                        () => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName ?? string.Empty))
                    )
                    .AsTask().Wait();
            }
        }

        public void RaiseCanExecuteChanged()
        {
            if (dispatcher.CheckAccess())
                Invalidate();
            else
                dispatcher.BeginInvoke(Invalidate);
        }

        public void RaiseCanExecuteChanged()
        {
            CanExecuteChanged?.Invoke(this, EventArgs.Empty);
        }

public class BaseVM : INotifyPropertyChanged
{
#if UWP
    public CoreDispatcher Dispatcher { get; } = CoreApplication.MainView.CoreWindow.Dispatcher;
#endif
 
    protected void OnPropertyChanged(PropertyChangedEventArgs e)
    {
#if WPF
        PropertyChanged?.Invoke(this, e);
#elif UWP
        if (Dispatcher.HasThreadAccess)
        {
            PropertyChanged?.Invoke(this, e);
        }
        else
        {
            Dispatcher.RunAsync
            (
                CoreDispatcherPriority.Normal,
                () => PropertyChanged?.Invoke(this, e)
            ).AsTask().Wait();
        }
#else
        throw new NotSupportedException("Neither UWP, nor WPF - must be WTF");
#endif
    }
}

//Это реализует программист, это именно VM со всей её логикой.
public class SomeViewModel
{
    public virtual ICollection<string> Items { get; } = default!;
}
 
//Этот класс полностью кодогенерируется либо заранее, на этапе сборки, 
//либо прямо в рантайме при старте приложения (либо при старте с кэшированием на диск). 
//В т.ч. конструкторы. В т.ч. через это можно сделать свою реализацию INPC и подстановки 
//реализации команд конкретной платформы в свойства ICommand.
//
//На самом деле даже виртуалить не обязательно, можно просто в конструкторе 
//сгенерировать создание/присвоение коллекции нужного типа (виртуальность использовал для 
//переопределения поведения сеттеров при реализации INPC через этот подход).
//
//Далее, при старте приложения:
//  в зависимости от платформы генерируется/загружается нужная сборка с прокси-VM
//  прокси-VM регистрируются в DI:
//      sc.AddTransient(typeof(SomeViewModel), typeof(SomeViewModel_WpfProxy));
public class SomeViewModel_WpfProxy : SomeViewModel
{
    public override ICollection<string> Items { get; } = new BindingList<string>();
}

public sealed class SomeViewModel
{
    public List<string> Items { get; }
 
#if DEBUG
    public SomeViewModel()
    {
        Items = new() { "Item 1", "Item 2" };
    }
#else
    public SomeViewModel(ItemsService itemsService)
    {
        Items = itemsService.GetItems();
    }
#endif
}