Rework subscription in Producer such that all Sinks set the upstream disposable by themselves.

This will save up to two allocations per subscription. (#575)

Rx.NET/Source/src/System.Reactive/Concurrency/Synchronization.ObserveOn.cs

@@ -20,10 +20,10 @@ namespace System.Reactive.Concurrency
                 _scheduler = scheduler;
             }
 
-            protected override ObserveOnObserver<TSource> CreateSink(IObserver<TSource> observer, IDisposable cancel) => new ObserveOnObserver<TSource>(_scheduler, observer, cancel);
+            protected override ObserveOnObserver<TSource> CreateSink(IObserver<TSource> observer) => new ObserveOnObserver<TSource>(_scheduler, observer);
 
             [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Justification = "Visibility restricted to friend assemblies. Those should be correct by inspection.")]
-            protected override IDisposable Run(ObserveOnObserver<TSource> sink) => _source.SubscribeSafe(sink);
+            protected override void Run(ObserveOnObserver<TSource> sink) => sink.Run(_source);
         }
 
         /// <summary>
@@ -40,10 +40,10 @@ namespace System.Reactive.Concurrency
                 _scheduler = scheduler;
             }
 
-            protected override ObserveOnObserverNew<TSource> CreateSink(IObserver<TSource> observer, IDisposable cancel) => new ObserveOnObserverNew<TSource>(_scheduler, observer, cancel);
+            protected override ObserveOnObserverNew<TSource> CreateSink(IObserver<TSource> observer) => new ObserveOnObserverNew<TSource>(_scheduler, observer);
 
             [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Justification = "Visibility restricted to friend assemblies. Those should be correct by inspection.")]
-            protected override IDisposable Run(ObserveOnObserverNew<TSource> sink) => _source.SubscribeSafe(sink);
+            protected override void Run(ObserveOnObserverNew<TSource> sink) => sink.Run(_source);
         }
 
         internal sealed class Context : Producer<TSource, Context._>
@@ -57,22 +57,22 @@ namespace System.Reactive.Concurrency
                 _context = context;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_context, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_context, observer);
 
             [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Justification = "Visibility restricted to friend assemblies. Those should be correct by inspection.")]
-            protected override IDisposable Run(_ sink) => sink.Run(_source);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private readonly SynchronizationContext _context;
 
