С Reactive Extensions (RX) възможно ли е да добавите команда за пауза?

Ето моето решение с помощта на оператори за буфер и прозорец:

public static IObservable<T> Pausable<T>(this IObservable<T> source, IObservable<bool> pauser)
{
    var queue = source.Buffer(pauser.Where(toPause => !toPause),
                              _ => pauser.Where(toPause => toPause))
                      .SelectMany(l => l.ToObservable());

    return source.Window(pauser.Where(toPause => toPause).StartWith(true), 
                         _ => pauser.Where(toPause => !toPause))
                 .Switch()
                 .Merge(queue);
}

Прозорецът се отваря при абониране и всеки път, когато се получи „true“ от потока на пауза. Затваря се, когато паузърът предостави стойност „false“.

Буферът прави това, което е трябвало да прави, буферира стойности, които са между „false“ и „true“ от пауза. След като Buffer получи 'true', той извежда IList от стойности, които незабавно се предават всички наведнъж.

Връзка към DotNetFiddle: https://dotnetfiddle.net/vGU5dJ

Ето един сравнително прост Rx начин да направите това, което искате. Създадох метод за разширение, наречен Pausable, който взема наблюдаем източник и втори наблюдаем от boolean, който поставя на пауза или възобновява наблюдаемия.

public static IObservable<T> Pausable<T>(
    this IObservable<T> source,
    IObservable<bool> pauser)
{
    return Observable.Create<T>(o =>
    {
        var paused = new SerialDisposable();
        var subscription = Observable.Publish(source, ps =>
        {
            var values = new ReplaySubject<T>();
            Func<bool, IObservable<T>> switcher = b =>
            {
                if (b)
                {
                    values.Dispose();
                    values = new ReplaySubject<T>();
                    paused.Disposable = ps.Subscribe(values);
                    return Observable.Empty<T>();
                }
                else
                {
                    return values.Concat(ps);
                }
            };

            return pauser.StartWith(false).DistinctUntilChanged()
                .Select(p => switcher(p))
                .Switch();
        }).Subscribe(o);
        return new CompositeDisposable(subscription, paused);
    });
}

Може да се използва така:

var xs = Observable.Generate(
    0,
    x => x < 100,
    x => x + 1,
    x => x,
    x => TimeSpan.FromSeconds(0.1));

var bs = new Subject<bool>();

var pxs = xs.Pausable(bs);

pxs.Subscribe(x => { /* Do stuff */ });

Thread.Sleep(500);
bs.OnNext(true);
Thread.Sleep(5000);
bs.OnNext(false);
Thread.Sleep(500);
bs.OnNext(true);
Thread.Sleep(5000);
bs.OnNext(false);

Сега, единственото нещо, което не можах да разбера какво имате предвид с вашия „входящ поток от събития е IObserver<T>“. Потоците са IObservable<T>. Наблюдателите не са потоци. Изглежда, че не правите нещо както трябва. Можете ли да добавите към въпроса си и да обясните допълнително, моля?

Можете да симулирате пауза/възстановяване на пауза с Observable.

След като вашият pauseObservable излъчи стойност „на пауза“, буферирайте събитията, докато pauseObservable излъчи стойност „на пауза“.

Ето един пример, който използва Реализация на BufferUntil от Дейв Секстън и Наблюдаема логика от Тимъти Шийлдс (от моя собствен въпрос преди известно време)

        //Input events, hot observable
        var source = Observable.Interval(TimeSpan.FromSeconds(1))
            .Select(i => i.ToString())
            .Publish().RefCount();

       //Simulate pausing from Keyboard, not actually relevant within this answer
        var pauseObservable = Observable.FromEventPattern<KeyPressEventHandler, KeyPressEventArgs>(
            k => KeyPressed += k, k => KeyPressed -= k)
            .Select(i => i.EventArgs.PressedKey)
            .Select(i => i == ConsoleKey.Spacebar) //space is pause, others are unpause
            .DistinctUntilChanged();

        //Let events through when not paused
        var notPausedEvents = source.Zip(pauseObservable.MostRecent(false), (value, paused) => new {value, paused})
            .Where(i => !i.paused) //not paused
            .Select(i => i.value)
            .Subscribe(Console.WriteLine);

        //When paused, buffer until not paused
        var pausedEvents = pauseObservable.Where(i => i)
            .Subscribe(_ =>
                source.BufferUntil(pauseObservable.Where(i => !i))
                    .Select(i => String.Join(Environment.NewLine, i))
                    .Subscribe(Console.WriteLine));

Място за подобрение: може би обединете двата абонамента за източник (pausedEvents и notPausedEvents) в едно.