Можно ли с помощью Reactive Extensions (RX) добавить команду Pause?

Вот мое решение с использованием операторов Buffer и Window:

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

Окно открывается при подписке и каждый раз, когда из потока паузы принимается «истина». Он закрывается, когда пауза предоставляет значение «false».

Буфер делает то, что он должен делать, буферизует значения между «ложью» и «истиной» из паузы. Как только 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 выдает значение «paused», буферизируйте события до тех пор, пока pauseObservable не выдаст значение «unpaused».

Вот пример, в котором используется Реализация 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) как одну.