-                public _(SynchronizationContext context, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(SynchronizationContext context, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _context = context;
                 }
 
-                public IDisposable Run(IObservable<TSource> source)
+                public void Run(IObservable<TSource> source)
                 {
                     //
                     // The interactions with OperationStarted/OperationCompleted below allow
@@ -86,7 +86,7 @@ namespace System.Reactive.Concurrency
                     var d = source.SubscribeSafe(this);
                     var c = Disposable.Create(_context.OperationCompleted);
 
-                    return StableCompositeDisposable.Create(d, c);
+                    SetUpstream(StableCompositeDisposable.Create(d, c));
                 }
 
                 public override void OnNext(TSource value)

Rx.NET/Source/src/System.Reactive/Concurrency/Synchronization.Synchronize.cs

@@ -20,18 +20,18 @@ namespace System.Reactive.Concurrency
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(this, observer);
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Justification = "Visibility restricted to friend assemblies. Those should be correct by inspection.")]
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<TSource>
         {
             private readonly Synchronize<TSource> _parent;
             private readonly object _gate;
 
-            public _(Synchronize<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Synchronize<TSource> parent, IObserver<TSource> observer)
+                : base(observer)
             {
                 _parent = parent;
                 _gate = _parent._gate ?? new object();

Rx.NET/Source/src/System.Reactive/Internal/ConcatSink.cs

@@ -8,8 +8,8 @@ namespace System.Reactive
 {
     internal abstract class ConcatSink<TSource> : TailRecursiveSink<TSource>
     {
-        public ConcatSink(IObserver<TSource> observer, IDisposable cancel)
-            : base(observer, cancel)
+        public ConcatSink(IObserver<TSource> observer)
+            : base(observer)
         {
         }
 

Rx.NET/Source/src/System.Reactive/Internal/IdentitySink.cs

@@ -6,7 +6,7 @@ namespace System.Reactive
 {
     internal abstract class IdentitySink<T> : Sink<T, T>
     {
-        protected IdentitySink(IObserver<T> observer, IDisposable cancel) : base(observer, cancel)
+        protected IdentitySink(IObserver<T> observer) : base(observer)
         {
         }
 

Rx.NET/Source/src/System.Reactive/Internal/Producer.cs

@@ -90,7 +90,7 @@ namespace System.Reactive
 
         public IDisposable SubscribeRaw(IObserver<TTarget> observer, bool enableSafeguard)
         {
-            var subscription = new SubscriptionDisposable();
+            SingleAssignmentDisposable subscription = null;
 
             //
             // See AutoDetachObserver.cs for more information on the safeguarding requirement and
@@ -98,47 +98,35 @@ namespace System.Reactive
             //
             if (enableSafeguard)
             {
+                subscription = new SingleAssignmentDisposable();
                 observer = SafeObserver<TTarget>.Create(observer, subscription);
             }
 
-            var sink = CreateSink(observer, subscription.Inner);
+            var sink = CreateSink(observer);
 
-            subscription.Sink = sink;
+            if (subscription != null)
+                subscription.Disposable = sink;
 
             if (CurrentThreadScheduler.IsScheduleRequired)
             {
                 CurrentThreadScheduler.Instance.ScheduleAction(
-                    (@this: this, sink, inner: subscription.Inner),
-                    tuple => tuple.inner.Disposable = tuple.@this.Run(tuple.sink));
+                    (@this: this, sink),
+                    tuple => [email protected](tuple.sink));
             }
             else
             {
-                subscription.Inner.Disposable = Run(sink);
+                Run(sink);
             }
 
-            return subscription;
+            return (IDisposable)subscription ?? sink;
         }
 
         /// <summary>
         /// Core implementation of the query operator, called upon a new subscription to the producer object.
         /// </summary>
         /// <param name="sink">The sink object.</param>
-        protected abstract IDisposable Run(TSink sink);
-
-        protected abstract TSink CreateSink(IObserver<TTarget> observer, IDisposable cancel);
-    }
-
-    internal sealed class SubscriptionDisposable : ICancelable
-    {
-        public volatile IDisposable Sink;
-        public readonly SingleAssignmentDisposable Inner = new SingleAssignmentDisposable();
-
-        public bool IsDisposed => Sink == null;
+        protected abstract void Run(TSink sink);
 
-        public void Dispose()
-        {
-            Interlocked.Exchange(ref Sink, null)?.Dispose();
-            Inner.Dispose();
-        }
+        protected abstract TSink CreateSink(IObserver<TTarget> observer);
     }
 }

Rx.NET/Source/src/System.Reactive/Internal/ScheduledObserver.cs

@@ -296,12 +296,17 @@ namespace System.Reactive
 
     internal sealed class ObserveOnObserver<T> : ScheduledObserver<T>
     {
-        private IDisposable _cancel;
+        private IDisposable _run;
 
-        public ObserveOnObserver(IScheduler scheduler, IObserver<T> observer, IDisposable cancel)
+        public ObserveOnObserver(IScheduler scheduler, IObserver<T> observer)
             : base(scheduler, observer)
         {
-            _cancel = cancel;
+
+        }
+
+        public void Run(IObservable<T> source)
+        {
+            Disposable.SetSingle(ref _run, source.SubscribeSafe(this));
         }
 
         protected override void OnNextCore(T value)
@@ -328,7 +333,7 @@ namespace System.Reactive
 
             if (disposing)
             {
-                Disposable.TryDispose(ref _cancel);
+                Disposable.TryDispose(ref _run);
             }
         }
     }
@@ -363,6 +368,8 @@ namespace System.Reactive
         /// </summary>
         IDisposable upstream;
 
+        private IDisposable _run;
+
         /// <summary>
         /// The current task representing a running drain operation.
         /// </summary>
@@ -389,20 +396,24 @@ namespace System.Reactive
         /// </summary>
         bool disposed;
 
-        public ObserveOnObserverNew(IScheduler scheduler, IObserver<T> downstream, IDisposable upstream)
+        public ObserveOnObserverNew(IScheduler scheduler, IObserver<T> downstream)
         {
             this.downstream = downstream;
             this.scheduler = scheduler;
             this.longRunning = scheduler.AsLongRunning();
             this.queue = new ConcurrentQueue<T>();
-            Volatile.Write(ref this.upstream, upstream);
+        }
+
+        public void Run(IObservable<T> source)
+        {
+            Disposable.SetSingle(ref _run, source.SubscribeSafe(this));
         }
 
         public void Dispose()
         {
             Volatile.Write(ref disposed, true);
-            Disposable.TryDispose(ref upstream);
             Disposable.TryDispose(ref task);
+            Disposable.TryDispose(ref _run);
             Clear();
         }
 

Rx.NET/Source/src/System.Reactive/Internal/Sink.cs

@@ -16,13 +16,12 @@ namespace System.Reactive
 
     internal abstract class Sink<TTarget> : ISink<TTarget>, IDisposable
     {
-        private IDisposable _cancel;
+        private IDisposable _upstream;
         private volatile IObserver<TTarget> _observer;
 
-        protected Sink(IObserver<TTarget> observer, IDisposable cancel)
+        protected Sink(IObserver<TTarget> observer)
         {
             _observer = observer;
-            _cancel = cancel;
         }
 
         public void Dispose()
@@ -33,7 +32,7 @@ namespace System.Reactive
         protected virtual void Dispose(bool disposing)
         {
             _observer = NopObserver<TTarget>.Instance;
-            Disposable.TryDispose(ref _cancel);
+            Disposable.TryDispose(ref _upstream);
         }
 
         public void ForwardOnNext(TTarget value)
@@ -52,6 +51,11 @@ namespace System.Reactive
             _observer.OnError(error);
             Dispose();
         }
+
+        protected void SetUpstream(IDisposable upstream)
+        {
+            Disposable.SetSingle(ref _upstream, upstream);
+        }
     }
 
     /// <summary>
@@ -62,8 +66,13 @@ namespace System.Reactive
     /// <remarks>Implementations of sinks are responsible to enforce the message grammar on the associated observer. Upon sending a terminal message, a pairing Dispose call should be made to trigger cancellation of related resources and to mute the outgoing observer.</remarks>
     internal abstract class Sink<TSource, TTarget> : Sink<TTarget>, IObserver<TSource>
     {
-        protected Sink(IObserver<TTarget> observer, IDisposable cancel) : base(observer, cancel)
+        protected Sink(IObserver<TTarget> observer) : base(observer)
+        {
+        }
+
+        public virtual void Run(IObservable<TSource> source)
         {
+            SetUpstream(source.SubscribeSafe(this));
         }
 
         public abstract void OnNext(TSource value);

Rx.NET/Source/src/System.Reactive/Internal/TailRecursiveSink.cs

@@ -11,8 +11,8 @@ namespace System.Reactive
 {
     internal abstract class TailRecursiveSink<TSource> : IdentitySink<TSource>
     {
-        public TailRecursiveSink(IObserver<TSource> observer, IDisposable cancel)
-            : base(observer, cancel)
+        public TailRecursiveSink(IObserver<TSource> observer)
+            : base(observer)
         {
         }
 
@@ -24,17 +24,17 @@ namespace System.Reactive
 
         Stack<IEnumerator<IObservable<TSource>>> stack;
 
-        public IDisposable Run(IEnumerable<IObservable<TSource>> sources)
+        public void Run(IEnumerable<IObservable<TSource>> sources)
         {
             if (!TryGetEnumerator(sources, out var current))
-                return Disposable.Empty;
+                return;
 
             stack = new Stack<IEnumerator<IObservable<TSource>>>();
             stack.Push(current);
 
             Drain();
 
-            return new RecursiveSinkDisposable(this);
+            SetUpstream(new RecursiveSinkDisposable(this));
         }
 
         sealed class RecursiveSinkDisposable : IDisposable

Rx.NET/Source/src/System.Reactive/Linq/Observable/AddRef.cs

@@ -17,15 +17,28 @@ namespace System.Reactive.Linq.ObservableImpl
             _refCount = refCount;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, StableCompositeDisposable.Create(_refCount.GetDisposable(), cancel));
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer, _refCount.GetDisposable());
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<TSource>
         {
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            private readonly IDisposable _refCountDisposable;
+
+            public _(IObserver<TSource> observer, IDisposable refCountDisposable)
+                : base(observer)
             {
+                _refCountDisposable = refCountDisposable;
+            }
+
+            protected override void Dispose(bool disposing)
+            {
+                if (disposing)
+                {
+                    _refCountDisposable.Dispose();
+                }
+
+                base.Dispose(disposing);
             }
         }
     }

Rx.NET/Source/src/System.Reactive/Linq/Observable/Aggregate.cs

@@ -15,9 +15,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _accumulator = accumulator;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_accumulator, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(_accumulator, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<TSource>
         {
@@ -25,8 +25,8 @@ namespace System.Reactive.Linq.ObservableImpl
             private TSource _accumulation;
             private bool _hasAccumulation;
 
-            public _(Func<TSource, TSource, TSource> accumulator, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Func<TSource, TSource, TSource> accumulator, IObserver<TSource> observer)
+                : base(observer)
             {
                 _accumulator = accumulator;
                 _accumulation = default(TSource);
@@ -81,17 +81,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _accumulator = accumulator;
         }
 
-        protected override _ CreateSink(IObserver<TAccumulate> observer, IDisposable cancel) => new _(_seed, _accumulator, observer, cancel);
+        protected override _ CreateSink(IObserver<TAccumulate> observer) => new _(_seed, _accumulator, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, TAccumulate> 
         {
             private readonly Func<TAccumulate, TSource, TAccumulate> _accumulator;
             private TAccumulate _accumulation;
 
-            public _(TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator, IObserver<TAccumulate> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator, IObserver<TAccumulate> observer)
+                : base(observer)
             {
                 _accumulator = accumulator;
                 _accumulation = seed;
@@ -137,9 +137,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, TResult> 
         {
@@ -148,8 +148,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
             private TAccumulate _accumulation;
 
-            public _(Aggregate<TSource, TAccumulate, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Aggregate<TSource, TAccumulate, TResult> parent, IObserver<TResult> observer)
+                : base(observer)
             {
                 _accumulator = parent._accumulator;
                 _resultSelector = parent._resultSelector;

Rx.NET/Source/src/System.Reactive/Linq/Observable/All.cs

@@ -15,16 +15,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _predicate = predicate;
         }
 
-        protected override _ CreateSink(IObserver<bool> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+        protected override _ CreateSink(IObserver<bool> observer) => new _(_predicate, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, bool> 
         {
             private readonly Func<TSource, bool> _predicate;
 
-            public _(Func<TSource, bool> predicate, IObserver<bool> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Func<TSource, bool> predicate, IObserver<bool> observer)
+                : base(observer)
             {
                 _predicate = predicate;
             }

Rx.NET/Source/src/System.Reactive/Linq/Observable/Amb.cs

@@ -18,9 +18,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _right = right;
         }
 
-        protected override AmbCoordinator CreateSink(IObserver<TSource> observer, IDisposable cancel) => new AmbCoordinator(observer);
+        protected override AmbCoordinator CreateSink(IObserver<TSource> observer) => new AmbCoordinator(observer);
 
-        protected override IDisposable Run(AmbCoordinator sink) => sink.Run(_left, _right);
+        protected override void Run(AmbCoordinator sink) => sink.Run(_left, _right);
 
         internal sealed class AmbCoordinator : IDisposable
         {
@@ -36,11 +36,10 @@ namespace System.Reactive.Linq.ObservableImpl
                 rightObserver = new AmbObserver(observer, this, false);
             }
 
-            public IDisposable Run(IObservable<TSource> left, IObservable<TSource> right)
+            public void Run(IObservable<TSource> left, IObservable<TSource> right)
             {
                 leftObserver.OnSubscribe(left.Subscribe(leftObserver));
                 rightObserver.OnSubscribe(right.Subscribe(rightObserver));
-                return this;
             }
 
             public void Dispose()

Rx.NET/Source/src/System.Reactive/Linq/Observable/Any.cs

@@ -15,14 +15,14 @@ namespace System.Reactive.Linq.ObservableImpl
                 _source = source;
             }
 
-            protected override _ CreateSink(IObserver<bool> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<bool> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, bool> 
             {
-                public _(IObserver<bool> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<bool> observer)
+                    : base(observer)
                 {
                 }
 
@@ -51,16 +51,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 _predicate = predicate;
             }
 
-            protected override _ CreateSink(IObserver<bool> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+            protected override _ CreateSink(IObserver<bool> observer) => new _(_predicate, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, bool> 
             {
                 private readonly Func<TSource, bool> _predicate;
 
-                public _(Func<TSource, bool> predicate, IObserver<bool> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, bool> predicate, IObserver<bool> observer)
+                    : base(observer)
                 {
                     _predicate = predicate;
                 }

Rx.NET/Source/src/System.Reactive/Linq/Observable/AsObservable.cs

@@ -15,14 +15,14 @@ namespace System.Reactive.Linq.ObservableImpl
 
         public IObservable<TSource> Eval() => _source;
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<TSource>
         {
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
         }

Rx.NET/Source/src/System.Reactive/Linq/Observable/Average.cs

@@ -13,17 +13,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<double> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<double> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<double>
         {
             private double _sum;
             private long _count;
 
-            public _(IObserver<double> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<double> observer)
+                : base(observer)
             {
                 _sum = 0.0;
                 _count = 0L;
@@ -69,17 +69,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<float> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<float> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<float>
         {
             private double _sum; // NOTE: Uses a different accumulator type (double), conform LINQ to Objects.
             private long _count;
 
-            public _(IObserver<float> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<float> observer)
+                : base(observer)
             {
                 _sum = 0.0;
                 _count = 0L;
@@ -125,17 +125,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<decimal> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<decimal> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<decimal>
         {
             private decimal _sum;
             private long _count;
 
-            public _(IObserver<decimal> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<decimal> observer)
+                : base(observer)
             {
                 _sum = 0M;
                 _count = 0L;
@@ -181,17 +181,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<double> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<double> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<int, double> 
         {
             private long _sum;
             private long _count;
 
-            public _(IObserver<double> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<double> observer)
+                : base(observer)
             {
                 _sum = 0L;
                 _count = 0L;
@@ -237,17 +237,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<double> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<double> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<long, double> 
         {
             private long _sum;
             private long _count;
 
-            public _(IObserver<double> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<double> observer)
+                : base(observer)
             {
                 _sum = 0L;
                 _count = 0L;
@@ -293,17 +293,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<double?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<double?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<double?>
         {
             private double _sum;
             private long _count;
 
-            public _(IObserver<double?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<double?> observer)
+                : base(observer)
             {
                 _sum = 0.0;
                 _count = 0L;
@@ -353,17 +353,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<float?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<float?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<float?>
         {
             private double _sum; // NOTE: Uses a different accumulator type (double), conform LINQ to Objects.
             private long _count;
 
-            public _(IObserver<float?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<float?> observer)
+                : base(observer)
             {
                 _sum = 0.0;
                 _count = 0L;
@@ -413,17 +413,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<decimal?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<decimal?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<decimal?>
         {
             private decimal _sum;
             private long _count;
 
-            public _(IObserver<decimal?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<decimal?> observer)
+                : base(observer)
             {
                 _sum = 0M;
                 _count = 0L;
@@ -473,17 +473,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<double?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<double?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<int?, double?> 
         {
             private long _sum;
             private long _count;
 
-            public _(IObserver<double?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<double?> observer)
+                : base(observer)
             {
                 _sum = 0L;
                 _count = 0L;
@@ -533,17 +533,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<double?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<double?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<long?, double?> 
         {
             private long _sum;
             private long _count;
 
-            public _(IObserver<double?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<double?> observer)
+                : base(observer)
             {
                 _sum = 0L;
                 _count = 0L;

Rx.NET/Source/src/System.Reactive/Linq/Observable/Buffer.cs

@@ -23,9 +23,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _skip = skip;
             }
 
-            protected override _ CreateSink(IObserver<IList<TSource>> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<IList<TSource>> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(_source);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, IList<TSource>> 
             {
@@ -34,8 +34,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private readonly int _count;
                 private readonly int _skip;
 
-                public _(Count parent, IObserver<IList<TSource>> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Count parent, IObserver<IList<TSource>> observer)
+                    : base(observer)
                 {
                     _count = parent._count;
                     _skip = parent._skip;
@@ -43,12 +43,12 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private int _n;
 
-                public IDisposable Run(IObservable<TSource> source)
+                public override void Run(IObservable<TSource> source)
                 {
                     _n = 0;
 
                     CreateWindow();
-                    return source.SubscribeSafe(this);
+                    base.Run(source);
                 }
 
                 private void CreateWindow()
@@ -113,9 +113,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _scheduler = scheduler;
             }
 
-            protected override _ CreateSink(IObserver<IList<TSource>> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<IList<TSource>> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : Sink<TSource, IList<TSource>> 
             {
@@ -126,8 +126,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private readonly Queue<List<TSource>> _q = new Queue<List<TSource>>();
                 private readonly SerialDisposable _timerD = new SerialDisposable();
 
-                public _(TimeSliding parent, IObserver<IList<TSource>> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(TimeSliding parent, IObserver<IList<TSource>> observer)
+                    : base(observer)
                 {
                     _timeShift = parent._timeShift;
                     _scheduler = parent._scheduler;
@@ -137,7 +137,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 private TimeSpan _nextShift;
                 private TimeSpan _nextSpan;
 
-                public IDisposable Run(TimeSliding parent)
+                public void Run(TimeSliding parent)
                 {
                     _totalTime = TimeSpan.Zero;
                     _nextShift = parent._timeShift;
@@ -148,7 +148,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                     var subscription = parent._source.SubscribeSafe(this);
 
-                    return StableCompositeDisposable.Create(_timerD, subscription);
+                    SetUpstream(StableCompositeDisposable.Create(_timerD, subscription));
                 }
 
                 private void CreateWindow()
@@ -266,29 +266,29 @@ namespace System.Reactive.Linq.ObservableImpl
                 _scheduler = scheduler;
             }
 
-            protected override _ CreateSink(IObserver<IList<TSource>> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<IList<TSource>> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : Sink<TSource, IList<TSource>> 
             {
                 private readonly object _gate = new object();
 
-                public _(IObserver<IList<TSource>> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<IList<TSource>> observer)
+                    : base(observer)
                 {
                 }
 
                 private List<TSource> _list;
 
-                public IDisposable Run(TimeHopping parent)
+                public void Run(TimeHopping parent)
                 {
                     _list = new List<TSource>();
 
                     var d = parent._scheduler.SchedulePeriodic(parent._timeSpan, Tick);
                     var s = parent._source.SubscribeSafe(this);
 
-                    return StableCompositeDisposable.Create(d, s);
+                    SetUpstream(StableCompositeDisposable.Create(d, s));
                 }
 
                 private void Tick()
@@ -344,9 +344,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _scheduler = scheduler;
             }
 
-            protected override _ CreateSink(IObserver<IList<TSource>> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<IList<TSource>> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run();
+            protected override void Run(_ sink) => sink.Run();
 
             internal sealed class _ : Sink<TSource, IList<TSource>> 
             {
@@ -355,8 +355,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private readonly object _gate = new object();
                 private readonly SerialDisposable _timerD = new SerialDisposable();
 
-                public _(Ferry parent, IObserver<IList<TSource>> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Ferry parent, IObserver<IList<TSource>> observer)
+                    : base(observer)
                 {
                     _parent = parent;
                 }
@@ -365,7 +365,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 private int _n;
                 private int _windowId;
 
-                public IDisposable Run()
+                public void Run()
                 {
                     _s = new List<TSource>();
                     _n = 0;
@@ -375,7 +375,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                     var subscription = _parent._source.SubscribeSafe(this);
 
-                    return StableCompositeDisposable.Create(_timerD, subscription);
+                    SetUpstream(StableCompositeDisposable.Create(_timerD, subscription));
                 }
 
                 private void CreateTimer(int id)
@@ -469,9 +469,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _bufferClosingSelector = bufferClosingSelector;
             }
 
-            protected override _ CreateSink(IObserver<IList<TSource>> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<IList<TSource>> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(_source);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, IList<TSource>> 
             {
@@ -481,15 +481,15 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private readonly Func<IObservable<TBufferClosing>> _bufferClosingSelector;
 
-                public _(Selector parent, IObserver<IList<TSource>> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Selector parent, IObserver<IList<TSource>> observer)
+                    : base(observer)
                 {
                     _bufferClosingSelector = parent._bufferClosingSelector;
                 }
 
                 private IList<TSource> _buffer;
 
-                public IDisposable Run(IObservable<TSource> source)
+                public void Run(IObservable<TSource> source)
                 {
                     _buffer = new List<TSource>();
 
@@ -497,7 +497,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                     _bufferGate.Wait(CreateBufferClose);
 
-                    return groupDisposable;
+                    SetUpstream(groupDisposable);
                 }
 
                 private void CreateBufferClose()
@@ -601,29 +601,29 @@ namespace System.Reactive.Linq.ObservableImpl
                 _bufferBoundaries = bufferBoundaries;
             }
 
-            protected override _ CreateSink(IObserver<IList<TSource>> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<IList<TSource>> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : Sink<TSource, IList<TSource>> 
             {
                 private readonly object _gate = new object();
 
-                public _(IObserver<IList<TSource>> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<IList<TSource>> observer)
+                    : base(observer)
                 {
                 }
 
                 private IList<TSource> _buffer;
 
-                public IDisposable Run(Boundaries parent)
+                public void Run(Boundaries parent)
                 {
                     _buffer = new List<TSource>();
 
                     var sourceSubscription = parent._source.SubscribeSafe(this);
                     var boundariesSubscription = parent._bufferBoundaries.SubscribeSafe(new BufferClosingObserver(this));
 
-                    return StableCompositeDisposable.Create(sourceSubscription, boundariesSubscription);
+                    SetUpstream(StableCompositeDisposable.Create(sourceSubscription, boundariesSubscription));
                 }
 
                 private sealed class BufferClosingObserver : IObserver<TBufferClosing>

Rx.NET/Source/src/System.Reactive/Linq/Observable/Case.cs

@@ -28,18 +28,18 @@ namespace System.Reactive.Linq.ObservableImpl
             return _defaultSource;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : IdentitySink<TResult>
         {
-            public _(IObserver<TResult> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TResult> observer)
+                : base(observer)
             {
             }
 
-            public IDisposable Run(Case<TValue, TResult> parent)
+            public void Run(Case<TValue, TResult> parent)
             {
                 var result = default(IObservable<TResult>);
                 try
@@ -49,10 +49,11 @@ namespace System.Reactive.Linq.ObservableImpl
                 catch (Exception exception)
                 {
                     ForwardOnError(exception);
-                    return Disposable.Empty;
+
+                    return;
                 }
 
-                return result.SubscribeSafe(this);
+                SetUpstream(result.SubscribeSafe(this));
             }
         }
     }

Rx.NET/Source/src/System.Reactive/Linq/Observable/Cast.cs

@@ -13,14 +13,14 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, TResult> 
         {
-            public _(IObserver<TResult> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TResult> observer)
+                : base(observer)
             {
             }
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/Catch.cs

@@ -16,14 +16,14 @@ namespace System.Reactive.Linq.ObservableImpl
             _sources = sources;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_sources);
+        protected override void Run(_ sink) => sink.Run(_sources);
 
         internal sealed class _ : TailRecursiveSink<TSource>
         {
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
 
@@ -75,23 +75,23 @@ namespace System.Reactive.Linq.ObservableImpl
             _handler = handler;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_handler, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(_handler, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<TSource>
         {
             private readonly Func<TException, IObservable<TSource>> _handler;
 
-            public _(Func<TException, IObservable<TSource>> handler, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Func<TException, IObservable<TSource>> handler, IObserver<TSource> observer)
+                : base(observer)
             {
                 _handler = handler;
             }
 
             private SerialDisposable _subscription;
 
-            public IDisposable Run(IObservable<TSource> source)
+            public void Run(IObservable<TSource> source)
             {
                 _subscription = new SerialDisposable();
 
@@ -99,7 +99,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 _subscription.Disposable = d1;
                 d1.Disposable = source.SubscribeSafe(this);
 
-                return _subscription;
+                SetUpstream(_subscription);
             }
 
             public override void OnError(Exception error)

Rx.NET/Source/src/System.Reactive/Linq/Observable/CombineLatest.Generated.cs

@@ -10,7 +10,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
     /* The following code is generated by a T4 template. */
 
-    #region CombineLatest auto-generated code (2018.05.28. 16:02:20)
+    #region CombineLatest auto-generated code (06.06.2018 11:24:41)
 
     internal sealed class CombineLatest<T1, T2, T3, TResult> : Producer<TResult, CombineLatest<T1, T2, T3, TResult>._>
     {
@@ -27,16 +27,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source1, _source2, _source3);
+        protected override void Run(_ sink) => sink.Run(_source1, _source2, _source3);
 
         internal sealed class _ : CombineLatestSink<TResult>
         {
             private readonly Func<T1, T2, T3, TResult> _resultSelector;
 
-            public _(Func<T1, T2, T3, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(3, observer, cancel)
+            public _(Func<T1, T2, T3, TResult> resultSelector, IObserver<TResult> observer)
+                : base(3, observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -45,7 +45,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private CombineLatestObserver<T2> _observer2;
             private CombineLatestObserver<T3> _observer3;
 
-            public IDisposable Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3)
+            public void Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3)
             {
                 var subscriptions = new SingleAssignmentDisposable[3];
                 for (int i = 0; i < 3; i++)
@@ -59,7 +59,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 subscriptions[1].Disposable = source2.SubscribeSafe(_observer2);
                 subscriptions[2].Disposable = source3.SubscribeSafe(_observer3);
 
-                return StableCompositeDisposable.Create(subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(subscriptions));
             }
 
             protected override TResult GetResult() => _resultSelector(_observer1.Value, _observer2.Value, _observer3.Value);
@@ -83,16 +83,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4);
+        protected override void Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4);
 
         internal sealed class _ : CombineLatestSink<TResult>
         {
             private readonly Func<T1, T2, T3, T4, TResult> _resultSelector;
 
-            public _(Func<T1, T2, T3, T4, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(4, observer, cancel)
+            public _(Func<T1, T2, T3, T4, TResult> resultSelector, IObserver<TResult> observer)
+                : base(4, observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -102,7 +102,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private CombineLatestObserver<T3> _observer3;
             private CombineLatestObserver<T4> _observer4;
 
-            public IDisposable Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4)
+            public void Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4)
             {
                 var subscriptions = new SingleAssignmentDisposable[4];
                 for (int i = 0; i < 4; i++)
@@ -118,7 +118,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 subscriptions[2].Disposable = source3.SubscribeSafe(_observer3);
                 subscriptions[3].Disposable = source4.SubscribeSafe(_observer4);
 
-                return StableCompositeDisposable.Create(subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(subscriptions));
             }
 
             protected override TResult GetResult() => _resultSelector(_observer1.Value, _observer2.Value, _observer3.Value, _observer4.Value);
@@ -144,16 +144,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5);
+        protected override void Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5);
 
         internal sealed class _ : CombineLatestSink<TResult>
         {
             private readonly Func<T1, T2, T3, T4, T5, TResult> _resultSelector;
 
-            public _(Func<T1, T2, T3, T4, T5, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(5, observer, cancel)
+            public _(Func<T1, T2, T3, T4, T5, TResult> resultSelector, IObserver<TResult> observer)
+                : base(5, observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -164,7 +164,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private CombineLatestObserver<T4> _observer4;
             private CombineLatestObserver<T5> _observer5;
 
-            public IDisposable Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5)
+            public void Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5)
             {
                 var subscriptions = new SingleAssignmentDisposable[5];
                 for (int i = 0; i < 5; i++)
@@ -182,7 +182,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 subscriptions[3].Disposable = source4.SubscribeSafe(_observer4);
                 subscriptions[4].Disposable = source5.SubscribeSafe(_observer5);
 
-                return StableCompositeDisposable.Create(subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(subscriptions));
             }
 
             protected override TResult GetResult() => _resultSelector(_observer1.Value, _observer2.Value, _observer3.Value, _observer4.Value, _observer5.Value);
@@ -210,16 +210,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6);
+        protected override void Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6);
 
         internal sealed class _ : CombineLatestSink<TResult>
         {
             private readonly Func<T1, T2, T3, T4, T5, T6, TResult> _resultSelector;
 
-            public _(Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(6, observer, cancel)
+            public _(Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector, IObserver<TResult> observer)
+                : base(6, observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -231,7 +231,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private CombineLatestObserver<T5> _observer5;
             private CombineLatestObserver<T6> _observer6;
 
-            public IDisposable Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6)
+            public void Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6)
             {
                 var subscriptions = new SingleAssignmentDisposable[6];
                 for (int i = 0; i < 6; i++)
@@ -251,7 +251,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 subscriptions[4].Disposable = source5.SubscribeSafe(_observer5);
                 subscriptions[5].Disposable = source6.SubscribeSafe(_observer6);
 
-                return StableCompositeDisposable.Create(subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(subscriptions));
             }
 
             protected override TResult GetResult() => _resultSelector(_observer1.Value, _observer2.Value, _observer3.Value, _observer4.Value, _observer5.Value, _observer6.Value);
@@ -281,16 +281,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7);
+        protected override void Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7);
 
         internal sealed class _ : CombineLatestSink<TResult>
         {
             private readonly Func<T1, T2, T3, T4, T5, T6, T7, TResult> _resultSelector;
 
-            public _(Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(7, observer, cancel)
+            public _(Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector, IObserver<TResult> observer)
+                : base(7, observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -303,7 +303,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private CombineLatestObserver<T6> _observer6;
             private CombineLatestObserver<T7> _observer7;
 
-            public IDisposable Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7)
+            public void Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7)
             {
                 var subscriptions = new SingleAssignmentDisposable[7];
                 for (int i = 0; i < 7; i++)
@@ -325,7 +325,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 subscriptions[5].Disposable = source6.SubscribeSafe(_observer6);
                 subscriptions[6].Disposable = source7.SubscribeSafe(_observer7);
 
-                return StableCompositeDisposable.Create(subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(subscriptions));
             }
 
             protected override TResult GetResult() => _resultSelector(_observer1.Value, _observer2.Value, _observer3.Value, _observer4.Value, _observer5.Value, _observer6.Value, _observer7.Value);
@@ -357,16 +357,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8);
+        protected override void Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8);
 
         internal sealed class _ : CombineLatestSink<TResult>
         {
             private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> _resultSelector;
 
-            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(8, observer, cancel)
+            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector, IObserver<TResult> observer)
+                : base(8, observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -380,7 +380,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private CombineLatestObserver<T7> _observer7;
             private CombineLatestObserver<T8> _observer8;
 
-            public IDisposable Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8)
+            public void Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8)
             {
                 var subscriptions = new SingleAssignmentDisposable[8];
                 for (int i = 0; i < 8; i++)
@@ -404,7 +404,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 subscriptions[6].Disposable = source7.SubscribeSafe(_observer7);
                 subscriptions[7].Disposable = source8.SubscribeSafe(_observer8);
 
-                return StableCompositeDisposable.Create(subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(subscriptions));
             }
 
             protected override TResult GetResult() => _resultSelector(_observer1.Value, _observer2.Value, _observer3.Value, _observer4.Value, _observer5.Value, _observer6.Value, _observer7.Value, _observer8.Value);
@@ -438,16 +438,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9);
+        protected override void Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9);
 
         internal sealed class _ : CombineLatestSink<TResult>
         {
             private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> _resultSelector;
 
-            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(9, observer, cancel)
+            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> resultSelector, IObserver<TResult> observer)
+                : base(9, observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -462,7 +462,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private CombineLatestObserver<T8> _observer8;
             private CombineLatestObserver<T9> _observer9;
 
-            public IDisposable Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9)
+            public void Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9)
             {
                 var subscriptions = new SingleAssignmentDisposable[9];
                 for (int i = 0; i < 9; i++)
@@ -488,7 +488,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 subscriptions[7].Disposable = source8.SubscribeSafe(_observer8);
                 subscriptions[8].Disposable = source9.SubscribeSafe(_observer9);
 
-                return StableCompositeDisposable.Create(subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(subscriptions));
             }
 
             protected override TResult GetResult() => _resultSelector(_observer1.Value, _observer2.Value, _observer3.Value, _observer4.Value, _observer5.Value, _observer6.Value, _observer7.Value, _observer8.Value, _observer9.Value);
@@ -524,16 +524,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9, _source10);
+        protected override void Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9, _source10);
 
         internal sealed class _ : CombineLatestSink<TResult>
         {
             private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> _resultSelector;
 
-            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(10, observer, cancel)
+            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> resultSelector, IObserver<TResult> observer)
+                : base(10, observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -549,7 +549,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private CombineLatestObserver<T9> _observer9;
             private CombineLatestObserver<T10> _observer10;
 
-            public IDisposable Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9, IObservable<T10> source10)
+            public void Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9, IObservable<T10> source10)
             {
                 var subscriptions = new SingleAssignmentDisposable[10];
                 for (int i = 0; i < 10; i++)
@@ -577,7 +577,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 subscriptions[8].Disposable = source9.SubscribeSafe(_observer9);
                 subscriptions[9].Disposable = source10.SubscribeSafe(_observer10);
 
-                return StableCompositeDisposable.Create(subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(subscriptions));
             }
 
             protected override TResult GetResult() => _resultSelector(_observer1.Value, _observer2.Value, _observer3.Value, _observer4.Value, _observer5.Value, _observer6.Value, _observer7.Value, _observer8.Value, _observer9.Value, _observer10.Value);
@@ -615,16 +615,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9, _source10, _source11);
+        protected override void Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9, _source10, _source11);
 
         internal sealed class _ : CombineLatestSink<TResult>
         {
             private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> _resultSelector;
 
-            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(11, observer, cancel)
+            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> resultSelector, IObserver<TResult> observer)
+                : base(11, observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -641,7 +641,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private CombineLatestObserver<T10> _observer10;
             private CombineLatestObserver<T11> _observer11;
 
-            public IDisposable Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9, IObservable<T10> source10, IObservable<T11> source11)
+            public void Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9, IObservable<T10> source10, IObservable<T11> source11)
             {
                 var subscriptions = new SingleAssignmentDisposable[11];
                 for (int i = 0; i < 11; i++)
@@ -671,7 +671,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 subscriptions[9].Disposable = source10.SubscribeSafe(_observer10);
                 subscriptions[10].Disposable = source11.SubscribeSafe(_observer11);
 
-                return StableCompositeDisposable.Create(subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(subscriptions));
             }
 
             protected override TResult GetResult() => _resultSelector(_observer1.Value, _observer2.Value, _observer3.Value, _observer4.Value, _observer5.Value, _observer6.Value, _observer7.Value, _observer8.Value, _observer9.Value, _observer10.Value, _observer11.Value);
@@ -711,16 +711,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9, _source10, _source11, _source12);
+        protected override void Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9, _source10, _source11, _source12);
 
         internal sealed class _ : CombineLatestSink<TResult>
         {
             private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> _resultSelector;
 
-            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(12, observer, cancel)
+            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> resultSelector, IObserver<TResult> observer)
+                : base(12, observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -738,7 +738,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private CombineLatestObserver<T11> _observer11;
             private CombineLatestObserver<T12> _observer12;
 
-            public IDisposable Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9, IObservable<T10> source10, IObservable<T11> source11, IObservable<T12> source12)
+            public void Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9, IObservable<T10> source10, IObservable<T11> source11, IObservable<T12> source12)
             {
                 var subscriptions = new SingleAssignmentDisposable[12];
                 for (int i = 0; i < 12; i++)
@@ -770,7 +770,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 subscriptions[10].Disposable = source11.SubscribeSafe(_observer11);
                 subscriptions[11].Disposable = source12.SubscribeSafe(_observer12);
 
-                return StableCompositeDisposable.Create(subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(subscriptions));
             }
 
             protected override TResult GetResult() => _resultSelector(_observer1.Value, _observer2.Value, _observer3.Value, _observer4.Value, _observer5.Value, _observer6.Value, _observer7.Value, _observer8.Value, _observer9.Value, _observer10.Value, _observer11.Value, _observer12.Value);
@@ -812,16 +812,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9, _source10, _source11, _source12, _source13);
+        protected override void Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9, _source10, _source11, _source12, _source13);
 
         internal sealed class _ : CombineLatestSink<TResult>
         {
             private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> _resultSelector;
 
-            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(13, observer, cancel)
+            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> resultSelector, IObserver<TResult> observer)
+                : base(13, observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -840,7 +840,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private CombineLatestObserver<T12> _observer12;
             private CombineLatestObserver<T13> _observer13;
 
-            public IDisposable Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9, IObservable<T10> source10, IObservable<T11> source11, IObservable<T12> source12, IObservable<T13> source13)
+            public void Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9, IObservable<T10> source10, IObservable<T11> source11, IObservable<T12> source12, IObservable<T13> source13)
             {
                 var subscriptions = new SingleAssignmentDisposable[13];
                 for (int i = 0; i < 13; i++)
@@ -874,7 +874,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 subscriptions[11].Disposable = source12.SubscribeSafe(_observer12);
                 subscriptions[12].Disposable = source13.SubscribeSafe(_observer13);
 
-                return StableCompositeDisposable.Create(subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(subscriptions));
             }
 
             protected override TResult GetResult() => _resultSelector(_observer1.Value, _observer2.Value, _observer3.Value, _observer4.Value, _observer5.Value, _observer6.Value, _observer7.Value, _observer8.Value, _observer9.Value, _observer10.Value, _observer11.Value, _observer12.Value, _observer13.Value);
@@ -918,16 +918,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9, _source10, _source11, _source12, _source13, _source14);
+        protected override void Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9, _source10, _source11, _source12, _source13, _source14);
 
         internal sealed class _ : CombineLatestSink<TResult>
         {
             private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> _resultSelector;
 
-            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(14, observer, cancel)
+            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> resultSelector, IObserver<TResult> observer)
+                : base(14, observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -947,7 +947,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private CombineLatestObserver<T13> _observer13;
             private CombineLatestObserver<T14> _observer14;
 
-            public IDisposable Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9, IObservable<T10> source10, IObservable<T11> source11, IObservable<T12> source12, IObservable<T13> source13, IObservable<T14> source14)
+            public void Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9, IObservable<T10> source10, IObservable<T11> source11, IObservable<T12> source12, IObservable<T13> source13, IObservable<T14> source14)
             {
                 var subscriptions = new SingleAssignmentDisposable[14];
                 for (int i = 0; i < 14; i++)
@@ -983,7 +983,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 subscriptions[12].Disposable = source13.SubscribeSafe(_observer13);
                 subscriptions[13].Disposable = source14.SubscribeSafe(_observer14);
 
-                return StableCompositeDisposable.Create(subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(subscriptions));
             }
 
             protected override TResult GetResult() => _resultSelector(_observer1.Value, _observer2.Value, _observer3.Value, _observer4.Value, _observer5.Value, _observer6.Value, _observer7.Value, _observer8.Value, _observer9.Value, _observer10.Value, _observer11.Value, _observer12.Value, _observer13.Value, _observer14.Value);
@@ -1029,16 +1029,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9, _source10, _source11, _source12, _source13, _source14, _source15);
+        protected override void Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9, _source10, _source11, _source12, _source13, _source14, _source15);
 
         internal sealed class _ : CombineLatestSink<TResult>
         {
             private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> _resultSelector;
 
-            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(15, observer, cancel)
+            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> resultSelector, IObserver<TResult> observer)
+                : base(15, observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -1059,7 +1059,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private CombineLatestObserver<T14> _observer14;
             private CombineLatestObserver<T15> _observer15;
 
-            public IDisposable Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9, IObservable<T10> source10, IObservable<T11> source11, IObservable<T12> source12, IObservable<T13> source13, IObservable<T14> source14, IObservable<T15> source15)
+            public void Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9, IObservable<T10> source10, IObservable<T11> source11, IObservable<T12> source12, IObservable<T13> source13, IObservable<T14> source14, IObservable<T15> source15)
             {
                 var subscriptions = new SingleAssignmentDisposable[15];
                 for (int i = 0; i < 15; i++)
@@ -1097,7 +1097,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 subscriptions[13].Disposable = source14.SubscribeSafe(_observer14);
                 subscriptions[14].Disposable = source15.SubscribeSafe(_observer15);
 
-                return StableCompositeDisposable.Create(subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(subscriptions));
             }
 
             protected override TResult GetResult() => _resultSelector(_observer1.Value, _observer2.Value, _observer3.Value, _observer4.Value, _observer5.Value, _observer6.Value, _observer7.Value, _observer8.Value, _observer9.Value, _observer10.Value, _observer11.Value, _observer12.Value, _observer13.Value, _observer14.Value, _observer15.Value);
@@ -1145,16 +1145,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9, _source10, _source11, _source12, _source13, _source14, _source15, _source16);
+        protected override void Run(_ sink) => sink.Run(_source1, _source2, _source3, _source4, _source5, _source6, _source7, _source8, _source9, _source10, _source11, _source12, _source13, _source14, _source15, _source16);
 
         internal sealed class _ : CombineLatestSink<TResult>
         {
             private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> _resultSelector;
 
-            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(16, observer, cancel)
+            public _(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> resultSelector, IObserver<TResult> observer)
+                : base(16, observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -1176,7 +1176,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private CombineLatestObserver<T15> _observer15;
             private CombineLatestObserver<T16> _observer16;
 
-            public IDisposable Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9, IObservable<T10> source10, IObservable<T11> source11, IObservable<T12> source12, IObservable<T13> source13, IObservable<T14> source14, IObservable<T15> source15, IObservable<T16> source16)
+            public void Run(IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, IObservable<T8> source8, IObservable<T9> source9, IObservable<T10> source10, IObservable<T11> source11, IObservable<T12> source12, IObservable<T13> source13, IObservable<T14> source14, IObservable<T15> source15, IObservable<T16> source16)
             {
                 var subscriptions = new SingleAssignmentDisposable[16];
                 for (int i = 0; i < 16; i++)
@@ -1216,7 +1216,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 subscriptions[14].Disposable = source15.SubscribeSafe(_observer15);
                 subscriptions[15].Disposable = source16.SubscribeSafe(_observer16);
 
-                return StableCompositeDisposable.Create(subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(subscriptions));
             }
 
             protected override TResult GetResult() => _resultSelector(_observer1.Value, _observer2.Value, _observer3.Value, _observer4.Value, _observer5.Value, _observer6.Value, _observer7.Value, _observer8.Value, _observer9.Value, _observer10.Value, _observer11.Value, _observer12.Value, _observer13.Value, _observer14.Value, _observer15.Value, _observer16.Value);

Rx.NET/Source/src/System.Reactive/Linq/Observable/CombineLatest.Generated.tt

@@ -51,16 +51,16 @@ for (var j = 1; j <= i; j++)
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(<#=ss#>);
+        protected override void Run(_ sink) => sink.Run(<#=ss#>);
 
         internal sealed class _ : CombineLatestSink<TResult>
         {
             private readonly Func<<#=ts#>, TResult> _resultSelector;
 
-            public _(Func<<#=ts#>, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(<#=i#>, observer, cancel)
+            public _(Func<<#=ts#>, TResult> resultSelector, IObserver<TResult> observer)
+                : base(<#=i#>, observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -74,7 +74,7 @@ for (var j = 1; j <= i; j++)
 }
 #>
 
-            public IDisposable Run(<#=os#>)
+            public void Run(<#=os#>)
             {
                 var subscriptions = new SingleAssignmentDisposable[<#=i#>];
                 for (int i = 0; i < <#=i#>; i++)
@@ -98,7 +98,7 @@ for (var j = 1; j <= i; j++)
 }
 #>
 
-                return StableCompositeDisposable.Create(subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(subscriptions));
             }
 
             protected override TResult GetResult() => _resultSelector(<#=vs#>);

Rx.NET/Source/src/System.Reactive/Linq/Observable/CombineLatest.cs

@@ -24,23 +24,23 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_first, _second);
+        protected override void Run(_ sink) => sink.Run(_first, _second);
 
         internal sealed class _ : IdentitySink<TResult>
         {
             private readonly Func<TFirst, TSecond, TResult> _resultSelector;
 
-            public _(Func<TFirst, TSecond, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Func<TFirst, TSecond, TResult> resultSelector, IObserver<TResult> observer)
+                : base(observer)
             {
                 _resultSelector = resultSelector;
             }
 
             private object _gate;
 
-            public IDisposable Run(IObservable<TFirst> first, IObservable<TSecond> second)
+            public void Run(IObservable<TFirst> first, IObservable<TSecond> second)
             {
                 _gate = new object();
 
@@ -56,7 +56,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 fstSubscription.Disposable = first.SubscribeSafe(fstO);
                 sndSubscription.Disposable = second.SubscribeSafe(sndO);
 
-                return StableCompositeDisposable.Create(fstSubscription, sndSubscription);
+                SetUpstream(StableCompositeDisposable.Create(fstSubscription, sndSubscription));
             }
 
             private sealed class FirstObserver : IObserver<TFirst>
@@ -232,8 +232,8 @@ namespace System.Reactive.Linq.ObservableImpl
         private readonly bool[] _hasValue;
         private readonly bool[] _isDone;
 
-        public CombineLatestSink(int arity, IObserver<TResult> observer, IDisposable cancel)
-            : base(observer, cancel)
+        public CombineLatestSink(int arity, IObserver<TResult> observer)
+            : base(observer)
         {
             _gate = new object();
 
@@ -389,16 +389,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_sources);
+        protected override void Run(_ sink) => sink.Run(_sources);
 
         internal sealed class _ : IdentitySink<TResult>
         {
             private readonly Func<IList<TSource>, TResult> _resultSelector;
 
-            public _(Func<IList<TSource>, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Func<IList<TSource>, TResult> resultSelector, IObserver<TResult> observer)
+                : base(observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -410,7 +410,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private bool[] _isDone;
             private IDisposable[] _subscriptions;
 
-            public IDisposable Run(IEnumerable<IObservable<TSource>> sources)
+            public void Run(IEnumerable<IObservable<TSource>> sources)
             {
                 var srcs = sources.ToArray();
 
@@ -440,7 +440,7 @@ namespace System.Reactive.Linq.ObservableImpl
                     d.Disposable = srcs[j].SubscribeSafe(o);
                 }
 
-                return StableCompositeDisposable.Create(_subscriptions);
+                SetUpstream(StableCompositeDisposable.Create(_subscriptions));
             }
 
             private void OnNext(int index, TSource value)

Rx.NET/Source/src/System.Reactive/Linq/Observable/Concat.cs

@@ -15,16 +15,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _sources = sources;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_sources);
+        protected override void Run(_ sink) => sink.Run(_sources);
 
         public IEnumerable<IObservable<TSource>> GetSources() => _sources;
 
         internal sealed class _ : ConcatSink<TSource>
         {
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
         }

Rx.NET/Source/src/System.Reactive/Linq/Observable/Contains.cs

@@ -19,17 +19,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _comparer = comparer;
         }
 
-        protected override _ CreateSink(IObserver<bool> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<bool> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, bool> 
         {
             private readonly TSource _value;
             private readonly IEqualityComparer<TSource> _comparer;
 
-            public _(Contains<TSource> parent, IObserver<bool> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Contains<TSource> parent, IObserver<bool> observer)
+                : base(observer)
             {
                 _value = parent._value;
                 _comparer = parent._comparer;

Rx.NET/Source/src/System.Reactive/Linq/Observable/Count.cs

@@ -15,16 +15,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 _source = source;
             }
 
-            protected override _ CreateSink(IObserver<int> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<int> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, int> 
             {
                 private int _count;
 
-                public _(IObserver<int> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<int> observer)
+                    : base(observer)
                 {
                     _count = 0;
                 }
@@ -63,17 +63,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _predicate = predicate;
             }
 
-            protected override _ CreateSink(IObserver<int> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+            protected override _ CreateSink(IObserver<int> observer) => new _(_predicate, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, int> 
             {
                 private readonly Func<TSource, bool> _predicate;
                 private int _count;
 
-                public _(Func<TSource, bool> predicate, IObserver<int> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, bool> predicate, IObserver<int> observer)
+                    : base(observer)
                 {
                     _predicate = predicate;
                     _count = 0;

Rx.NET/Source/src/System.Reactive/Linq/Observable/DefaultIfEmpty.cs

@@ -15,17 +15,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _defaultValue = defaultValue;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_defaultValue, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(_defaultValue, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<TSource>
         {
             private readonly TSource _defaultValue;
             private bool _found;
 
-            public _(TSource defaultValue, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(TSource defaultValue, IObserver<TSource> observer)
+                : base(observer)
             {
                 _defaultValue = defaultValue;
                 _found = false;

Rx.NET/Source/src/System.Reactive/Linq/Observable/Defer.cs

@@ -15,9 +15,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _observableFactory = observableFactory;
         }
 
-        protected override _ CreateSink(IObserver<TValue> observer, IDisposable cancel) => new _(_observableFactory, observer, cancel);
+        protected override _ CreateSink(IObserver<TValue> observer) => new _(_observableFactory, observer);
 
-        protected override IDisposable Run(_ sink) =>sink.Run();
+        protected override void Run(_ sink) => sink.Run();
 
         public IObservable<TValue> Eval() => _observableFactory();
 
@@ -25,13 +25,13 @@ namespace System.Reactive.Linq.ObservableImpl
         {
             private readonly Func<IObservable<TValue>> _observableFactory;
 
-            public _(Func<IObservable<TValue>> observableFactory, IObserver<TValue> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Func<IObservable<TValue>> observableFactory, IObserver<TValue> observer)
+                : base(observer)
             {
                 _observableFactory = observableFactory;
             }
 
-            public IDisposable Run()
+            public void Run()
             {
                 var result = default(IObservable<TValue>);
                 try
@@ -41,10 +41,11 @@ namespace System.Reactive.Linq.ObservableImpl
                 catch (Exception exception)
                 {
                     ForwardOnError(exception);
-                    return Disposable.Empty;
+
+                    return;
                 }
 
-                return result.SubscribeSafe(this);
+                SetUpstream(result.SubscribeSafe(this));
             }
         }
     }

Rx.NET/Source/src/System.Reactive/Linq/Observable/Delay.cs

@@ -25,12 +25,12 @@ namespace System.Reactive.Linq.ObservableImpl
 
             internal abstract class _ : IdentitySink<TSource>
             {
-                public _(IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<TSource> observer)
+                    : base(observer)
                 {
                 }
 
-                public abstract IDisposable Run(TParent parent);
+                public abstract void Run(TParent parent);
             }
 
             internal abstract class S : _
@@ -40,8 +40,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 protected readonly IScheduler _scheduler;
 
-                public S(TParent parent, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public S(TParent parent, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _scheduler = parent._scheduler;
                 }
@@ -60,7 +60,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 private bool _hasFailed;
                 private Exception _exception;
 
-                public override IDisposable Run(TParent parent)
+                public override void Run(TParent parent)
                 {
                     _active = false;
                     _running = false;
@@ -75,8 +75,6 @@ namespace System.Reactive.Linq.ObservableImpl
                     RunCore(parent);
 
                     Disposable.SetSingle(ref _sourceSubscription, parent._source.SubscribeSafe(this));
-
-                    return this;
                 }
 
                 protected override void Dispose(bool disposing)
@@ -86,6 +84,7 @@ namespace System.Reactive.Linq.ObservableImpl
                         Disposable.TryDispose(ref _sourceSubscription);
                         Disposable.TryDispose(ref _cancelable);
                     }
+
                     base.Dispose(disposing);
                 }
 
@@ -271,8 +270,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private readonly IScheduler _scheduler;
 
-                public L(TParent parent, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public L(TParent parent, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _scheduler = parent._scheduler;
                 }
@@ -289,7 +288,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 private bool _hasFailed;
                 private Exception _exception;
 
-                public override IDisposable Run(TParent parent)
+                public override void Run(TParent parent)
                 {
                     _queue = new Queue<System.Reactive.TimeInterval<TSource>>();
                     _hasCompleted = false;
@@ -302,8 +301,6 @@ namespace System.Reactive.Linq.ObservableImpl
                     RunCore(parent);
 
                     Disposable.SetSingle(ref _sourceSubscription, parent._source.SubscribeSafe(this));
-
-                    return this;
                 }
 
                 protected override void Dispose(bool disposing)
@@ -478,14 +475,14 @@ namespace System.Reactive.Linq.ObservableImpl
                 _dueTime = dueTime;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => _scheduler.AsLongRunning() != null ? (Base<Absolute>._)new L(this, observer, cancel) : new S(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => _scheduler.AsLongRunning() != null ? (Base<Absolute>._)new L(this, observer) : new S(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             new private sealed class S : Base<Absolute>.S
             {
-                public S(Absolute parent, IObserver<TSource> observer, IDisposable cancel)
-                    : base(parent, observer, cancel)
+                public S(Absolute parent, IObserver<TSource> observer)
+                    : base(parent, observer)
                 {
                 }
 
@@ -534,8 +531,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
             new private sealed class L : Base<Absolute>.L
             {
-                public L(Absolute parent, IObserver<TSource> observer, IDisposable cancel)
-                    : base(parent, observer, cancel)
+                public L(Absolute parent, IObserver<TSource> observer)
+                    : base(parent, observer)
                 {
                 }
 
@@ -578,14 +575,14 @@ namespace System.Reactive.Linq.ObservableImpl
                 _dueTime = dueTime;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => _scheduler.AsLongRunning() != null ? (Base<Relative>._)new L(this, observer, cancel) : new S(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => _scheduler.AsLongRunning() != null ? (Base<Relative>._)new L(this, observer) : new S(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             new private sealed class S : Base<Relative>.S
             {
-                public S(Relative parent, IObserver<TSource> observer, IDisposable cancel)
-                    : base(parent, observer, cancel)
+                public S(Relative parent, IObserver<TSource> observer)
+                    : base(parent, observer)
                 {
                 }
 
@@ -599,8 +596,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
             new private sealed class L : Base<Relative>.L
             {
-                public L(Relative parent, IObserver<TSource> observer, IDisposable cancel)
-                    : base(parent, observer, cancel)
+                public L(Relative parent, IObserver<TSource> observer)
+                    : base(parent, observer)
                 {
                 }
 
@@ -632,8 +629,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private readonly Func<TSource, IObservable<TDelay>> _delaySelector;
 
-                public _(Func<TSource, IObservable<TDelay>> delaySelector, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, IObservable<TDelay>> delaySelector, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _delaySelector = delaySelector;
                 }
@@ -641,13 +638,13 @@ namespace System.Reactive.Linq.ObservableImpl
                 private bool _atEnd;
                 private IDisposable _subscription;
 
-                public IDisposable Run(TParent parent)
+                public void Run(TParent parent)
                 {
                     _atEnd = false;
 
                     _subscription = RunCore(parent);
 
-                    return StableCompositeDisposable.Create(_subscription, _delays);
+                    SetUpstream(StableCompositeDisposable.Create(_subscription, _delays));
                 }
 
                 protected abstract IDisposable RunCore(TParent parent);
@@ -757,14 +754,14 @@ namespace System.Reactive.Linq.ObservableImpl
                 _delaySelector = delaySelector;
             }
 
-            protected override Base<Selector>._ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_delaySelector, observer, cancel);
+            protected override Base<Selector>._ CreateSink(IObserver<TSource> observer) => new _(_delaySelector, observer);
 
-            protected override IDisposable Run(Base<Selector>._ sink) => sink.Run(this);
+            protected override void Run(Base<Selector>._ sink) => sink.Run(this);
 
             new private sealed class _ : Base<Selector>._
             {
-                public _(Func<TSource, IObservable<TDelay>> delaySelector, IObserver<TSource> observer, IDisposable cancel)
-                    : base(delaySelector, observer, cancel)
+                public _(Func<TSource, IObservable<TDelay>> delaySelector, IObserver<TSource> observer)
+                    : base(delaySelector, observer)
                 {
                 }
 
@@ -784,14 +781,14 @@ namespace System.Reactive.Linq.ObservableImpl
                 _delaySelector = delaySelector;
             }
 
-            protected override Base<SelectorWithSubscriptionDelay>._ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_delaySelector, observer, cancel);
+            protected override Base<SelectorWithSubscriptionDelay>._ CreateSink(IObserver<TSource> observer) => new _(_delaySelector, observer);
 
-            protected override IDisposable Run(Base<SelectorWithSubscriptionDelay>._ sink) => sink.Run(this);
+            protected override void Run(Base<SelectorWithSubscriptionDelay>._ sink) => sink.Run(this);
 
             new private sealed class _ : Base<SelectorWithSubscriptionDelay>._
             {
-                public _(Func<TSource, IObservable<TDelay>> delaySelector, IObserver<TSource> observer, IDisposable cancel)
-                    : base(delaySelector, observer, cancel)
+                public _(Func<TSource, IObservable<TDelay>> delaySelector, IObserver<TSource> observer)
+                    : base(delaySelector, observer)
                 {
                 }
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/DelaySubscription.cs

@@ -27,9 +27,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _dueTime = dueTime;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => _scheduler.Schedule(sink, _dueTime, Subscribe);
+            protected override void Run(_ sink) => sink.Run(_source, _scheduler, _dueTime);
         }
 
         internal sealed class Absolute : DelaySubscription<TSource>
@@ -42,21 +42,26 @@ namespace System.Reactive.Linq.ObservableImpl
                 _dueTime = dueTime;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => _scheduler.Schedule(sink, _dueTime, Subscribe);
-        }
-
-        private IDisposable Subscribe(IScheduler _, _ sink)
-        {
-            return _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source, _scheduler, _dueTime);
         }
 
         internal sealed class _ : IdentitySink<TSource>
         {
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
+            {
+            }
+
+            public void Run(IObservable<TSource> source, IScheduler scheduler, DateTimeOffset dueTime)
+            {
+                SetUpstream(scheduler.Schedule((@this: this, source), dueTime, (self, tuple) => tuple.source.SubscribeSafe(tuple.@this)));
+            }
+
+            public void Run(IObservable<TSource> source, IScheduler scheduler, TimeSpan dueTime)
             {
+                SetUpstream(scheduler.Schedule((@this: this, source), dueTime, (self, tuple) => tuple.source.SubscribeSafe(tuple.@this)));
             }
         }
     }

Rx.NET/Source/src/System.Reactive/Linq/Observable/Dematerialize.cs

@@ -13,14 +13,14 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<Notification<TSource>, TSource> 
         {
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/Distinct.cs

@@ -19,17 +19,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _comparer = comparer;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<TSource>
         {
             private readonly Func<TSource, TKey> _keySelector;
             private HashSet<TKey> _hashSet;
 
-            public _(Distinct<TSource, TKey> parent, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Distinct<TSource, TKey> parent, IObserver<TSource> observer)
+                : base(observer)
             {
                 _keySelector = parent._keySelector;
                 _hashSet = new HashSet<TKey>(parent._comparer);

Rx.NET/Source/src/System.Reactive/Linq/Observable/DistinctUntilChanged.cs

@@ -19,9 +19,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _comparer = comparer;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<TSource>
         {
@@ -31,8 +31,8 @@ namespace System.Reactive.Linq.ObservableImpl
             private TKey _currentKey;
             private bool _hasCurrentKey;
 
-            public _(DistinctUntilChanged<TSource, TKey> parent, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(DistinctUntilChanged<TSource, TKey> parent, IObserver<TSource> observer)
+                : base(observer)
             {
                 _keySelector = parent._keySelector;
                 _comparer = parent._comparer;

Rx.NET/Source/src/System.Reactive/Linq/Observable/Do.cs

@@ -17,16 +17,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 _onNext = onNext;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_onNext, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_onNext, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private readonly Action<TSource> _onNext;
 
-                public _(Action<TSource> onNext, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Action<TSource> onNext, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _onNext = onNext;
                 }
@@ -59,16 +59,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 _observer = observer;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_observer, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_observer, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private readonly IObserver<TSource> _doObserver;
 
-                public _(IObserver<TSource> doObserver, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<TSource> doObserver, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _doObserver = doObserver;
                 }
@@ -135,9 +135,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _onCompleted = onCompleted;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
@@ -145,8 +145,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private readonly Actions _parent;
 
-                public _(Actions parent, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Actions parent, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _parent = parent;
                 }

Rx.NET/Source/src/System.Reactive/Linq/Observable/DoWhile.cs

@@ -17,9 +17,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(GetSources());
+        protected override void Run(_ sink) => sink.Run(GetSources());
 
         public IEnumerable<IObservable<TSource>> GetSources()
         {
@@ -30,8 +30,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
         internal sealed class _ : ConcatSink<TSource>
         {
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
         }

Rx.NET/Source/src/System.Reactive/Linq/Observable/ElementAt.cs

@@ -15,16 +15,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _index = index;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_index, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(_index, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<TSource>
         {
             private int _i;
 
-            public _(int index, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(int index, IObserver<TSource> observer)
+                : base(observer)
             {
                 _i = index;
             }

Rx.NET/Source/src/System.Reactive/Linq/Observable/ElementAtOrDefault.cs

@@ -15,16 +15,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _index = index;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_index, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(_index, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<TSource>
         {
             private int _i;
 
-            public _(int index, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(int index, IObserver<TSource> observer)
+                : base(observer)
             {
                 _i = index;
             }

Rx.NET/Source/src/System.Reactive/Linq/Observable/Empty.cs

@@ -16,24 +16,24 @@ namespace System.Reactive.Linq.ObservableImpl
             _scheduler = scheduler;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_scheduler);
+        protected override void Run(_ sink) => sink.Run(_scheduler);
 
         internal sealed class _ : IdentitySink<TResult>
         {
-            public _(IObserver<TResult> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TResult> observer)
+                : base(observer)
             {
             }
 
-            public IDisposable Run(IScheduler scheduler)
+            public void Run(IScheduler scheduler)
             {
-                return scheduler.Schedule(this, (s, target) => 
+                SetUpstream(scheduler.Schedule(this, (s, target) => 
                 {
                     target.OnCompleted();
                     return Disposable.Empty;
-                });
+                }));
             }
         }
     }

Rx.NET/Source/src/System.Reactive/Linq/Observable/Finally.cs

@@ -17,25 +17,25 @@ namespace System.Reactive.Linq.ObservableImpl
             _finallyAction = finallyAction;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_finallyAction, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(_finallyAction, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<TSource>
         {
             private readonly Action _finallyAction;
 
-            public _(Action finallyAction, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Action finallyAction, IObserver<TSource> observer)
+                : base(observer)
             {
                 _finallyAction = finallyAction;
             }
 
-            public IDisposable Run(IObservable<TSource> source)
+            public void Run(IObservable<TSource> source)
             {
                 var subscription = source.SubscribeSafe(this);
 
-                return Disposable.Create(() =>
+                SetUpstream(Disposable.Create(() =>
                 {
                     try
                     {
@@ -45,7 +45,7 @@ namespace System.Reactive.Linq.ObservableImpl
                     {
                         _finallyAction();
                     }
-                });
+                }));
             }
         }
     }

Rx.NET/Source/src/System.Reactive/Linq/Observable/FirstAsync.cs

@@ -15,14 +15,14 @@ namespace System.Reactive.Linq.ObservableImpl
                 _source = source;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
-                public _(IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<TSource> observer)
+                    : base(observer)
                 {
                 }
 
@@ -50,16 +50,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 _predicate = predicate;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_predicate, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private readonly Func<TSource, bool> _predicate;
 
-                public _(Func<TSource, bool> predicate, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, bool> predicate, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _predicate = predicate;
                 }

Rx.NET/Source/src/System.Reactive/Linq/Observable/FirstOrDefaultAsync.cs

@@ -15,14 +15,14 @@ namespace System.Reactive.Linq.ObservableImpl
                 _source = source;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
-                public _(IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<TSource> observer)
+                    : base(observer)
                 {
                 }
 
@@ -51,16 +51,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 _predicate = predicate;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_predicate, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private readonly Func<TSource, bool> _predicate;
 
-                public _(Func<TSource, bool> predicate, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, bool> predicate, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _predicate = predicate;
                 }

Rx.NET/Source/src/System.Reactive/Linq/Observable/For.cs

@@ -17,9 +17,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(GetSources());
+        protected override void Run(_ sink) => sink.Run(GetSources());
 
         public IEnumerable<IObservable<TResult>> GetSources()
         {
@@ -29,8 +29,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
         internal sealed class _ : ConcatSink<TResult>
         {
-            public _(IObserver<TResult> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TResult> observer)
+                : base(observer)
             {
             }
         }

Rx.NET/Source/src/System.Reactive/Linq/Observable/Generate.cs

@@ -26,9 +26,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _scheduler = scheduler;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run();
+            protected override void Run(_ sink) => sink.Run();
 
             internal sealed class _ : IdentitySink<TResult>
             {
@@ -36,8 +36,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private readonly NoTime _parent;
 
-                public _(NoTime parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(NoTime parent, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _parent = parent;
                 }
@@ -45,7 +45,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 private TState _state;
                 private bool _first;
 
-                public IDisposable Run()
+                public void Run()
                 {
                     _state = _parent._initialState;
                     _first = true;
@@ -53,11 +53,11 @@ namespace System.Reactive.Linq.ObservableImpl
                     var longRunning = _parent._scheduler.AsLongRunning();
                     if (longRunning != null)
                     {
-                        return longRunning.ScheduleLongRunning(Loop);
+                        SetUpstream(longRunning.ScheduleLongRunning(Loop));
                     }
                     else
                     {
-                        return _parent._scheduler.Schedule(LoopRec);
+                        SetUpstream(_parent._scheduler.Schedule(LoopRec));
                     }
                 }
 
@@ -167,9 +167,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _scheduler = scheduler;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run();
+            protected override void Run(_ sink) => sink.Run();
 
             internal sealed class _ : IdentitySink<TResult>
             {
@@ -177,8 +177,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private readonly Absolute _parent;
 
-                public _(Absolute parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Absolute parent, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _parent = parent;
                 }
@@ -187,13 +187,13 @@ namespace System.Reactive.Linq.ObservableImpl
                 private bool _hasResult;
                 private TResult _result;
 
-                public IDisposable Run()
+                public void Run()
                 {
                     _first = true;
                     _hasResult = false;
                     _result = default(TResult);
 
-                    return _parent._scheduler.Schedule(_parent._initialState, InvokeRec);
+                    SetUpstream(_parent._scheduler.Schedule(_parent._initialState, InvokeRec));
                 }
 
                 private IDisposable InvokeRec(IScheduler self, TState state)
@@ -260,9 +260,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _scheduler = scheduler;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run();
+            protected override void Run(_ sink) => sink.Run();
 
             internal sealed class _ : IdentitySink<TResult>
             {
@@ -270,8 +270,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private readonly Relative _parent;
 
-                public _(Relative parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Relative parent, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _parent = parent;
                 }
@@ -280,13 +280,13 @@ namespace System.Reactive.Linq.ObservableImpl
                 private bool _hasResult;
                 private TResult _result;
 
-                public IDisposable Run()
+                public void Run()
                 {
                     _first = true;
                     _hasResult = false;
                     _result = default(TResult);
 
-                    return _parent._scheduler.Schedule(_parent._initialState, InvokeRec);
+                    SetUpstream(_parent._scheduler.Schedule(_parent._initialState, InvokeRec));
                 }
 
                 private IDisposable InvokeRec(IScheduler self, TState state)

Rx.NET/Source/src/System.Reactive/Linq/Observable/GroupBy.cs

@@ -25,9 +25,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _comparer = comparer;
         }
 
-        protected override _ CreateSink(IObserver<IGroupedObservable<TKey, TElement>> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<IGroupedObservable<TKey, TElement>> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, IGroupedObservable<TKey, TElement>> 
         {
@@ -38,8 +38,8 @@ namespace System.Reactive.Linq.ObservableImpl
             private RefCountDisposable _refCountDisposable;
             private Subject<TElement> _null;
 
-            public _(GroupBy<TSource, TKey, TElement> parent, IObserver<IGroupedObservable<TKey, TElement>> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(GroupBy<TSource, TKey, TElement> parent, IObserver<IGroupedObservable<TKey, TElement>> observer)
+                : base(observer)
             {
                 _keySelector = parent._keySelector;
                 _elementSelector = parent._elementSelector;
@@ -54,12 +54,13 @@ namespace System.Reactive.Linq.ObservableImpl
                 }
             }
 
-            public IDisposable Run(IObservable<TSource> source)
+            public void Run(IObservable<TSource> source)
             {
                 var sourceSubscription = new SingleAssignmentDisposable();
                 _refCountDisposable = new RefCountDisposable(sourceSubscription);
                 sourceSubscription.Disposable = source.SubscribeSafe(this);
-                return _refCountDisposable;
+
+                SetUpstream(_refCountDisposable);
             }
 
             public override void OnNext(TSource value)

Rx.NET/Source/src/System.Reactive/Linq/Observable/GroupByUntil.cs

@@ -29,9 +29,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _comparer = comparer;
         }
 
-        protected override _ CreateSink(IObserver<IGroupedObservable<TKey, TElement>> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<IGroupedObservable<TKey, TElement>> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, IGroupedObservable<TKey, TElement>> 
         {
@@ -47,8 +47,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
             private ISubject<TElement> _null;
 
-            public _(GroupByUntil<TSource, TKey, TElement, TDuration> parent, IObserver<IGroupedObservable<TKey, TElement>> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(GroupByUntil<TSource, TKey, TElement, TDuration> parent, IObserver<IGroupedObservable<TKey, TElement>> observer)
+                : base(observer)
             {
                 _refCountDisposable = new RefCountDisposable(_groupDisposable);
                 _map = new Map<TKey, ISubject<TElement>>(parent._capacity, parent._comparer);
@@ -58,11 +58,11 @@ namespace System.Reactive.Linq.ObservableImpl
                 _durationSelector = parent._durationSelector;
             }
 
-            public IDisposable Run(IObservable<TSource> source)
+            public void Run(IObservable<TSource> source)
             {
                 _groupDisposable.Add(source.SubscribeSafe(this));
 
-                return _refCountDisposable;
+                SetUpstream(_refCountDisposable);
             }
 
             private ISubject<TElement> NewSubject()

Rx.NET/Source/src/System.Reactive/Linq/Observable/GroupJoin.cs

@@ -25,9 +25,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : IdentitySink<TResult>
         {
@@ -41,8 +41,8 @@ namespace System.Reactive.Linq.ObservableImpl
             private readonly Func<TRight, IObservable<TRightDuration>> _rightDurationSelector;
             private readonly Func<TLeft, IObservable<TRight>, TResult> _resultSelector;
 
-            public _(GroupJoin<TLeft, TRight, TLeftDuration, TRightDuration, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(GroupJoin<TLeft, TRight, TLeftDuration, TRightDuration, TResult> parent, IObserver<TResult> observer)
+                : base(observer)
             {
                 _refCount = new RefCountDisposable(_group);
                 _leftMap = new SortedDictionary<int, IObserver<TRight>>();
@@ -56,7 +56,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private int _leftID;
             private int _rightID;
 
-            public IDisposable Run(GroupJoin<TLeft, TRight, TLeftDuration, TRightDuration, TResult> parent)
+            public void Run(GroupJoin<TLeft, TRight, TLeftDuration, TRightDuration, TResult> parent)
             {
                 var leftSubscription = new SingleAssignmentDisposable();
                 _group.Add(leftSubscription);
@@ -69,7 +69,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 leftSubscription.Disposable = parent._left.SubscribeSafe(new LeftObserver(this, leftSubscription));
                 rightSubscription.Disposable = parent._right.SubscribeSafe(new RightObserver(this, rightSubscription));
 
-                return _refCount;
+                SetUpstream(_refCount);
             }
 
             private sealed class LeftObserver : IObserver<TLeft>

Rx.NET/Source/src/System.Reactive/Linq/Observable/If.cs

@@ -21,21 +21,21 @@ namespace System.Reactive.Linq.ObservableImpl
 
         public IObservable<TResult> Eval() => _condition() ? _thenSource : _elseSource;
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run();
+        protected override void Run(_ sink) => sink.Run();
 
         internal sealed class _ : IdentitySink<TResult>
         {
             private readonly If<TResult> _parent;
 
-            public _(If<TResult> parent, IObserver<TResult> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(If<TResult> parent, IObserver<TResult> observer)
+                : base(observer)
             {
                 _parent = parent;
             }
 
-            public IDisposable Run()
+            public void Run()
             {
                 var result = default(IObservable<TResult>);
                 try
@@ -45,10 +45,11 @@ namespace System.Reactive.Linq.ObservableImpl
                 catch (Exception exception)
                 {
                     ForwardOnError(exception);
-                    return Disposable.Empty;
+
+                    return;
                 }
 
-                return result.SubscribeSafe(this);
+                SetUpstream(result.SubscribeSafe(this));
             }
         }
     }

Rx.NET/Source/src/System.Reactive/Linq/Observable/IgnoreElements.cs

@@ -13,14 +13,14 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<TSource>
         {
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/IsEmpty.cs

@@ -13,14 +13,14 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<bool> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<bool> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, bool> 
         {
-            public _(IObserver<bool> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<bool> observer)
+                : base(observer)
             {
             }
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/Join.cs

@@ -24,9 +24,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : IdentitySink<TResult>
         {
@@ -39,8 +39,8 @@ namespace System.Reactive.Linq.ObservableImpl
             private readonly Func<TRight, IObservable<TRightDuration>> _rightDurationSelector;
             private readonly Func<TLeft, TRight, TResult> _resultSelector;
 
-            public _(Join<TLeft, TRight, TLeftDuration, TRightDuration, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Join<TLeft, TRight, TLeftDuration, TRightDuration, TResult> parent, IObserver<TResult> observer)
+                : base(observer)
             {
                 _leftDurationSelector = parent._leftDurationSelector;
                 _rightDurationSelector = parent._rightDurationSelector;
@@ -53,7 +53,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private bool _rightDone;
             private int _rightID;
 
-            public IDisposable Run(Join<TLeft, TRight, TLeftDuration, TRightDuration, TResult> parent)
+            public void Run(Join<TLeft, TRight, TLeftDuration, TRightDuration, TResult> parent)
             {
                 var leftSubscription = new SingleAssignmentDisposable();
                 _group.Add(leftSubscription);
@@ -68,7 +68,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 leftSubscription.Disposable = parent._left.SubscribeSafe(new LeftObserver(this, leftSubscription));
                 rightSubscription.Disposable = parent._right.SubscribeSafe(new RightObserver(this, rightSubscription));
 
-                return _group;
+                SetUpstream(_group);
             }
 
             private sealed class LeftObserver : IObserver<TLeft>

Rx.NET/Source/src/System.Reactive/Linq/Observable/LastAsync.cs

@@ -15,17 +15,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _source = source;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private TSource _value;
                 private bool _seenValue;
 
-                public _(IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _value = default(TSource);
                     _seenValue = false;
@@ -63,9 +63,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _predicate = predicate;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_predicate, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
@@ -73,8 +73,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private TSource _value;
                 private bool _seenValue;
 
-                public _(Func<TSource, bool> predicate, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, bool> predicate, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _predicate = predicate;
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/LastOrDefaultAsync.cs

@@ -15,16 +15,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 _source = source;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private TSource _value;
 
-                public _(IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _value = default(TSource);
                 }
@@ -53,17 +53,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _predicate = predicate;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_predicate, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private readonly Func<TSource, bool> _predicate;
                 private TSource _value;
 
-                public _(Func<TSource, bool> predicate, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, bool> predicate, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _predicate = predicate;
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/LongCount.cs

@@ -15,16 +15,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 _source = source;
             }
 
-            protected override _ CreateSink(IObserver<long> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<long> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, long> 
             {
                 private long _count;
 
-                public _(IObserver<long> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<long> observer)
+                    : base(observer)
                 {
                     _count = 0L;
                 }
@@ -63,17 +63,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _predicate = predicate;
             }
 
-            protected override _ CreateSink(IObserver<long> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+            protected override _ CreateSink(IObserver<long> observer) => new _(_predicate, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, long> 
             {
                 private readonly Func<TSource, bool> _predicate;
                 private long _count;
 
-                public _(Func<TSource, bool> predicate, IObserver<long> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, bool> predicate, IObserver<long> observer)
+                    : base(observer)
                 {
                     _predicate = predicate;
                     _count = 0L;

Rx.NET/Source/src/System.Reactive/Linq/Observable/Materialize.cs

@@ -15,14 +15,14 @@ namespace System.Reactive.Linq.ObservableImpl
 
         public IObservable<TSource> Dematerialize() => _source.AsObservable();
 
-        protected override _ CreateSink(IObserver<Notification<TSource>> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<Notification<TSource>> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, Notification<TSource>> 
         {
-            public _(IObserver<Notification<TSource>> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<Notification<TSource>> observer)
+                : base(observer)
             {
             }
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/Max.cs

@@ -17,16 +17,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _comparer = comparer;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => default(TSource) == null ? (_)new Null(_comparer, observer, cancel) : new NonNull(_comparer, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => default(TSource) == null ? (_)new Null(_comparer, observer) : new NonNull(_comparer, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal abstract class _ : IdentitySink<TSource>
         {
             protected readonly IComparer<TSource> _comparer;
 
-            public _(IComparer<TSource> comparer, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IComparer<TSource> comparer, IObserver<TSource> observer)
+                : base(observer)
             {
                 _comparer = comparer;
             }
@@ -37,8 +37,8 @@ namespace System.Reactive.Linq.ObservableImpl
             private bool _hasValue;
             private TSource _lastValue;
 
-            public NonNull(IComparer<TSource> comparer, IObserver<TSource> observer, IDisposable cancel)
-                : base(comparer, observer, cancel)
+            public NonNull(IComparer<TSource> comparer, IObserver<TSource> observer)
+                : base(comparer, observer)
             {
                 _hasValue = false;
                 _lastValue = default(TSource);
@@ -90,8 +90,8 @@ namespace System.Reactive.Linq.ObservableImpl
         {
             private TSource _lastValue;
 
-            public Null(IComparer<TSource> comparer, IObserver<TSource> observer, IDisposable cancel)
-                : base(comparer, observer, cancel)
+            public Null(IComparer<TSource> comparer, IObserver<TSource> observer)
+                : base(comparer, observer)
             {
                 _lastValue = default(TSource);
             }
@@ -148,17 +148,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<double> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<double> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<double>
         {
             private bool _hasValue;
             private double _lastValue;
 
-            public _(IObserver<double> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<double> observer)
+                : base(observer)
             {
                 _hasValue = false;
                 _lastValue = default(double);
@@ -204,17 +204,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<float> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<float> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<float>
         {
             private bool _hasValue;
             private float _lastValue;
 
-            public _(IObserver<float> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<float> observer)
+                : base(observer)
             {
                 _hasValue = false;
                 _lastValue = default(float);
@@ -260,17 +260,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<decimal> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<decimal> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<decimal>
         {
             private bool _hasValue;
             private decimal _lastValue;
 
-            public _(IObserver<decimal> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<decimal> observer)
+                : base(observer)
             {
                 _hasValue = false;
                 _lastValue = default(decimal);
@@ -316,17 +316,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<int> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<int> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<int>
         {
             private bool _hasValue;
             private int _lastValue;
 
-            public _(IObserver<int> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<int> observer)
+                : base(observer)
             {
                 _hasValue = false;
                 _lastValue = default(int);
@@ -372,17 +372,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<long> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<long> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<long>
         {
             private bool _hasValue;
             private long _lastValue;
 
-            public _(IObserver<long> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<long> observer)
+                : base(observer)
             {
                 _hasValue = false;
                 _lastValue = default(long);
@@ -428,16 +428,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<double?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<double?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<double?>
         {
             private double? _lastValue;
 
-            public _(IObserver<double?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<double?> observer)
+                : base(observer)
             {
                 _lastValue = default(double?);
             }
@@ -477,16 +477,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<float?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<float?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<float?>
         {
             private float? _lastValue;
 
-            public _(IObserver<float?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<float?> observer)
+                : base(observer)
             {
                 _lastValue = default(float?);
             }
@@ -526,16 +526,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<decimal?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<decimal?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<decimal?>
         {
             private decimal? _lastValue;
 
-            public _(IObserver<decimal?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<decimal?> observer)
+                : base(observer)
             {
                 _lastValue = default(decimal?);
             }
@@ -575,16 +575,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<int?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<int?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<int?>
         {
             private int? _lastValue;
 
-            public _(IObserver<int?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<int?> observer)
+                : base(observer)
             {
                 _lastValue = default(int?);
             }
@@ -624,16 +624,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<long?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<long?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<long?>
         {
             private long? _lastValue;
 
-            public _(IObserver<long?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<long?> observer)
+                : base(observer)
             {
                 _lastValue = default(long?);
             }
@@ -664,3 +664,4 @@ namespace System.Reactive.Linq.ObservableImpl
         }
     }
 }
+

Rx.NET/Source/src/System.Reactive/Linq/Observable/MaxBy.cs

@@ -19,9 +19,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _comparer = comparer;
         }
 
-        protected override _ CreateSink(IObserver<IList<TSource>> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<IList<TSource>> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, IList<TSource>> 
         {
@@ -30,8 +30,8 @@ namespace System.Reactive.Linq.ObservableImpl
             private TKey _lastKey;
             private List<TSource> _list;
 
-            public _(MaxBy<TSource, TKey> parent, IObserver<IList<TSource>> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(MaxBy<TSource, TKey> parent, IObserver<IList<TSource>> observer)
+                : base(observer)
             {
                 _parent = parent;
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/Merge.cs

@@ -22,16 +22,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 _maxConcurrent = maxConcurrent;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_maxConcurrent, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_maxConcurrent, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : Sink<IObservable<TSource>, TSource> 
             {
                 private readonly int _maxConcurrent;
 
-                public _(int maxConcurrent, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(int maxConcurrent, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _maxConcurrent = maxConcurrent;
                 }
@@ -43,7 +43,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 private CompositeDisposable _group;
                 private int _activeCount = 0;
 
-                public IDisposable Run(ObservablesMaxConcurrency parent)
+                public void Run(ObservablesMaxConcurrency parent)
                 {
                     _gate = new object();
                     _q = new Queue<IObservable<TSource>>();
@@ -55,7 +55,7 @@ namespace System.Reactive.Linq.ObservableImpl
                     _sourceSubscription.Disposable = parent._sources.SubscribeSafe(this);
                     _group.Add(_sourceSubscription);
 
-                    return _group;
+                    SetUpstream(_group);
                 }
 
                 public override void OnNext(IObservable<TSource> value)
@@ -161,14 +161,14 @@ namespace System.Reactive.Linq.ObservableImpl
                 _sources = sources;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : Sink<IObservable<TSource>, TSource> 
             {
-                public _(IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<TSource> observer)
+                    : base(observer)
                 {
                 }
 
@@ -177,7 +177,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 private CompositeDisposable _group;
                 private SingleAssignmentDisposable _sourceSubscription;
 
-                public IDisposable Run(Observables parent)
+                public void Run(Observables parent)
                 {
                     _gate = new object();
                     _isStopped = false;
@@ -187,7 +187,7 @@ namespace System.Reactive.Linq.ObservableImpl
                     _group.Add(_sourceSubscription);
                     _sourceSubscription.Disposable = parent._sources.SubscribeSafe(this);
 
-                    return _group;
+                    SetUpstream(_group);
                 }
 
                 public override void OnNext(IObservable<TSource> value)
@@ -284,26 +284,26 @@ namespace System.Reactive.Linq.ObservableImpl
                 _sources = sources;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : Sink<Task<TSource>, TSource> 
             {
-                public _(IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<TSource> observer)
+                    : base(observer)
                 {
                 }
 
                 private object _gate;
                 private volatile int _count;
 
-                public IDisposable Run(Tasks parent)
+                public void Run(Tasks parent)
                 {
                     _gate = new object();
                     _count = 1;
 
-                    return parent._sources.SubscribeSafe(this);
+                    SetUpstream(parent._sources.SubscribeSafe(this));
                 }
 
                 public override void OnNext(Task<TSource> value)

Rx.NET/Source/src/System.Reactive/Linq/Observable/Min.cs

@@ -17,16 +17,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _comparer = comparer;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => default(TSource) == null ? (_)new Null(_comparer, observer, cancel) : new NonNull(_comparer, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => default(TSource) == null ? (_)new Null(_comparer, observer) : new NonNull(_comparer, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal abstract class _ : IdentitySink<TSource>
         {
             protected readonly IComparer<TSource> _comparer;
 
-            public _(IComparer<TSource> comparer, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IComparer<TSource> comparer, IObserver<TSource> observer)
+                : base(observer)
             {
                 _comparer = comparer;
             }
@@ -37,8 +37,8 @@ namespace System.Reactive.Linq.ObservableImpl
             private bool _hasValue;
             private TSource _lastValue;
 
-            public NonNull(IComparer<TSource> comparer, IObserver<TSource> observer, IDisposable cancel)
-                : base(comparer, observer, cancel)
+            public NonNull(IComparer<TSource> comparer, IObserver<TSource> observer)
+                : base(comparer, observer)
             {
                 _hasValue = false;
                 _lastValue = default(TSource);
@@ -95,8 +95,8 @@ namespace System.Reactive.Linq.ObservableImpl
         {
             private TSource _lastValue;
 
-            public Null(IComparer<TSource> comparer, IObserver<TSource> observer, IDisposable cancel)
-                : base(comparer, observer, cancel)
+            public Null(IComparer<TSource> comparer, IObserver<TSource> observer)
+                : base(comparer, observer)
             {
                 _lastValue = default(TSource);
             }
@@ -148,17 +148,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<double> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<double> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<double>
         {
             private bool _hasValue;
             private double _lastValue;
 
-            public _(IObserver<double> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<double> observer)
+                : base(observer)
             {
                 _hasValue = false;
                 _lastValue = default(double);
@@ -204,17 +204,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<float> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<float> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<float>
         {
             private bool _hasValue;
             private float _lastValue;
 
-            public _(IObserver<float> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<float> observer)
+                : base(observer)
             {
                 _hasValue = false;
                 _lastValue = default(float);
@@ -260,17 +260,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<decimal> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<decimal> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<decimal>
         {
             private bool _hasValue;
             private decimal _lastValue;
 
-            public _(IObserver<decimal> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<decimal> observer)
+                : base(observer)
             {
                 _hasValue = false;
                 _lastValue = default(decimal);
@@ -316,17 +316,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<int> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<int> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<int>
         {
             private bool _hasValue;
             private int _lastValue;
 
-            public _(IObserver<int> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<int> observer)
+                : base(observer)
             {
                 _hasValue = false;
                 _lastValue = default(int);
@@ -372,17 +372,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<long> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<long> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<long>
         {
             private bool _hasValue;
             private long _lastValue;
 
-            public _(IObserver<long> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<long> observer)
+                : base(observer)
             {
                 _hasValue = false;
                 _lastValue = default(long);
@@ -428,16 +428,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<double?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<double?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<double?>
         {
             private double? _lastValue;
 
-            public _(IObserver<double?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<double?> observer)
+                : base(observer)
             {
                 _lastValue = default(double?);
             }
@@ -477,16 +477,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<float?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<float?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<float?>
         {
             private float? _lastValue;
 
-            public _(IObserver<float?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<float?> observer)
+                : base(observer)
             {
                 _lastValue = default(float?);
             }
@@ -526,16 +526,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<decimal?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<decimal?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<decimal?>
         {
             private decimal? _lastValue;
 
-            public _(IObserver<decimal?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<decimal?> observer)
+                : base(observer)
             {
                 _lastValue = default(decimal?);
             }
@@ -575,16 +575,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<int?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<int?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<int?>
         {
             private int? _lastValue;
 
-            public _(IObserver<int?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<int?> observer)
+                : base(observer)
             {
                 _lastValue = default(int?);
             }
@@ -624,16 +624,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<long?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<long?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<long?>
         {
             private long? _lastValue;
 
-            public _(IObserver<long?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<long?> observer)
+                : base(observer)
             {
                 _lastValue = default(long?);
             }

Rx.NET/Source/src/System.Reactive/Linq/Observable/MinBy.cs

@@ -19,9 +19,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _comparer = comparer;
         }
 
-        protected override _ CreateSink(IObserver<IList<TSource>> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<IList<TSource>> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, IList<TSource>> 
         {
@@ -30,8 +30,8 @@ namespace System.Reactive.Linq.ObservableImpl
             private TKey _lastKey;
             private List<TSource> _list;
 
-            public _(MinBy<TSource, TKey> parent, IObserver<IList<TSource>> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(MinBy<TSource, TKey> parent, IObserver<IList<TSource>> observer)
+                : base(observer)
             {
                 _parent = parent;
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/Multicast.cs

@@ -20,18 +20,18 @@ namespace System.Reactive.Linq.ObservableImpl
             _selector = selector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : IdentitySink<TResult>
         {
-            public _(IObserver<TResult> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TResult> observer)
+                : base(observer)
             {
             }
 
-            public IDisposable Run(Multicast<TSource, TIntermediate, TResult> parent)
+            public void Run(Multicast<TSource, TIntermediate, TResult> parent)
             {
                 var observable = default(IObservable<TResult>);
                 var connectable = default(IConnectableObservable<TIntermediate>);
@@ -44,13 +44,13 @@ namespace System.Reactive.Linq.ObservableImpl
                 catch (Exception exception)
                 {
                     ForwardOnError(exception);
-                    return Disposable.Empty;
+                    return;
                 }
 
                 var subscription = observable.SubscribeSafe(this);
                 var connection = connectable.Connect();
 
-                return StableCompositeDisposable.Create(subscription, connection);
+                SetUpstream(StableCompositeDisposable.Create(subscription, connection));
             }
         }
     }

Rx.NET/Source/src/System.Reactive/Linq/Observable/OfType.cs

@@ -13,14 +13,14 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, TResult> 
         {
-            public _(IObserver<TResult> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TResult> observer)
+                : base(observer)
             {
             }
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/OnErrorResumeNext.cs

@@ -15,14 +15,14 @@ namespace System.Reactive.Linq.ObservableImpl
             _sources = sources;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_sources);
+        protected override void Run(_ sink) => sink.Run(_sources);
 
         internal sealed class _ : TailRecursiveSink<TSource>
         {
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/Range.cs

@@ -20,32 +20,32 @@ namespace System.Reactive.Linq.ObservableImpl
             _scheduler = scheduler;
         }
 
-        protected override _ CreateSink(IObserver<int> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<int> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_scheduler);
+        protected override void Run(_ sink) => sink.Run(_scheduler);
 
         internal sealed class _ : IdentitySink<int>
         {
             private readonly int _start;
             private readonly int _count;
 
-            public _(Range parent, IObserver<int> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Range parent, IObserver<int> observer)
+                : base(observer)
             {
                 _start = parent._start;
                 _count = parent._count;
             }
 
-            public IDisposable Run(IScheduler scheduler)
+            public void Run(IScheduler scheduler)
             {
                 var longRunning = scheduler.AsLongRunning();
                 if (longRunning != null)
                 {
-                    return longRunning.ScheduleLongRunning(0, Loop);
+                    SetUpstream(longRunning.ScheduleLongRunning(0, Loop));
                 }
                 else
                 {
-                    return scheduler.Schedule(0, LoopRec);
+                    SetUpstream(scheduler.Schedule(0, LoopRec));
                 }
             }
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/RefCount.cs

@@ -23,18 +23,18 @@ namespace System.Reactive.Linq.ObservableImpl
             _connectableSubscription = default(IDisposable);
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : IdentitySink<TSource>
         {
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
 
-            public IDisposable Run(RefCount<TSource> parent)
+            public void Run(RefCount<TSource> parent)
             {
                 var subscription = parent._source.SubscribeSafe(this);
 
@@ -46,7 +46,7 @@ namespace System.Reactive.Linq.ObservableImpl
                     }
                 }
 
-                return Disposable.Create(() =>
+                SetUpstream(Disposable.Create(() =>
                 {
                     subscription.Dispose();
 
@@ -57,7 +57,7 @@ namespace System.Reactive.Linq.ObservableImpl
                             parent._connectableSubscription.Dispose();
                         }
                     }
-                });
+                }));
             }
         }
     }

Rx.NET/Source/src/System.Reactive/Linq/Observable/Repeat.cs

@@ -20,30 +20,30 @@ namespace System.Reactive.Linq.ObservableImpl
                 _scheduler = scheduler;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_value, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(_value, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : IdentitySink<TResult>
             {
                 private readonly TResult _value;
 
-                public _(TResult value, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(TResult value, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _value = value;
                 }
 
-                public IDisposable Run(Forever parent)
+                public void Run(Forever parent)
                 {
                     var longRunning = parent._scheduler.AsLongRunning();
                     if (longRunning != null)
                     {
-                        return longRunning.ScheduleLongRunning(LoopInf);
+                        SetUpstream(longRunning.ScheduleLongRunning(LoopInf));
                     }
                     else
                     {
-                        return parent._scheduler.Schedule(LoopRecInf);
+                        SetUpstream(parent._scheduler.Schedule(LoopRecInf));
                     }
                 }
 
@@ -77,30 +77,30 @@ namespace System.Reactive.Linq.ObservableImpl
                 _repeatCount = repeatCount;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_value, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(_value, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : IdentitySink<TResult>
             {
                 private readonly TResult _value;
 
-                public _(TResult value, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(TResult value, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _value = value;
                 }
 
-                public IDisposable Run(Count parent)
+                public void Run(Count parent)
                 {
                     var longRunning = parent._scheduler.AsLongRunning();
                     if (longRunning != null)
                     {
-                        return longRunning.ScheduleLongRunning(parent._repeatCount, Loop);
+                        SetUpstream(longRunning.ScheduleLongRunning(parent._repeatCount, Loop));
                     }
                     else
                     {
-                        return parent._scheduler.Schedule(parent._repeatCount, LoopRec);
+                        SetUpstream(parent._scheduler.Schedule(parent._repeatCount, LoopRec));
                     }
                 }
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/Return.cs

@@ -18,23 +18,23 @@ namespace System.Reactive.Linq.ObservableImpl
             _scheduler = scheduler;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_value, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_value, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_scheduler);
+        protected override void Run(_ sink) => sink.Run(_scheduler);
 
         internal sealed class _ : IdentitySink<TResult>
         {
             private readonly TResult _value;
 
-            public _(TResult value, IObserver<TResult> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(TResult value, IObserver<TResult> observer)
+                : base(observer)
             {
                 _value = value;
             }
 
-            public IDisposable Run(IScheduler scheduler)
+            public void Run(IScheduler scheduler)
             {
-                return scheduler.ScheduleAction(this, @this => @this.Invoke());
+                SetUpstream(scheduler.ScheduleAction(this, @this => @this.Invoke()));
             }
 
             private void Invoke()

Rx.NET/Source/src/System.Reactive/Linq/Observable/Sample.cs

@@ -18,16 +18,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _sampler = sampler;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : IdentitySink<TSource>
         {
             private readonly object _gate = new object();
 
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
 
@@ -39,7 +39,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private bool _sourceAtEnd;
             private bool _samplerAtEnd;
 
-            public IDisposable Run(Sample<TSource, TSample> parent)
+            public void Run(Sample<TSource, TSample> parent)
             {
                 var sourceSubscription = new SingleAssignmentDisposable();
                 _sourceSubscription = sourceSubscription;
@@ -49,7 +49,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 _samplerSubscription = samplerSubscription;
                 samplerSubscription.Disposable = parent._sampler.SubscribeSafe(new SampleObserver(this));
 
-                return StableCompositeDisposable.Create(_sourceSubscription, _samplerSubscription);
+                SetUpstream(StableCompositeDisposable.Create(_sourceSubscription, _samplerSubscription));
             }
 
             public override void OnNext(TSource value)
@@ -154,16 +154,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _scheduler = scheduler;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : IdentitySink<TSource>
         {
             private object _gate = new object();
 
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
 
@@ -173,16 +173,16 @@ namespace System.Reactive.Linq.ObservableImpl
             private TSource _value;
             private bool _atEnd;
 
-            public IDisposable Run(Sample<TSource> parent)
+            public void Run(Sample<TSource> parent)
             {
                 var sourceSubscription = new SingleAssignmentDisposable();
                 _sourceSubscription = sourceSubscription;
                 sourceSubscription.Disposable = parent._source.SubscribeSafe(this);
 
-                return StableCompositeDisposable.Create(
+                SetUpstream(StableCompositeDisposable.Create(
                     sourceSubscription,
                     parent._scheduler.SchedulePeriodic(parent._interval, Tick)
-                );
+                ));
             }
 
             private void Tick()

Rx.NET/Source/src/System.Reactive/Linq/Observable/Scan.cs

@@ -17,17 +17,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _accumulator = accumulator;
         }
 
-        protected override _ CreateSink(IObserver<TAccumulate> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<TAccumulate> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, TAccumulate> 
         {
             private readonly Func<TAccumulate, TSource, TAccumulate> _accumulator;
             private TAccumulate _accumulation;
 
-            public _(Scan<TSource, TAccumulate> parent, IObserver<TAccumulate> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Scan<TSource, TAccumulate> parent, IObserver<TAccumulate> observer)
+                : base(observer)
             {
                 _accumulator = parent._accumulator;
                 _accumulation = parent._seed;
@@ -61,9 +61,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _accumulator = accumulator;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_accumulator, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(_accumulator, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<TSource>
         {
@@ -71,8 +71,8 @@ namespace System.Reactive.Linq.ObservableImpl
             private TSource _accumulation;
             private bool _hasAccumulation;
 
-            public _(Func<TSource, TSource, TSource> accumulator, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Func<TSource, TSource, TSource> accumulator, IObserver<TSource> observer)
+                : base(observer)
             {
                 _accumulator = accumulator;
                 _accumulation = default(TSource);
@@ -96,6 +96,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 catch (Exception exception)
                 {
                     ForwardOnError(exception);
+
                     return;
                 }
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/Select.cs

@@ -17,16 +17,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 _selector = selector;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_selector, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(_selector, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, TResult> 
             {
                 private readonly Func<TSource, TResult> _selector;
 
-                public _(Func<TSource, TResult> selector, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, TResult> selector, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _selector = selector;
                 }
@@ -60,17 +60,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _selector = selector;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_selector, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(_selector, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, TResult> 
             {
                 private readonly Func<TSource, int, TResult> _selector;
                 private int _index;
 
-                public _(Func<TSource, int, TResult> selector, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, int, TResult> selector, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _selector = selector;
                     _index = 0;

Rx.NET/Source/src/System.Reactive/Linq/Observable/SelectMany.cs

@@ -24,9 +24,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _resultSelector = resultSelector;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(_source);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, TResult> 
             {
@@ -37,8 +37,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private readonly Func<TSource, IObservable<TCollection>> _collectionSelector;
                 private readonly Func<TSource, TCollection, TResult> _resultSelector;
 
-                public _(ObservableSelector parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(ObservableSelector parent, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _collectionSelector = parent._collectionSelector;
                     _resultSelector = parent._resultSelector;
@@ -48,13 +48,13 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private bool _isStopped;
 
-                public IDisposable Run(IObservable<TSource> source)
+                public void Run(IObservable<TSource> source)
                 {
                     _isStopped = false;
 
                     _sourceSubscription.Disposable = source.SubscribeSafe(this);
 
-                    return _group;
+                    SetUpstream(_group);
                 }
 
                 public override void OnNext(TSource value)
@@ -187,9 +187,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _resultSelector = resultSelector;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(_source);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, TResult> 
             {
@@ -200,8 +200,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private readonly Func<TSource, int, IObservable<TCollection>> _collectionSelector;
                 private readonly Func<TSource, int, TCollection, int, TResult> _resultSelector;
 
-                public _(ObservableSelectorIndexed parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(ObservableSelectorIndexed parent, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _collectionSelector = parent._collectionSelector;
                     _resultSelector = parent._resultSelector;
@@ -212,13 +212,13 @@ namespace System.Reactive.Linq.ObservableImpl
                 private bool _isStopped;
                 private int _index;
 
-                public IDisposable Run(IObservable<TSource> source)
+                public void Run(IObservable<TSource> source)
                 {
                     _isStopped = false;
 
                     _sourceSubscription.Disposable = source.SubscribeSafe(this);
 
-                    return _group;
+                    SetUpstream(_group);
                 }
 
                 public override void OnNext(TSource value)
@@ -356,17 +356,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _resultSelector = resultSelector;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, TResult> 
             {
                 private readonly Func<TSource, IEnumerable<TCollection>> _collectionSelector;
                 private readonly Func<TSource, TCollection, TResult> _resultSelector;
 
-                public _(EnumerableSelector parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(EnumerableSelector parent, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _collectionSelector = parent._collectionSelector;
                     _resultSelector = parent._resultSelector;
@@ -442,17 +442,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _resultSelector = resultSelector;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, TResult> 
             {
                 private readonly Func<TSource, int, IEnumerable<TCollection>> _collectionSelector;
                 private readonly Func<TSource, int, TCollection, int, TResult> _resultSelector;
 
-                public _(EnumerableSelectorIndexed parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(EnumerableSelectorIndexed parent, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _collectionSelector = parent._collectionSelector;
                     _resultSelector = parent._resultSelector;
@@ -533,9 +533,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _resultSelector = resultSelector;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(_source);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, TResult> 
             {
@@ -545,8 +545,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private readonly Func<TSource, CancellationToken, Task<TCollection>> _collectionSelector;
                 private readonly Func<TSource, TCollection, TResult> _resultSelector;
 
-                public _(TaskSelector parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(TaskSelector parent, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _collectionSelector = parent._collectionSelector;
                     _resultSelector = parent._resultSelector;
@@ -554,11 +554,11 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private volatile int _count;
 
-                public IDisposable Run(IObservable<TSource> source)
+                public void Run(IObservable<TSource> source)
                 {
                     _count = 1;
 
-                    return StableCompositeDisposable.Create(source.SubscribeSafe(this), _cancel);
+                    SetUpstream(StableCompositeDisposable.Create(source.SubscribeSafe(this), _cancel));
                 }
 
                 public override void OnNext(TSource value)
@@ -680,9 +680,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _resultSelector = resultSelector;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(_source);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, TResult> 
             {
@@ -692,8 +692,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private readonly Func<TSource, int, CancellationToken, Task<TCollection>> _collectionSelector;
                 private readonly Func<TSource, int, TCollection, TResult> _resultSelector;
 
-                public _(TaskSelectorIndexed parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(TaskSelectorIndexed parent, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _collectionSelector = parent._collectionSelector;
                     _resultSelector = parent._resultSelector;
@@ -702,11 +702,11 @@ namespace System.Reactive.Linq.ObservableImpl
                 private volatile int _count;
                 private int _index;
 
-                public IDisposable Run(IObservable<TSource> source)
+                public void Run(IObservable<TSource> source)
                 {
                     _count = 1;
 
-                    return StableCompositeDisposable.Create(source.SubscribeSafe(this), _cancel);
+                    SetUpstream(StableCompositeDisposable.Create(source.SubscribeSafe(this), _cancel));
                 }
 
                 public override void OnNext(TSource value)
@@ -831,9 +831,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _selector = selector;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(_source);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal class _ : Sink<TSource, TResult> 
             {
@@ -843,8 +843,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private readonly Func<TSource, IObservable<TResult>> _selector;
 
-                public _(ObservableSelector parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(ObservableSelector parent, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _selector = parent._selector;
 
@@ -853,13 +853,13 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private bool _isStopped;
 
-                public IDisposable Run(IObservable<TSource> source)
+                public void Run(IObservable<TSource> source)
                 {
                     _isStopped = false;
 
                     _sourceSubscription.Disposable = source.SubscribeSafe(this);
 
-                    return _group;
+                    SetUpstream(_group);
                 }
 
                 public override void OnNext(TSource value)
@@ -984,15 +984,15 @@ namespace System.Reactive.Linq.ObservableImpl
                 _selectorOnCompleted = selectorOnCompleted;
             }
 
-            protected override ObservableSelector._ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override ObservableSelector._ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
             new internal sealed class _ : ObservableSelector._
             {
                 private readonly Func<Exception, IObservable<TResult>> _selectorOnError;
                 private readonly Func<IObservable<TResult>> _selectorOnCompleted;
 
-                public _(ObservableSelectors parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(parent, observer, cancel)
+                public _(ObservableSelectors parent, IObserver<TResult> observer)
+                    : base(parent, observer)
                 {
                     _selectorOnError = parent._selectorOnError;
                     _selectorOnCompleted = parent._selectorOnCompleted;
@@ -1065,9 +1065,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _selector = selector;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(_source);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal class _ : Sink<TSource, TResult> 
             {
@@ -1077,8 +1077,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 protected readonly Func<TSource, int, IObservable<TResult>> _selector;
 
-                public _(ObservableSelectorIndexed parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(ObservableSelectorIndexed parent, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _selector = parent._selector;
 
@@ -1088,13 +1088,13 @@ namespace System.Reactive.Linq.ObservableImpl
                 private bool _isStopped;
                 private int _index;
 
-                public IDisposable Run(IObservable<TSource> source)
+                public void Run(IObservable<TSource> source)
                 {
                     _isStopped = false;
 
                     _sourceSubscription.Disposable = source.SubscribeSafe(this);
 
-                    return _group;
+                    SetUpstream(_group);
                 }
 
                 public override void OnNext(TSource value)
@@ -1219,7 +1219,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 _selectorOnCompleted = selectorOnCompleted;
             }
 
-            protected override ObservableSelectorIndexed._ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override ObservableSelectorIndexed._ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
             new internal sealed class _ : ObservableSelectorIndexed._
             {
@@ -1230,8 +1230,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private readonly Func<Exception, IObservable<TResult>> _selectorOnError;
                 private readonly Func<IObservable<TResult>> _selectorOnCompleted;
 
-                public _(ObservableSelectorsIndexed parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(parent, observer, cancel)
+                public _(ObservableSelectorsIndexed parent, IObserver<TResult> observer)
+                    : base(parent, observer)
                 {
                     _selectorOnError = parent._selectorOnError;
                     _selectorOnCompleted = parent._selectorOnCompleted;
@@ -1306,16 +1306,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 _selector = selector;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, TResult> 
             {
                 private readonly Func<TSource, IEnumerable<TResult>> _selector;
 
-                public _(EnumerableSelector parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(EnumerableSelector parent, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _selector = parent._selector;
                 }
@@ -1388,16 +1388,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 _selector = selector;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, TResult> 
             {
                 private readonly Func<TSource, int, IEnumerable<TResult>> _selector;
 
-                public _(EnumerableSelectorIndexed parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(EnumerableSelectorIndexed parent, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _selector = parent._selector;
                 }
@@ -1472,9 +1472,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _selector = selector;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(_source);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, TResult> 
             {
@@ -1483,19 +1483,19 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private readonly Func<TSource, CancellationToken, Task<TResult>> _selector;
 
-                public _(TaskSelector parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(TaskSelector parent, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _selector = parent._selector;
                 }
 
                 private volatile int _count;
 
-                public IDisposable Run(IObservable<TSource> source)
+                public void Run(IObservable<TSource> source)
                 {
                     _count = 1;
 
-                    return StableCompositeDisposable.Create(source.SubscribeSafe(this), _cancel);
+                    SetUpstream(StableCompositeDisposable.Create(source.SubscribeSafe(this), _cancel));
                 }
 
                 public override void OnNext(TSource value)
@@ -1592,9 +1592,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _selector = selector;
             }
 
-            protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TResult> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(_source);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, TResult> 
             {
@@ -1603,8 +1603,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private readonly Func<TSource, int, CancellationToken, Task<TResult>> _selector;
 
-                public _(TaskSelectorIndexed parent, IObserver<TResult> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(TaskSelectorIndexed parent, IObserver<TResult> observer)
+                    : base(observer)
                 {
                     _selector = parent._selector;
                 }
@@ -1612,11 +1612,11 @@ namespace System.Reactive.Linq.ObservableImpl
                 private volatile int _count;
                 private int _index;
 
-                public IDisposable Run(IObservable<TSource> source)
+                public void Run(IObservable<TSource> source)
                 {
                     _count = 1;
 
-                    return StableCompositeDisposable.Create(source.SubscribeSafe(this), _cancel);
+                    SetUpstream(StableCompositeDisposable.Create(source.SubscribeSafe(this), _cancel));
                 }
 
                 public override void OnNext(TSource value)

Rx.NET/Source/src/System.Reactive/Linq/Observable/SequenceEqual.cs

@@ -22,16 +22,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 _comparer = comparer;
             }
 
-            protected override _ CreateSink(IObserver<bool> observer, IDisposable cancel) => new _(_comparer, observer, cancel);
+            protected override _ CreateSink(IObserver<bool> observer) => new _(_comparer, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : IdentitySink<bool>
             {
                 private readonly IEqualityComparer<TSource> _comparer;
 
-                public _(IEqualityComparer<TSource> comparer, IObserver<bool> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IEqualityComparer<TSource> comparer, IObserver<bool> observer)
+                    : base(observer)
                 {
                     _comparer = comparer;
                 }
@@ -42,7 +42,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 private Queue<TSource> _ql;
                 private Queue<TSource> _qr;
 
-                public IDisposable Run(Observable parent)
+                public void Run(Observable parent)
                 {
                     _gate = new object();
                     _donel = false;
@@ -50,11 +50,11 @@ namespace System.Reactive.Linq.ObservableImpl
                     _ql = new Queue<TSource>();
                     _qr = new Queue<TSource>();
 
-                    return StableCompositeDisposable.Create
+                    SetUpstream(StableCompositeDisposable.Create
                     (
                         parent._first.SubscribeSafe(new FirstObserver(this)),
                         parent._second.SubscribeSafe(new SecondObserver(this))
-                    );
+                    ));
                 }
 
                 private sealed class FirstObserver : IObserver<TSource>
@@ -216,23 +216,23 @@ namespace System.Reactive.Linq.ObservableImpl
                 _comparer = comparer;
             }
 
-            protected override _ CreateSink(IObserver<bool> observer, IDisposable cancel) => new _(_comparer, observer, cancel);
+            protected override _ CreateSink(IObserver<bool> observer) => new _(_comparer, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : Sink<TSource, bool> 
             {
                 private readonly IEqualityComparer<TSource> _comparer;
 
-                public _(IEqualityComparer<TSource> comparer, IObserver<bool> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IEqualityComparer<TSource> comparer, IObserver<bool> observer)
+                    : base(observer)
                 {
                     _comparer = comparer;
                 }
 
                 private IEnumerator<TSource> _enumerator;
 
-                public IDisposable Run(Enumerable parent)
+                public void Run(Enumerable parent)
                 {
                     //
                     // Notice the evaluation order of obtaining the enumerator and subscribing to the
@@ -248,13 +248,14 @@ namespace System.Reactive.Linq.ObservableImpl
                     catch (Exception exception)
                     {
                         ForwardOnError(exception);
-                        return Disposable.Empty;
+
+                        return;
                     }
 
-                    return StableCompositeDisposable.Create(
+                    SetUpstream(StableCompositeDisposable.Create(
                         parent._first.SubscribeSafe(this),
                         _enumerator
-                    );
+                    ));
                 }
 
                 public override void OnNext(TSource value)

Rx.NET/Source/src/System.Reactive/Linq/Observable/SingleAsync.cs

@@ -15,17 +15,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _source = source;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private TSource _value;
                 private bool _seenValue;
 
-                public _(IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _value = default(TSource);
                     _seenValue = false;
@@ -69,9 +69,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _predicate = predicate;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_predicate, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
@@ -79,8 +79,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private TSource _value;
                 private bool _seenValue;
 
-                public _(Func<TSource, bool> predicate, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, bool> predicate, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _predicate = predicate;
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/SingleOrDefaultAsync.cs

@@ -15,17 +15,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _source = source;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private TSource _value;
                 private bool _seenValue;
 
-                public _(IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _value = default(TSource);
                     _seenValue = false;
@@ -62,9 +62,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _predicate = predicate;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_predicate, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
@@ -72,8 +72,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private TSource _value;
                 private bool _seenValue;
 
-                public _(Func<TSource, bool> predicate, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, bool> predicate, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _predicate = predicate;
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/Skip.cs

@@ -32,16 +32,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 return new Count(_source, _count + count);
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_count, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_count, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private int _remaining;
 
-                public _(int count, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(int count, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _remaining = count;
                 }
@@ -86,24 +86,24 @@ namespace System.Reactive.Linq.ObservableImpl
                     return new Time(_source, duration, _scheduler);
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private volatile bool _open;
 
-                public _(IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<TSource> observer)
+                    : base(observer)
                 {
                 }
 
-                public IDisposable Run(Time parent)
+                public void Run(Time parent)
                 {
                     var t = parent._scheduler.Schedule(this, parent._duration, (_, state) => state.Tick());
                     var d = parent._source.SubscribeSafe(this);
-                    return StableCompositeDisposable.Create(t, d);
+                    SetUpstream(StableCompositeDisposable.Create(t, d));
                 }
 
                 private IDisposable Tick()

Rx.NET/Source/src/System.Reactive/Linq/Observable/SkipLast.cs

@@ -20,17 +20,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _count = count;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_count, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_count, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private int _count;
                 private Queue<TSource> _queue;
 
-                public _(int count, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(int count, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _count = count;
                     _queue = new Queue<TSource>();
@@ -58,17 +58,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _scheduler = scheduler;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_duration, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_duration, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private readonly TimeSpan _duration;
                 private Queue<System.Reactive.TimeInterval<TSource>> _queue;
 
-                public _(TimeSpan duration, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(TimeSpan duration, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _duration = duration;
                     _queue = new Queue<System.Reactive.TimeInterval<TSource>>();
@@ -76,11 +76,11 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private IStopwatch _watch;
 
-                public IDisposable Run(Time parent)
+                public void Run(Time parent)
                 {
                     _watch = parent._scheduler.StartStopwatch();
 
-                    return parent._source.SubscribeSafe(this);
+                    SetUpstream(parent._source.SubscribeSafe(this));
                 }
 
                 public override void OnNext(TSource value)

Rx.NET/Source/src/System.Reactive/Linq/Observable/SkipUntil.cs

@@ -19,9 +19,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _other = other;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : IdentitySink<TSource>
         {
@@ -31,17 +31,15 @@ namespace System.Reactive.Linq.ObservableImpl
             int _halfSerializer;
             Exception _error;
 
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
 
-            public IDisposable Run(SkipUntil<TSource, TOther> parent)
+            public void Run(SkipUntil<TSource, TOther> parent)
             {
                 Disposable.TrySetSingle(ref _otherDisposable, parent._other.Subscribe(new OtherObserver(this)));
                 Disposable.TrySetSingle(ref _mainDisposable, parent._source.Subscribe(this));
-
-                return this;
             }
 
             protected override void Dispose(bool disposing)
@@ -161,24 +159,24 @@ namespace System.Reactive.Linq.ObservableImpl
                 return new SkipUntil<TSource>(_source, startTime, _scheduler);
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : IdentitySink<TSource>
         {
             private volatile bool _open;
 
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
 
-            public IDisposable Run(SkipUntil<TSource> parent)
+            public void Run(SkipUntil<TSource> parent)
             {
                 var t = parent._scheduler.Schedule(this, parent._startTime, (_, state) => state.Tick());
                 var d = parent._source.SubscribeSafe(this);
-                return StableCompositeDisposable.Create(t, d);
+                SetUpstream(StableCompositeDisposable.Create(t, d));
             }
 
             private IDisposable Tick()

Rx.NET/Source/src/System.Reactive/Linq/Observable/SkipWhile.cs

@@ -17,16 +17,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 _predicate = predicate;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_predicate, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private Func<TSource, bool> _predicate;
 
-                public _(Func<TSource, bool> predicate, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, bool> predicate, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _predicate = predicate;
                 }
@@ -72,17 +72,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _predicate = predicate;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_predicate, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private Func<TSource, int, bool> _predicate;
                 private int _index;
 
-                public _(Func<TSource, int, bool> predicate, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, int, bool> predicate, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _predicate = predicate;
                     _index = 0;

Rx.NET/Source/src/System.Reactive/Linq/Observable/Sum.cs

@@ -13,16 +13,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<double> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<double> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<double>
         {
             private double _sum;
 
-            public _(IObserver<double> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<double> observer)
+                : base(observer)
             {
                 _sum = 0.0;
             }
@@ -49,16 +49,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<float> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<float> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<float>
         {
             private double _sum; // This is what LINQ to Objects does!
 
-            public _(IObserver<float> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<float> observer)
+                : base(observer)
             {
                 _sum = 0.0; // This is what LINQ to Objects does!
             }
@@ -85,16 +85,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<decimal> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<decimal> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<decimal>
         {
             private decimal _sum;
 
-            public _(IObserver<decimal> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<decimal> observer)
+                : base(observer)
             {
                 _sum = 0M;
             }
@@ -121,16 +121,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<int> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<int> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<int>
         {
             private int _sum;
 
-            public _(IObserver<int> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<int> observer)
+                : base(observer)
             {
                 _sum = 0;
             }
@@ -167,16 +167,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<long> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<long> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<long>
         {
             private long _sum;
 
-            public _(IObserver<long> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<long> observer)
+                : base(observer)
             {
                 _sum = 0L;
             }
@@ -213,16 +213,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<double?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<double?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<double?>
         {
             private double _sum;
 
-            public _(IObserver<double?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<double?> observer)
+                : base(observer)
             {
                 _sum = 0.0;
             }
@@ -250,16 +250,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<float?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<float?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<float?>
         {
             private double _sum; // This is what LINQ to Objects does!
 
-            public _(IObserver<float?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<float?> observer)
+                : base(observer)
             {
                 _sum = 0.0; // This is what LINQ to Objects does!
             }
@@ -287,16 +287,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<decimal?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<decimal?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<decimal?>
         {
             private decimal _sum;
 
-            public _(IObserver<decimal?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<decimal?> observer)
+                : base(observer)
             {
                 _sum = 0M;
             }
@@ -324,16 +324,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<int?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<int?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<int?>
         {
             private int _sum;
 
-            public _(IObserver<int?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<int?> observer)
+                : base(observer)
             {
                 _sum = 0;
             }
@@ -371,16 +371,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<long?> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<long?> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<long?>
         {
             private long _sum;
 
-            public _(IObserver<long?> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<long?> observer)
+                : base(observer)
             {
                 _sum = 0L;
             }

Rx.NET/Source/src/System.Reactive/Linq/Observable/Switch.cs

@@ -15,16 +15,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _sources = sources;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : Sink<IObservable<TSource>, TSource> 
         {
             private readonly object _gate = new object();
 
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
 
@@ -34,7 +34,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private ulong _latest;
             private bool _hasLatest;
 
-            public IDisposable Run(Switch<TSource> parent)
+            public void Run(Switch<TSource> parent)
             {
                 _innerSubscription = new SerialDisposable();
                 _isStopped = false;
@@ -45,7 +45,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 _subscription = subscription;
                 subscription.Disposable = parent._sources.SubscribeSafe(this);
 
-                return StableCompositeDisposable.Create(_subscription, _innerSubscription);
+                SetUpstream(StableCompositeDisposable.Create(_subscription, _innerSubscription));
             }
 
             public override void OnNext(IObservable<TSource> value)

Rx.NET/Source/src/System.Reactive/Linq/Observable/Synchronize.cs

@@ -20,16 +20,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_gate, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(_gate, observer);
 
-        protected override IDisposable Run(_ sink) => _source.Subscribe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<TSource>
         {
             private readonly object _gate;
 
-            public _(object gate, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(object gate, IObserver<TSource> observer)
+                : base(observer)
             {
                 _gate = gate ?? new object();
             }

Rx.NET/Source/src/System.Reactive/Linq/Observable/Take.cs

@@ -35,16 +35,16 @@ namespace System.Reactive.Linq.ObservableImpl
                     return new Count(_source, count);
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_count, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_count, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private int _remaining;
 
-                public _(int count, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(int count, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _remaining = count;
                 }
@@ -95,26 +95,26 @@ namespace System.Reactive.Linq.ObservableImpl
                     return new Time(_source, duration, _scheduler);
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : IdentitySink<TSource> 
             {
-                public _(IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<TSource> observer)
+                    : base(observer)
                 {
                 }
 
                 private object _gate;
 
-                public IDisposable Run(Time parent)
+                public void Run(Time parent)
                 {
                     _gate = new object();
 
                     var t = parent._scheduler.Schedule(this, parent._duration, (_, state) => state.Tick());
                     var d = parent._source.SubscribeSafe(this);
-                    return StableCompositeDisposable.Create(t, d);
+                    SetUpstream(StableCompositeDisposable.Create(t, d));
                 }
 
                 private IDisposable Tick()

Rx.NET/Source/src/System.Reactive/Linq/Observable/TakeLast.cs

@@ -23,9 +23,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _loopScheduler = loopScheduler;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run();
+            protected override void Run(_ sink) => sink.Run();
 
             internal sealed class _ : IdentitySink<TSource>
             {
@@ -34,8 +34,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private readonly Count _parent;
                 private Queue<TSource> _queue;
 
-                public _(Count parent, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Count parent, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _parent = parent;
                     _queue = new Queue<TSource>();
@@ -44,14 +44,14 @@ namespace System.Reactive.Linq.ObservableImpl
                 private SingleAssignmentDisposable _subscription;
                 private SingleAssignmentDisposable _loop;
 
-                public IDisposable Run()
+                public void Run()
                 {
                     _subscription = new SingleAssignmentDisposable();
                     _loop = new SingleAssignmentDisposable();
 
                     _subscription.Disposable = _parent._source.SubscribeSafe(this);
 
-                    return StableCompositeDisposable.Create(_subscription, _loop);
+                    SetUpstream(StableCompositeDisposable.Create(_subscription, _loop));
                 }
 
                 public override void OnNext(TSource value)
@@ -122,9 +122,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _loopScheduler = loopScheduler;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run();
+            protected override void Run(_ sink) => sink.Run();
 
             internal sealed class _ : IdentitySink<TSource>
             {
@@ -133,8 +133,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private readonly Time _parent;
                 private Queue<System.Reactive.TimeInterval<TSource>> _queue;
 
-                public _(Time parent, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Time parent, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _parent = parent;
                     _queue = new Queue<System.Reactive.TimeInterval<TSource>>();
@@ -144,7 +144,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 private SingleAssignmentDisposable _loop;
                 private IStopwatch _watch;
 
-                public IDisposable Run()
+                public void Run()
                 {
                     _subscription = new SingleAssignmentDisposable();
                     _loop = new SingleAssignmentDisposable();
@@ -152,7 +152,7 @@ namespace System.Reactive.Linq.ObservableImpl
                     _watch = _parent._scheduler.StartStopwatch();
                     _subscription.Disposable = _parent._source.SubscribeSafe(this);
 
-                    return StableCompositeDisposable.Create(_subscription, _loop);
+                    SetUpstream(StableCompositeDisposable.Create(_subscription, _loop));
                 }
 
                 public override void OnNext(TSource value)

Rx.NET/Source/src/System.Reactive/Linq/Observable/TakeLastBuffer.cs

@@ -20,17 +20,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _count = count;
             }
 
-            protected override _ CreateSink(IObserver<IList<TSource>> observer, IDisposable cancel) => new _(_count, observer, cancel);
+            protected override _ CreateSink(IObserver<IList<TSource>> observer) => new _(_count, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, IList<TSource>> 
             {
                 private readonly int _count;
                 private Queue<TSource> _queue;
 
-                public _(int count, IObserver<IList<TSource>> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(int count, IObserver<IList<TSource>> observer)
+                    : base(observer)
                 {
                     _count = count;
                     _queue = new Queue<TSource>();
@@ -68,17 +68,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _scheduler = scheduler;
             }
 
-            protected override _ CreateSink(IObserver<IList<TSource>> observer, IDisposable cancel) => new _(_duration, observer, cancel);
+            protected override _ CreateSink(IObserver<IList<TSource>> observer) => new _(_duration, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : Sink<TSource, IList<TSource>> 
             {
                 private readonly TimeSpan _duration;
                 private Queue<System.Reactive.TimeInterval<TSource>> _queue;
 
-                public _(TimeSpan duration, IObserver<IList<TSource>> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(TimeSpan duration, IObserver<IList<TSource>> observer)
+                    : base(observer)
                 {
                     _duration = duration;
                     _queue = new Queue<System.Reactive.TimeInterval<TSource>>();
@@ -86,11 +86,11 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private IStopwatch _watch;
 
-                public IDisposable Run(Time parent)
+                public void Run(Time parent)
                 {
                     _watch = parent._scheduler.StartStopwatch();
 
-                    return parent._source.SubscribeSafe(this);
+                    SetUpstream(parent._source.SubscribeSafe(this));
                 }
 
                 public override void OnNext(TSource value)

Rx.NET/Source/src/System.Reactive/Linq/Observable/TakeUntil.cs

@@ -19,9 +19,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _other = other;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : IdentitySink<TSource>
         {
@@ -30,17 +30,15 @@ namespace System.Reactive.Linq.ObservableImpl
             private int _halfSerializer;
             private Exception _error;
 
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
 
-            public IDisposable Run(TakeUntil<TSource, TOther> parent)
+            public void Run(TakeUntil<TSource, TOther> parent)
             {
                 Disposable.SetSingle(ref _otherDisposable, parent._other.Subscribe(new OtherObserver(this)));
                 Disposable.SetSingle(ref _mainDisposable, parent._source.Subscribe(this));
-
-                return this;
             }
 
             protected override void Dispose(bool disposing)
@@ -136,24 +134,24 @@ namespace System.Reactive.Linq.ObservableImpl
                 return new TakeUntil<TSource>(_source, endTime, _scheduler);
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : IdentitySink<TSource>
         {
             private readonly object _gate = new object();
 
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
 
-            public IDisposable Run(TakeUntil<TSource> parent)
+            public void Run(TakeUntil<TSource> parent)
             {
                 var t = parent._scheduler.Schedule(this, parent._endTime, (_, state) => state.Tick());
                 var d = parent._source.SubscribeSafe(this);
-                return StableCompositeDisposable.Create(t, d);
+                SetUpstream(StableCompositeDisposable.Create(t, d));
             }
 
             private IDisposable Tick()

Rx.NET/Source/src/System.Reactive/Linq/Observable/TakeWhile.cs

@@ -17,17 +17,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _predicate = predicate;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_predicate, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private readonly Func<TSource, bool> _predicate;
                 private bool _running;
 
-                public _(Func<TSource, bool> predicate, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, bool> predicate, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _predicate = predicate;
                     _running = true;
@@ -71,9 +71,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _predicate = predicate;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_predicate, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
@@ -81,8 +81,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private bool _running;
                 private int _index;
 
-                public _(Func<TSource, int, bool> predicate, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, int, bool> predicate, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _predicate = predicate;
                     _running = true;

Rx.NET/Source/src/System.Reactive/Linq/Observable/Throttle.cs

@@ -20,17 +20,17 @@ namespace System.Reactive.Linq.ObservableImpl
             _scheduler = scheduler;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_source);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : IdentitySink<TSource>
         {
             private readonly TimeSpan _dueTime;
             private readonly IScheduler _scheduler;
 
-            public _(Throttle<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Throttle<TSource> parent, IObserver<TSource> observer)
+                : base(observer)
             {
                 _dueTime = parent._dueTime;
                 _scheduler = parent._scheduler;
@@ -42,7 +42,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private SerialDisposable _cancelable;
             private ulong _id;
 
-            public IDisposable Run(IObservable<TSource> source)
+            public void Run(IObservable<TSource> source)
             {
                 _gate = new object();
                 _value = default(TSource);
@@ -52,7 +52,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 var subscription = source.SubscribeSafe(this);
 
-                return StableCompositeDisposable.Create(subscription, _cancelable);
+                SetUpstream(StableCompositeDisposable.Create(subscription, _cancelable));
             }
 
             public override void OnNext(TSource value)
@@ -124,16 +124,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _throttleSelector = throttleSelector;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : IdentitySink<TSource>
         {
             private readonly Func<TSource, IObservable<TThrottle>> _throttleSelector;
 
-            public _(Throttle<TSource, TThrottle> parent, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Throttle<TSource, TThrottle> parent, IObserver<TSource> observer)
+                : base(observer)
             {
                 _throttleSelector = parent._throttleSelector;
             }
@@ -144,7 +144,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private SerialDisposable _cancelable;
             private ulong _id;
 
-            public IDisposable Run(Throttle<TSource, TThrottle> parent)
+            public void Run(Throttle<TSource, TThrottle> parent)
             {
                 _gate = new object();
                 _value = default(TSource);
@@ -154,7 +154,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 var subscription = parent._source.SubscribeSafe(this);
 
-                return StableCompositeDisposable.Create(subscription, _cancelable);
+                SetUpstream(StableCompositeDisposable.Create(subscription, _cancelable));
             }
 
             public override void OnNext(TSource value)

Rx.NET/Source/src/System.Reactive/Linq/Observable/Throw.cs

@@ -18,25 +18,24 @@ namespace System.Reactive.Linq.ObservableImpl
             _scheduler = scheduler;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_exception, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_exception, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_scheduler);
+        protected override void Run(_ sink) => sink.Run(_scheduler);
 
         internal sealed class _ : IdentitySink<TResult>
         {
             private readonly Exception _exception;
 
-            public _(Exception exception, IObserver<TResult> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Exception exception, IObserver<TResult> observer)
+                : base(observer)
             {
                 _exception = exception;
             }
 
-            public IDisposable Run(IScheduler scheduler)
+            public void Run(IScheduler scheduler)
             {
-                return scheduler.ScheduleAction(this, @this => @this.ForwardOnError(@this._exception));
+                SetUpstream(scheduler.ScheduleAction(this, @this => @this.ForwardOnError(@this._exception)));
             }
-
         }
     }
 }

Rx.NET/Source/src/System.Reactive/Linq/Observable/TimeInterval.cs

@@ -17,26 +17,26 @@ namespace System.Reactive.Linq.ObservableImpl
             _scheduler = scheduler;
         }
 
-        protected override _ CreateSink(IObserver<System.Reactive.TimeInterval<TSource>> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<Reactive.TimeInterval<TSource>> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : Sink<TSource, System.Reactive.TimeInterval<TSource>> 
         {
-            public _(IObserver<System.Reactive.TimeInterval<TSource>> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<System.Reactive.TimeInterval<TSource>> observer)
+                : base(observer)
             {
             }
 
             private IStopwatch _watch;
             private TimeSpan _last;
 
-            public IDisposable Run(TimeInterval<TSource> parent)
+            public void Run(TimeInterval<TSource> parent)
             {
                 _watch = parent._scheduler.StartStopwatch();
                 _last = TimeSpan.Zero;
 
-                return parent._source.Subscribe(this);
+                SetUpstream(parent._source.Subscribe(this));
             }
 
             public override void OnNext(TSource value)

Rx.NET/Source/src/System.Reactive/Linq/Observable/Timeout.cs

@@ -25,9 +25,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _scheduler = scheduler;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(_source);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
@@ -41,22 +41,19 @@ namespace System.Reactive.Linq.ObservableImpl
                 IDisposable _otherDisposable;
                 IDisposable _timerDisposable;
 
-                public _(Relative parent, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Relative parent, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _dueTime = parent._dueTime;
                     _other = parent._other;
                     _scheduler = parent._scheduler;
                 }
 
-                public IDisposable Run(IObservable<TSource> source)
+                public void Run(IObservable<TSource> source)
                 {
-
                     CreateTimer(0L);
 
                     Disposable.SetSingle(ref _mainDisposable, source.SubscribeSafe(this));
-
-                    return this;
                 }
 
                 protected override void Dispose(bool disposing)
@@ -146,9 +143,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _scheduler = scheduler;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_other, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_other, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : IdentitySink<TSource>
             {
@@ -157,15 +154,15 @@ namespace System.Reactive.Linq.ObservableImpl
                 private readonly object _gate = new object();
                 private readonly SerialDisposable _subscription = new SerialDisposable();
 
-                public _(IObservable<TSource> other, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObservable<TSource> other, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _other = other;
                 }
 
                 private bool _switched;
 
-                public IDisposable Run(Absolute parent)
+                public void Run(Absolute parent)
                 {
                     var original = new SingleAssignmentDisposable();
 
@@ -177,7 +174,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                     original.Disposable = parent._source.SubscribeSafe(this);
 
-                    return StableCompositeDisposable.Create(_subscription, timer);
+                    SetUpstream(StableCompositeDisposable.Create(_subscription, timer));
                 }
 
                 private IDisposable Timeout()
@@ -255,9 +252,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _other = other;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : IdentitySink<TSource>
         {
@@ -268,8 +265,8 @@ namespace System.Reactive.Linq.ObservableImpl
             private readonly SerialDisposable _subscription = new SerialDisposable();
             private readonly SerialDisposable _timer = new SerialDisposable();
 
-            public _(Timeout<TSource, TTimeout> parent, IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Timeout<TSource, TTimeout> parent, IObserver<TSource> observer)
+                : base(observer)
             {
                 _timeoutSelector = parent._timeoutSelector;
                 _other = parent._other;
@@ -278,7 +275,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private ulong _id;
             private bool _switched;
 
-            public IDisposable Run(Timeout<TSource, TTimeout> parent)
+            public void Run(Timeout<TSource, TTimeout> parent)
             {
                 var original = new SingleAssignmentDisposable();
 
@@ -291,7 +288,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 original.Disposable = parent._source.SubscribeSafe(this);
 
-                return StableCompositeDisposable.Create(_subscription, _timer);
+                SetUpstream(StableCompositeDisposable.Create(_subscription, _timer));
             }
 
             public override void OnNext(TSource value)

Rx.NET/Source/src/System.Reactive/Linq/Observable/Timer.cs

@@ -29,9 +29,9 @@ namespace System.Reactive.Linq.ObservableImpl
                     _dueTime = dueTime;
                 }
 
-                protected override _ CreateSink(IObserver<long> observer, IDisposable cancel) => new _(observer, cancel);
+                protected override _ CreateSink(IObserver<long> observer) => new _(observer);
 
-                protected override IDisposable Run(_ sink) => sink.Run(this, _dueTime);
+                protected override void Run(_ sink) => sink.Run(this, _dueTime);
             }
 
             internal sealed class Absolute : Single
@@ -44,26 +44,26 @@ namespace System.Reactive.Linq.ObservableImpl
                     _dueTime = dueTime;
                 }
 
-                protected override _ CreateSink(IObserver<long> observer, IDisposable cancel) => new _(observer, cancel);
+                protected override _ CreateSink(IObserver<long> observer) => new _(observer);
 
-                protected override IDisposable Run(_ sink) => sink.Run(this, _dueTime);
+                protected override void Run(_ sink) => sink.Run(this, _dueTime);
             }
 
             internal sealed class _ : IdentitySink<long>
             {
-                public _(IObserver<long> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<long> observer)
+                    : base(observer)
                 {
                 }
 
-                public IDisposable Run(Single parent, DateTimeOffset dueTime)
+                public void Run(Single parent, DateTimeOffset dueTime)
                 {
-                    return parent._scheduler.Schedule(this, dueTime, (_, state) => state.Invoke());
+                    SetUpstream(parent._scheduler.Schedule(this, dueTime, (_, state) => state.Invoke()));
                 }
 
-                public IDisposable Run(Single parent, TimeSpan dueTime)
+                public void Run(Single parent, TimeSpan dueTime)
                 {
-                    return parent._scheduler.Schedule(this, dueTime, (_, state) => state.Invoke());
+                    SetUpstream(parent._scheduler.Schedule(this, dueTime, (_, state) => state.Invoke()));
                 }
 
                 private IDisposable Invoke()
@@ -96,9 +96,9 @@ namespace System.Reactive.Linq.ObservableImpl
                     _dueTime = dueTime;
                 }
 
-                protected override _ CreateSink(IObserver<long> observer, IDisposable cancel) => new _(_period, observer, cancel);
+                protected override _ CreateSink(IObserver<long> observer) => new _(_period, observer);
 
-                protected override IDisposable Run(_ sink) => sink.Run(this, _dueTime);
+                protected override void Run(_ sink) => sink.Run(this, _dueTime);
             }
 
             internal sealed class Absolute : Periodic
@@ -111,37 +111,35 @@ namespace System.Reactive.Linq.ObservableImpl
                     _dueTime = dueTime;
                 }
 
-                protected override _ CreateSink(IObserver<long> observer, IDisposable cancel) => new _(_period, observer, cancel);
+                protected override _ CreateSink(IObserver<long> observer) => new _(_period, observer);
 
-                protected override IDisposable Run(_ sink) => sink.Run(this, _dueTime);
+                protected override void Run(_ sink) => sink.Run(this, _dueTime);
             }
 
             internal sealed class _ : IdentitySink<long>
             {
                 private readonly TimeSpan _period;
 
-                public _(TimeSpan period, IObserver<long> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(TimeSpan period, IObserver<long> observer)
+                    : base(observer)
                 {
                     _period = period;
                 }
 
-                public IDisposable Run(Periodic parent, DateTimeOffset dueTime)
+                public void Run(Periodic parent, DateTimeOffset dueTime)
                 {
-                    return parent._scheduler.Schedule(default(object), dueTime, InvokeStart);
+                    SetUpstream(parent._scheduler.Schedule(default(object), dueTime, InvokeStart));
                 }
 
-                public IDisposable Run(Periodic parent, TimeSpan dueTime)
+                public void Run(Periodic parent, TimeSpan dueTime)
                 {
                     //
                     // Optimize for the case of Observable.Interval.
                     //
                     if (dueTime == _period)
-                    {
-                        return parent._scheduler.SchedulePeriodic(0L, _period, (Func<long, long>)Tick);
-                    }
-
-                    return parent._scheduler.Schedule(default(object), dueTime, InvokeStart);
+                        SetUpstream(parent._scheduler.SchedulePeriodic(0L, _period, (Func<long, long>)Tick));
+                    else
+                        SetUpstream(parent._scheduler.Schedule(default(object), dueTime, InvokeStart));
                 }
 
                 //

Rx.NET/Source/src/System.Reactive/Linq/Observable/Timestamp.cs

@@ -17,16 +17,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _scheduler = scheduler;
         }
 
-        protected override _ CreateSink(IObserver<Timestamped<TSource>> observer, IDisposable cancel) => new _(_scheduler, observer, cancel);
+        protected override _ CreateSink(IObserver<Timestamped<TSource>> observer) => new _(_scheduler, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, Timestamped<TSource>> 
         {
             private readonly IScheduler _scheduler;
 
-            public _(IScheduler scheduler, IObserver<Timestamped<TSource>> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IScheduler scheduler, IObserver<Timestamped<TSource>> observer)
+                : base(observer)
             {
                 _scheduler = scheduler;
             }

Rx.NET/Source/src/System.Reactive/Linq/Observable/ToArray.cs

@@ -15,16 +15,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<TSource[]> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource[]> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, TSource[]> 
         {
             private readonly List<TSource> _list;
 
-            public _(IObserver<TSource[]> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource[]> observer)
+                : base(observer)
             {
                 _list = new List<TSource>();
             }

Rx.NET/Source/src/System.Reactive/Linq/Observable/ToDictionary.cs

@@ -21,9 +21,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _comparer = comparer;
         }
 
-        protected override _ CreateSink(IObserver<IDictionary<TKey, TElement>> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<IDictionary<TKey, TElement>> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, IDictionary<TKey, TElement>> 
         {
@@ -31,8 +31,8 @@ namespace System.Reactive.Linq.ObservableImpl
             private readonly Func<TSource, TElement> _elementSelector;
             private readonly Dictionary<TKey, TElement> _dictionary;
 
-            public _(ToDictionary<TSource, TKey, TElement> parent, IObserver<IDictionary<TKey, TElement>> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(ToDictionary<TSource, TKey, TElement> parent, IObserver<IDictionary<TKey, TElement>> observer)
+                : base(observer)
             {
                 _keySelector = parent._keySelector;
                 _elementSelector = parent._elementSelector;

Rx.NET/Source/src/System.Reactive/Linq/Observable/ToList.cs

@@ -15,16 +15,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<IList<TSource>> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<IList<TSource>> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, IList<TSource>> 
         {
             private readonly List<TSource> _list;
 
-            public _(IObserver<IList<TSource>> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<IList<TSource>> observer)
+                : base(observer)
             {
                 _list = new List<TSource>();
             }

Rx.NET/Source/src/System.Reactive/Linq/Observable/ToLookup.cs

@@ -22,9 +22,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _comparer = comparer;
         }
 
-        protected override _ CreateSink(IObserver<ILookup<TKey, TElement>> observer, IDisposable cancel) => new _(this, observer, cancel);
+        protected override _ CreateSink(IObserver<ILookup<TKey, TElement>> observer) => new _(this, observer);
 
-        protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+        protected override void Run(_ sink) => sink.Run(_source);
 
         internal sealed class _ : Sink<TSource, ILookup<TKey, TElement>> 
         {
@@ -32,8 +32,8 @@ namespace System.Reactive.Linq.ObservableImpl
             private readonly Func<TSource, TElement> _elementSelector;
             private readonly Lookup<TKey, TElement> _lookup;
 
-            public _(ToLookup<TSource, TKey, TElement> parent, IObserver<ILookup<TKey, TElement>> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(ToLookup<TSource, TKey, TElement> parent, IObserver<ILookup<TKey, TElement>> observer)
+                : base(observer)
             {
                 _keySelector = parent._keySelector;
                 _elementSelector = parent._elementSelector;

Rx.NET/Source/src/System.Reactive/Linq/Observable/ToObservable.cs

@@ -19,18 +19,18 @@ namespace System.Reactive.Linq.ObservableImpl
             _scheduler = scheduler;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : IdentitySink<TSource>
         {
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
 
-            public IDisposable Run(ToObservable<TSource> parent)
+            public void Run(ToObservable<TSource> parent)
             {
                 var e = default(IEnumerator<TSource>);
                 try
@@ -40,7 +40,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 catch (Exception exception)
                 {
                     ForwardOnError(exception);
-                    return Disposable.Empty;
+
+                    return;
                 }
 
                 var longRunning = parent._scheduler.AsLongRunning();
@@ -52,7 +53,7 @@ namespace System.Reactive.Linq.ObservableImpl
                     // to observe the cancellation and perform proper clean-up. In this case,
                     // we're sure Loop will be entered, allowing us to dispose the enumerator.
                     //
-                    return longRunning.ScheduleLongRunning(e, Loop);
+                    SetUpstream(longRunning.ScheduleLongRunning(e, Loop));
                 }
                 else
                 {
@@ -63,7 +64,7 @@ namespace System.Reactive.Linq.ObservableImpl
                     //
                     var flag = new BooleanDisposable();
                     parent._scheduler.Schedule(new State(flag, e), LoopRec);
-                    return flag;
+                    SetUpstream(flag);
                 }
             }
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/Using.cs

@@ -18,18 +18,18 @@ namespace System.Reactive.Linq.ObservableImpl
             _observableFactory = observableFactory;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(this);
+        protected override void Run(_ sink) => sink.Run(this);
 
         internal sealed class _ : IdentitySink<TSource>
         {
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
 
-            public IDisposable Run(Using<TSource, TResource> parent)
+            public void Run(Using<TSource, TResource> parent)
             {
                 var source = default(IObservable<TSource>);
                 var disposable = Disposable.Empty;
@@ -42,10 +42,12 @@ namespace System.Reactive.Linq.ObservableImpl
                 }
                 catch (Exception exception)
                 {
-                    return StableCompositeDisposable.Create(Observable.Throw<TSource>(exception).SubscribeSafe(this), disposable);
+                    SetUpstream(StableCompositeDisposable.Create(Observable.Throw<TSource>(exception).SubscribeSafe(this), disposable));
+
+                    return;
                 }
 
-                return StableCompositeDisposable.Create(source.SubscribeSafe(this), disposable);
+                SetUpstream(StableCompositeDisposable.Create(source.SubscribeSafe(this), disposable));
             }
         }
     }

Rx.NET/Source/src/System.Reactive/Linq/Observable/Where.cs

@@ -22,16 +22,16 @@ namespace System.Reactive.Linq.ObservableImpl
                 return new Predicate(_source, x => _predicate(x) && predicate(x));
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_predicate, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private readonly Func<TSource, bool> _predicate;
 
-                public _(Func<TSource, bool> predicate, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, bool> predicate, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _predicate = predicate;
                 }
@@ -68,17 +68,17 @@ namespace System.Reactive.Linq.ObservableImpl
                 _predicate = predicate;
             }
 
-            protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(_predicate, observer, cancel);
+            protected override _ CreateSink(IObserver<TSource> observer) => new _(_predicate, observer);
 
-            protected override IDisposable Run(_ sink) => _source.SubscribeSafe(sink);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : IdentitySink<TSource>
             {
                 private readonly Func<TSource, int, bool> _predicate;
                 private int _index;
 
-                public _(Func<TSource, int, bool> predicate, IObserver<TSource> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Func<TSource, int, bool> predicate, IObserver<TSource> observer)
+                    : base(observer)
                 {
                     _predicate = predicate;
                     _index = 0;

Rx.NET/Source/src/System.Reactive/Linq/Observable/While.cs

@@ -17,9 +17,9 @@ namespace System.Reactive.Linq.ObservableImpl
             _source = source;
         }
 
-        protected override _ CreateSink(IObserver<TSource> observer, IDisposable cancel) => new _(observer, cancel);
+        protected override _ CreateSink(IObserver<TSource> observer) => new _(observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(GetSources());
+        protected override void Run(_ sink) => sink.Run(GetSources());
 
         public IEnumerable<IObservable<TSource>> GetSources()
         {
@@ -29,8 +29,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
         internal sealed class _ : ConcatSink<TSource>
         {
-            public _(IObserver<TSource> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(IObserver<TSource> observer)
+                : base(observer)
             {
             }
         }

Rx.NET/Source/src/System.Reactive/Linq/Observable/Window.cs

@@ -24,9 +24,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _skip = skip;
             }
 
-            protected override _ CreateSink(IObserver<IObservable<TSource>> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<IObservable<TSource>> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(_source);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, IObservable<TSource> > 
             {
@@ -37,8 +37,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private readonly int _count;
                 private readonly int _skip;
 
-                public _(Count parent, IObserver<IObservable<TSource>> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Count parent, IObserver<IObservable<TSource>> observer)
+                    : base(observer)
                 {
                     _refCountDisposable = new RefCountDisposable(_m);
 
@@ -48,7 +48,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private int _n;
 
-                public IDisposable Run(IObservable<TSource> source)
+                public void Run(IObservable<TSource> source)
                 {
                     _n = 0;
 
@@ -57,7 +57,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                     _m.Disposable = source.SubscribeSafe(this);
 
-                    return _refCountDisposable;
+                    SetUpstream(_refCountDisposable);
                 }
 
                 private IObservable<TSource> CreateWindow()
@@ -120,9 +120,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _scheduler = scheduler;
             }
 
-            protected override _ CreateSink(IObserver<IObservable<TSource>> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<IObservable<TSource>> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : Sink<TSource, IObservable<TSource>> 
             {
@@ -133,8 +133,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private readonly IScheduler _scheduler;
                 private readonly TimeSpan _timeShift;
 
-                public _(TimeSliding parent, IObserver<IObservable<TSource>> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(TimeSliding parent, IObserver<IObservable<TSource>> observer)
+                    : base(observer)
                 {
                     _scheduler = parent._scheduler;
                     _timeShift = parent._timeShift;
@@ -145,7 +145,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 private TimeSpan _nextShift;
                 private TimeSpan _nextSpan;
 
-                public IDisposable Run(TimeSliding parent)
+                public void Run(TimeSliding parent)
                 {
                     _totalTime = TimeSpan.Zero;
                     _nextShift = parent._timeShift;
@@ -159,7 +159,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                     groupDisposable.Add(parent._source.SubscribeSafe(this));
 
-                    return _refCountDisposable;
+                    SetUpstream(_refCountDisposable);
                 }
 
                 private void CreateWindow()
@@ -277,23 +277,23 @@ namespace System.Reactive.Linq.ObservableImpl
                 _scheduler = scheduler;
             }
 
-            protected override _ CreateSink(IObserver<IObservable<TSource>> observer, IDisposable cancel) => new _(observer, cancel);
+            protected override _ CreateSink(IObserver<IObservable<TSource>> observer) => new _(observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : Sink<TSource, IObservable<TSource>> 
             {
                 private readonly object _gate = new object();
 
-                public _(IObserver<IObservable<TSource>> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(IObserver<IObservable<TSource>> observer)
+                    : base(observer)
                 {
                 }
 
                 private Subject<TSource> _subject;
                 private RefCountDisposable _refCountDisposable;
 
-                public IDisposable Run(TimeHopping parent)
+                public void Run(TimeHopping parent)
                 {
                     var groupDisposable = new CompositeDisposable(2);
                     _refCountDisposable = new RefCountDisposable(groupDisposable);
@@ -303,7 +303,7 @@ namespace System.Reactive.Linq.ObservableImpl
                     groupDisposable.Add(parent._scheduler.SchedulePeriodic(parent._timeSpan, Tick));
                     groupDisposable.Add(parent._source.SubscribeSafe(this));
 
-                    return _refCountDisposable;
+                    SetUpstream(_refCountDisposable);
                 }
 
                 private void Tick()
@@ -366,9 +366,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _scheduler = scheduler;
             }
 
-            protected override _ CreateSink(IObserver<IObservable<TSource>> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<IObservable<TSource>> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(_source);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, IObservable<TSource>> 
             {
@@ -379,8 +379,8 @@ namespace System.Reactive.Linq.ObservableImpl
                 private readonly TimeSpan _timeSpan;
                 private readonly IScheduler _scheduler;
 
-                public _(Ferry parent, IObserver<IObservable<TSource>> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Ferry parent, IObserver<IObservable<TSource>> observer)
+                    : base(observer)
                 {
                     _count = parent._count;
                     _timeSpan = parent._timeSpan;
@@ -392,7 +392,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private RefCountDisposable _refCountDisposable;
 
-                public IDisposable Run(IObservable<TSource> source)
+                public void Run(IObservable<TSource> source)
                 {
                     _n = 0;
 
@@ -405,7 +405,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                     groupDisposable.Add(source.SubscribeSafe(this));
 
-                    return _refCountDisposable;
+                    SetUpstream(_refCountDisposable);
                 }
 
                 private void CreateTimer(Subject<TSource> window)
@@ -497,9 +497,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _windowClosingSelector = windowClosingSelector;
             }
 
-            protected override _ CreateSink(IObserver<IObservable<TSource>> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<IObservable<TSource>> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(_source);
+            protected override void Run(_ sink) => sink.Run(_source);
 
             internal sealed class _ : Sink<TSource, IObservable<TSource>> 
             {
@@ -509,8 +509,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private readonly Func<IObservable<TWindowClosing>> _windowClosingSelector;
 
-                public _(Selector parent, IObserver<IObservable<TSource>> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Selector parent, IObserver<IObservable<TSource>> observer)
+                    : base(observer)
                 {
                     _windowClosingSelector = parent._windowClosingSelector;
                 }
@@ -518,7 +518,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 private ISubject<TSource> _window;
                 private RefCountDisposable _refCountDisposable;
 
-                public IDisposable Run(IObservable<TSource> source)
+                public void Run(IObservable<TSource> source)
                 {
                     _window = new Subject<TSource>();
 
@@ -532,7 +532,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                     _windowGate.Wait(CreateWindowClose);
 
-                    return _refCountDisposable;
+                    SetUpstream(_refCountDisposable);
                 }
 
                 private void CreateWindowClose()
@@ -638,9 +638,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 _windowBoundaries = windowBoundaries;
             }
 
-            protected override _ CreateSink(IObserver<IObservable<TSource>> observer, IDisposable cancel) => new _(this, observer, cancel);
+            protected override _ CreateSink(IObserver<IObservable<TSource>> observer) => new _(this, observer);
 
-            protected override IDisposable Run(_ sink) => sink.Run(this);
+            protected override void Run(_ sink) => sink.Run(this);
 
             internal sealed class _ : Sink<TSource, IObservable<TSource>> 
             {
@@ -648,8 +648,8 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private readonly IObservable<TWindowClosing> _windowBoundaries;
 
-                public _(Boundaries parent, IObserver<IObservable<TSource>> observer, IDisposable cancel)
-                    : base(observer, cancel)
+                public _(Boundaries parent, IObserver<IObservable<TSource>> observer)
+                    : base(observer)
                 {
                     _windowBoundaries = parent._windowBoundaries;
                 }
@@ -657,7 +657,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 private ISubject<TSource> _window;
                 private RefCountDisposable _refCountDisposable;
 
-                public IDisposable Run(Boundaries parent)
+                public void Run(Boundaries parent)
                 {
                     _window = new Subject<TSource>();
 
@@ -670,7 +670,7 @@ namespace System.Reactive.Linq.ObservableImpl
                     d.Add(parent._source.SubscribeSafe(this));
                     d.Add(parent._windowBoundaries.SubscribeSafe(new WindowClosingObserver(this)));
 
-                    return _refCountDisposable;
+                    SetUpstream(_refCountDisposable);
                 }
 
                 private sealed class WindowClosingObserver : IObserver<TWindowClosing>

Rx.NET/Source/src/System.Reactive/Linq/Observable/WithLatestFrom.cs

@@ -19,16 +19,16 @@ namespace System.Reactive.Linq.ObservableImpl
             _resultSelector = resultSelector;
         }
 
-        protected override _ CreateSink(IObserver<TResult> observer, IDisposable cancel) => new _(_resultSelector, observer, cancel);
+        protected override _ CreateSink(IObserver<TResult> observer) => new _(_resultSelector, observer);
 
-        protected override IDisposable Run(_ sink) => sink.Run(_first, _second);
+        protected override void Run(_ sink) => sink.Run(_first, _second);
 
         internal sealed class _ : IdentitySink<TResult>
         {
             private readonly Func<TFirst, TSecond, TResult> _resultSelector;
 
-            public _(Func<TFirst, TSecond, TResult> resultSelector, IObserver<TResult> observer, IDisposable cancel)
-                : base(observer, cancel)
+            public _(Func<TFirst, TSecond, TResult> resultSelector, IObserver<TResult> observer)
+                : base(observer)
             {
                 _resultSelector = resultSelector;
             }
@@ -39,7 +39,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
             private object _latestGate;
 
-            public IDisposable Run(IObservable<TFirst> first, IObservable<TSecond> second)
+            public void Run(IObservable<TFirst> first, IObservable<TSecond> second)
             {
                 _gate = new object();
                 _latestGate = new object();
@@ -52,7 +52,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 sndSubscription.Disposable = second.SubscribeSafe(sndO);
                 var fstSubscription = first.SubscribeSafe(fstO);
 
-                return StableCompositeDisposable.Create(fstSubscription, sndSubscription);
+                SetUpstream(StableCompositeDisposable.Create(fstSubscription, sndSubscription));
             }
 
             private sealed class FirstObserver : IObserver<TFirst>