Reactive Extensions Observerable.FromAsync: How to wait until async operation is finished

Question

In my application I´m getting events from a message bus (rabbit mq, but actually it does not really matter). The processing of this events is taking rather long and the events are produced in bursts. Only one event should be processed at a time. To fulfill this I´m using Rx in order to serialize the events and execute the processing asynchronously in order to not block the producer.

Here is the (simplified) sample code:

static void Main(string[] args)
{
   var input = Observable.Interval(TimeSpan.FromMilliseconds(500));
   var subscription = input.Select(i => Observable.FromAsync(ct => Process(ct, i)))
                           .Concat()
                           .Subscribe();

   Console.ReadLine();
   subscription.Dispose();
   // Wait until finished?
   Console.WriteLine("Completed");
}

private static async Task Process(CancellationToken cts, long i)
{
   Console.WriteLine($"Processing {i} ...");
   await Task.Delay(1000).ConfigureAwait(false);
   Console.WriteLine($"Finished processing {i}");
}

The sample application is disposing the subscription and then the application is terminated. But in this sample, the application is terminating while the last event received before the subscription is still being processed.

Question: What is the best way to wait until the last event is processed after the subscription is disposed? I´m still trying to wrap my head around the async Rx stuff. I assume there is a rather easy way to do this that I´m just not seeing right now.

RX have a build-in feature for [schedulers](http://reactivex.io/documentation/scheduler.html). Is it an option for you to use `ObserveOn()` instead of using async? See other questions like https://stackoverflow.com/questions/42655958/how-can-i-await-that-everything-is-done-in-a-rx-observable-sequence-after-unsubs — Progman, Jun 16 '20 at 09:19

score 2 · Accepted Answer · answered Jun 16 '20 at 11:13

2

If you are OK with a quick and easy solution, that is applicable for simple cases like this, then you could just Wait the IObservable instead of subscribing to it. And if you want to receive subscription-like notifications, use the Do operator just before the final Wait:

static void Main(string[] args)
{
    var input = Observable.Interval(TimeSpan.FromMilliseconds(500));
    input.Select(i => Observable.FromAsync(ct => Process(ct, i)))
        .Concat()
        .Do(onNext: x => { }, onError: ex => { }, onCompleted: () => { })
        .Wait();
    Console.WriteLine("Completed");
}

answered Jun 16 '20 at 11:13

Theodor Zoulias

34,835
7
69
104

1

Thanks for the suggestion. I would be ok with an quick and easy solution, but not with the "Wait". But this you can not know from my question :). But basically it is very similar. Thanks again. That helped a lot and I will accept your answer of course. – harri Jun 16 '20 at 11:25
1

Instead of blocking, you can also directly `await` your observables to 'wait' till completion. – Asti Jun 16 '20 at 11:37

score 1 · Answer 2 · answered Jun 16 '20 at 11:23

Thanks to the suggestion from Theodor I now found a solution that works for me:

static async Task Main(string[] args)
{
    var inputSequence = Observable.Interval(TimeSpan.FromMilliseconds(500));
    var terminate = new Subject<Unit>();
    var task = Execute(inputSequence, terminate);

    Console.ReadLine();
    terminate.OnNext(Unit.Default);
    await task.ConfigureAwait(false);
    Console.WriteLine($"Completed");
    Console.ReadLine();
}

private static async Task Process(CancellationToken cts, long i)
{
    Console.WriteLine($"Processing {i} ...");
    await Task.Delay(1000).ConfigureAwait(false);
    Console.WriteLine($"Finished processing {i}");
}

private static async Task Execute(IObservable<long> input, IObservable<Unit> terminate)
{
    await input
          .TakeUntil(terminate)
          .Select(i => Observable.FromAsync(ct => Process(ct, i)))
          .Concat();
}

Reactive Extensions Observerable.FromAsync: How to wait until async operation is finished

2 Answers2