GroupBy that closes and creates a new Group when the key changes. Useful on sorted collections.

GroupByDistinct.cs

        public static IObservable<IObservable<TElement>> GroupByDistinct<TElement, TKey>(this IObservable<TElement> source, Func<TElement, TKey> keySelector)
        {
            return Observable.Create<IObservable<TElement>>(o =>
                {
                    SerialDisposable dis = new SerialDisposable();
                    Subject<TElement> sub = new Subject<TElement>();
                    dis.Disposable = sub;
                    o.OnNext(sub.AsObservable());
                    bool first = true;
                    TKey prev = default(TKey);
                    return new CompositeDisposable(source.Subscribe(el =>
                    {
                        TKey cur = keySelector(el);
                        if (first)
                        {
                            first = false;
                            prev = cur;
                        }
                        else if (!cur.Equals(prev))
                        {
                            sub.OnCompleted();
                            sub = new Subject<TElement>();
                            dis.Disposable = sub;
                            o.OnNext(sub.AsObservable());
                            prev = cur;
                        }
                        sub.OnNext(el);
                    }, er =>
                    {
                        sub.OnCompleted();
                        o.OnError(er);
                    }
                    , () =>
                    {
                        sub.OnCompleted();
                        o.OnCompleted();
                    }
                    ), dis);
                });
        }

MultipleAssignmentDisposable dis = new MultipleAssignmentDisposable(); can be swapped for SerialDisposable dis = new SerialDisposable(); and then your inner subject will be disposed as you switch inner sequences.