在可观察序列中删除除最后一个样本之外的任何样本，直到消费者准备好

Question

There is a real-time sequence of instrumental observations IObservable<S> . There is also an async consumer function f : S -> Task<U> (with side effects) that may take time to process a value. The function must not be reentered. As soon as it has returned, however, the next available sample from the stream should be passed to it. Additionally, the function must see the very last sample at the end of the stream.

It feels like this must be a pretty common pattern, but I cannot find an idiomatic solution. My approach works, but rather reeks of inelegance of using a subject as an imperative signal variable in the feedback loop. Is there an idiomatic solution to my problem?

static void Main() {
  var source = Observable.Interval(TimeSpan.FromMilliseconds(100)).Take(27);

  var s = source.Publish(ps => {
    var signal = new Subject<Unit>();
    return ps
      .SkipLast(1)
      .Window(signal)
      .SelectMany(w => w.Take(1))
      .Merge(ps.PublishLast().RefCount())
      .Select(x => Observable.FromAsync(() => LengthyWork(x)))
      .Concat()
      .Do(signal.OnNext);
  });
  var d = s.Subscribe();
  Thread.Sleep(5000);
  Console.WriteLine("Stopping");
  d.Dispose();
}

static async Task<Unit> LengthyWork(long n) {
  Console.WriteLine($"Processing {n}");
  await Task.Delay(800);
  return Unit.Default;
}

EDIT: The code actually does not solve the problem in question: .Merge() composition with the published last element pushes that element out of sync. In this example terms, 26 is send before the function returns from processing 24 .

Output (note that item 26 is the last before end of stream).

Processing 0
Processing 8
Processing 16
Processing 24
Processing 26
Stopping

Answer 1

I couldn't find a simple solution since you also want the last value published even if it wasn't in the time frame.

// signal to indicate we want more events to flow
var signal = new BehaviorSubject<bool>(true);
var source = Observable.Interval(TimeSpan.FromMilliseconds(100)).Take(27).Publish();
// Observable to the source but have it skip the last value (would have published the same value twice if not doing this. Ex: if take was 33 instead of 27)
var sequence = source.SkipLast(1).Publish();
// Observable that is just the lastvalue in the sequence
var last = source.PublishLast();

var d = signal.DistinctUntilChanged()
    .Where(on => on) // only let go if we have signal set to true
    .SelectMany(last.Do(_ => signal.OnCompleted()).Merge(sequence).Take(1))  // Side effect of last is to turn off signal
    .Subscribe(
        async ps =>
        {
            signal.OnNext(false); // no more values from the source
            await LengthyWork(ps);
            signal.OnNext(true); // resubscribe to the source
        });

// wire it all  up
last.Connect();
sequence.Connect();
source.Connect();
Thread.Sleep(5000);
Console.WriteLine("Stopping");
d.Dispose();

Part of the idea came from How to turn Off/Restart an Interval? from the MSDN forums.

Answer 2

您可以使用 MostRecent 运算符 - 我认为您需要的是他对这个问题的回答的简单版本： Reactive Extensions (Rx) - 当间隔中没有值时，具有最后一个已知值的样本