Ensures that specific observables complete in serial (by a particular key)

MultiplexedOperationDispatcher.cs

    public static class MultiplexedOperationDispatcher
    {
        static readonly Subject<Tuple<string, IObservable<Unit>>> Operations = new Subject<Tuple<string, IObservable<Unit>>>();

        static MultiplexedOperationDispatcher()
        {
            Operations.GroupBy(x => x.Item1).Subscribe(g => g.Select(x => x.Item2).Concat().Subscribe());
        }

        public static IObservable<T> DispatchedByLockKey<T>(this IObservable<T> source, string lockKey)
        {
            return Observable.Create<T>(sourceObserver =>
                {
                    var disposable = new SingleAssignmentDisposable();
                    Operations.OnNext(new Tuple<string, IObservable<Unit>>(lockKey, Observable.Create<Unit>(unitObserver =>
                        {
                            disposable.Disposable = source.Finally(unitObserver.OnCompleted).Subscribe(sourceObserver);
                            return disposable;
                        })));
                    return disposable;
                });
        }
    }