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代替Concatenating Observables

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();

在第一个版本中，来源将变得“热”＆＃34;一旦你连接，当你想断开连接时，你应该处理连接。

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

另见hot vs cold observables

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;
            }
        }
    }

Observable.Interval为每个订阅重新启动

2 个答案: