Как реализовать таймер обратного отсчета с помощью ReactiveUI?

Как насчет этого:

public class MainViewModel : ReactiveObject, IMainViewModel
{
    static TimeSpan InitialTime = TimeSpan.FromSeconds(5);

    ObservableAsPropertyHelper<TimeSpan> _RemainingTime;
    public TimeSpan RemainingTime {
        get { return _remainingTime.Value; }
    }

    ReactiveCommand<TimeSpan> _startCommand;
    public ReactiveCommand<TimeSpan> StartCommand => this._startCommand;

    ObservableAsPropertyHelper<bool> _IsRunning;
    public bool IsRunning {
        get { return this._IsRunning.Value; }
    }

    public MainViewModel()
    {
        var canStart = this.WhenAny(x => x.IsRunning, propChanged => !propChanged.Value);
        _startCommand = ReactiveCommand.CreateAsyncObservable(_ => {
          var startTime = DateTime.Now;

          return Observable.Interval(TimeSpan.FromMilliseconds(20), RxApp.MainThreadScheduler)
            .Select(__ => DateTime.Now - startTime)
            .TakeWhile((elapsed) => elapsed < InitialTime)
            .Select((elapsed) => InitialTime - elapsed);
        });

        _startCommand.IsExecuting
            .ToProperty(this, x => x.IsRunning, out _IsRunning);
        _startCommand.StartWith(TimeSpan.Zero)
            .ToProperty(this, x => x.RemainingTime, out _RemainingTime);
    }
}

Я искал, как использовать таймер в реактивном, и я приземлился здесь. Я не мог сделать этот пробег. У меня версия 9.14.1, и вот как я изменил MainViewModel, чтобы она работала.

using System;
using System.Reactive;
using System.Reactive.Linq;
using ReactiveUI;

namespace TimerExample
{
    public class MainViewModel : ReactiveObject
    {
        public ReactiveCommand<Unit, TimeSpan> StartCommand { get; }

        private TimeSpan _remainingTime;
        public TimeSpan RemainingTime
        {
            get => _remainingTime;
            set => this.RaiseAndSetIfChanged(ref _remainingTime, value);
        }

        public MainViewModel()
        {
            var startTime = TimeSpan.FromSeconds(15);

            StartCommand = ReactiveCommand.CreateFromObservable<Unit, TimeSpan>(_ =>
            {
                return Observable.Interval(TimeSpan.FromSeconds(1))
                    .Select(x => startTime - TimeSpan.FromSeconds(x))
                    .TakeWhile(x => x >= TimeSpan.FromSeconds(0));
            });

            StartCommand
                .ObserveOn(RxApp.MainThreadScheduler)
                .Subscribe(span => RemainingTime = span);
        }
    }
}

Я смог заставить это работать, внеся следующие изменения:

1. Добавлен флаг vm.IsRunning, который устанавливается в значение true при запуске() и возвращается в значение false после завершения timerStream.

2. Использовал ReactiveObject.WhenAny(...) для свойства IsRunning и использовал его в качестве наблюдаемого объекта ReactiveCommand canExecute.

3. Я также обновил свою реализацию наблюдаемого объекта timerStream. Чтобы сделать таймер более точным, я обновил его так, чтобы он в начале регистрировал DateTime.Now, а затем всякий раз, когда Observable.Interval создает значение, я получаю DateTime.Now снова и вычтите из него исходное, чтобы получить прошедшее время.

Вот моя обновленная реализация ViewModel

public class MainViewModel : ReactiveObject, IMainViewModel
{
    const double InitialTimeInSeconds = 5;
    private TimeSpan _remainingTime;
    private ReactiveCommand<object> _startCommand;
    private bool _isRunning = false;

    public TimeSpan RemainingTime
    {
        get { return _remainingTime; }
        private set { this.RaiseAndSetIfChanged(ref _remainingTime, value); }
    }

    public ICommand StartCommand => this._startCommand;

    public bool IsRunning
    {
        get { return this._isRunning; }
        set { this.RaiseAndSetIfChanged(ref _isRunning, value); }
    }

    public MainViewModel()
    {
        var canStart = this.WhenAny(x => x.IsRunning, propChanged => !propChanged.Value);
        _startCommand = ReactiveCommand.Create(canStart);
        _startCommand.Subscribe(_ => Start());
    }

    private void Start()
    {
        IsRunning = true;
        var remaining = TimeSpan.FromSeconds(InitialTimeInSeconds);
        var startTime = DateTime.Now;
        var timerStream = Observable
            .Interval(TimeSpan.FromMilliseconds(1))
            .Select(_ => remaining.Subtract(DateTime.Now.Subtract(startTime)))
            .TakeWhile(x => x > TimeSpan.Zero)
            .ObserveOnDispatcher()
            .Subscribe(
                onNext: x => RemainingTime = x, 
                onCompleted: () =>
                {
                    this.RemainingTime = TimeSpan.Zero;
                    this.IsRunning = false;
                });
    }
}

ПРИМЕЧАНИЕ. Первоначально я не использовал ObserveOnDispatcher() для timerStream и столкнулся с проблемой, когда кнопка оставалась отключенной даже после завершения наблюдаемого. Мне потребовалось некоторое время, чтобы понять, что не так, поскольку я не видел никаких исключений. Я понял проблему только тогда, когда сам вручную реализовал команду (вместо использования ReactiveCommand). Это вызвало исключение UI-thread-access-exception, и это заставило меня понять, что мне нужно выполнить ObserveOnDispatcher.