Observable.Interval重新启动每个订阅

Question

我第一次定义测量时间表的尝试是：

    var schedule = Observable.Concat(
                Observable.Interval(TimeSpan.FromSeconds(1)).Take(3),
                Observable.Interval(TimeSpan.FromSeconds(3)).Take(3),
                Observable.Interval(TimeSpan.FromSeconds(5)));

不幸的是，当取消订阅和重新订阅时，它会重新启动，这对我而言不是理想的行为。 因此，我想到了这样的东西：

    class Schedule : IObservable<DateTime>, IDisposable
    {
        readonly ISubject<DateTime> _subject;
        readonly IDisposable _subscrption;

        public Schedule()
        {
            _subject = new BehaviorSubject<DateTime>(DateTime.UtcNow);
            _subscrption = Observable.Concat(
                Observable.Interval(TimeSpan.FromSeconds(1)).Take(3),
                Observable.Interval(TimeSpan.FromSeconds(3)).Take(3),
                Observable.Interval(TimeSpan.FromSeconds(5)))
                .Select(i => DateTime.UtcNow)
                .Subscribe(_subject);
        }

        public IDisposable Subscribe(IObserver<DateTime> observer)
        {
            return _subject.Subscribe(observer);
        }

        public void Dispose()
        {
            _subscrption.Dispose(); 
        }
    }

它可以工作，但需要在使用后进行处理。 有什么简单的方法可以定义Schedule而不暴露IDisposable？

Answer 1

如果您要取消所有观察者的订阅，然后重新订阅，则真的没有办法让Disposable保持跟踪连接。 因为您的Observable不会直接知道最新的取消订阅是否真的是最后一个。

我建议使用“ Generate而不是“连接可观察对象”

IConnectableObservable<DateTime> source = Observable.Generate(
  0,
  _ => true,
  x => x + 1,
  x => DateTime.UtcNow,
  x => {
    if (x < 3) return TimeSpan.FromSeconds(1);
    else if (x < 5) return TimeSpan.FromSeconds(3);
    else return TimeSpan.FromSeconds(5);
}).Publish();

Publish将您的Observable变为ConnectableObservable，并为您提供两个选项来管理源何时实际产生事件。

//1) Explicit connect
IDisposable connection = source.Connect();

//2) RefCounted connection
IObservable<DateTime> rcSource = source.RefCount();

在第一个版本中，一旦连接，源将变为“热”状态；当您要断开连接时，应丢弃连接。

在第二个中，当没有更多观察者时，源将自动断开连接。

另请参阅热与冷可观察物

Answer 2

这是我定义的不需要处理的解决方案。 不过，这非常复杂，因此，如果可以使用Rx工具简化某些操作，我将不胜感激。

用法：

  IObservable<DateTime> schedule = new Schedule()
            .Setup(TimeSpan.FromSeconds(1), 3)
            .Setup(TimeSpan.FromSeconds(3), 3)
            .Setup(TimeSpan.FromSeconds(5));

时间表在哪里：

    class Schedule : IObservable<DateTime>
    {
        readonly TimeSpan TimerPrecision = TimeSpan.FromMilliseconds(1);
        readonly IEnumerable<TimeSpan> Intervals;
        readonly IEnumerator<DateTime> Event;

        public Schedule()
            : this(new TimeSpan[0])
        {
        }

        Schedule(IEnumerable<TimeSpan> intervals)
        {
            Intervals = intervals;
            Event = Start();
            Event.MoveNext();
        }

        public Schedule Setup(TimeSpan interval)
        {
            return Setup(interval, Int32.MaxValue);
        }

        public Schedule Setup(TimeSpan interval, int repeat)
        {
            return new Schedule(
                Intervals.Concat(
                    Enumerable.Repeat(interval, repeat)));
        }

        public IDisposable Subscribe(IObserver<DateTime> observer)
        {
            var timer = new System.Timers.Timer() { AutoReset = true };
            timer.Elapsed += (s, a) => 
            {                                                
                observer.OnNext(DateTime.UtcNow);
                if (!TryArm(timer))
                    observer.OnCompleted();
            };

            if (!TryArm(timer))
                observer.OnCompleted();

            return timer;
        }

        IEnumerator<DateTime> Start()
        {
            var time = DateTime.UtcNow;
            yield return time;

            foreach (var interval in Intervals)
            {
                time += interval;
                yield return time;
            }
        }

        TimeSpan Delay()
        {
            var now = DateTime.UtcNow;
            lock (Event)
                while (Event.Current - DateTime.UtcNow < TimerPrecision)
                    Event.MoveNext();

            return Event.Current - now;
        }

        bool TryArm(System.Timers.Timer timer)
        {
            try
            {
                timer.Interval = Delay().TotalMilliseconds;
                timer.Start();
                return true;
            }            
            catch(ObjectDisposedException)   
            {
                return false;
            }
            catch(InvalidOperationException)   
            {
                return false;
            }
        }
    }