Merge branch 'master' into CleanupSystemReactive

Rx.NET/Source/benchmarks/Benchmarks.System.Reactive/AppendPrependBenchmark.cs

@@ -1,10 +1,9 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information.
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Reactive.Linq;
 using System.Threading;
 using BenchmarkDotNet.Attributes;
@@ -17,7 +16,7 @@ namespace Benchmarks.System.Reactive
         [Params(1, 10, 100, 1000, 10000)]
         public int N;
 
-        int _store;
+        private int _store;
 
         [Benchmark(Baseline = true)]
         public void StartWithArray()

Rx.NET/Source/benchmarks/Benchmarks.System.Reactive/ToObservableBenchmark.cs

@@ -1,9 +1,8 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Reactive.Linq;
 using System.Threading;
@@ -17,7 +16,7 @@ namespace Benchmarks.System.Reactive
         [Params(1, 10, 100, 1000, 10000, 100000, 1000000)]
         public int N;
 
-        int _store;
+        private int _store;
 
         [Benchmark]
         public void Exact()

Rx.NET/Source/src/Microsoft.Reactive.Testing/MockObserver.cs

@@ -10,33 +10,33 @@ namespace Microsoft.Reactive.Testing
 {
     internal class MockObserver<T> : ITestableObserver<T>
     {
-        private TestScheduler scheduler;
-        private List<Recorded<Notification<T>>> messages;
+        private TestScheduler _scheduler;
+        private List<Recorded<Notification<T>>> _messages;
 
         public MockObserver(TestScheduler scheduler)
         {
-            this.scheduler = scheduler ?? throw new ArgumentNullException(nameof(scheduler));
-            messages = new List<Recorded<Notification<T>>>();
+            this._scheduler = scheduler ?? throw new ArgumentNullException(nameof(scheduler));
+            _messages = new List<Recorded<Notification<T>>>();
         }
 
         public void OnNext(T value)
         {
-            messages.Add(new Recorded<Notification<T>>(scheduler.Clock, Notification.CreateOnNext<T>(value)));
+            _messages.Add(new Recorded<Notification<T>>(_scheduler.Clock, Notification.CreateOnNext(value)));
         }
 
         public void OnError(Exception exception)
         {
-            messages.Add(new Recorded<Notification<T>>(scheduler.Clock, Notification.CreateOnError<T>(exception)));
+            _messages.Add(new Recorded<Notification<T>>(_scheduler.Clock, Notification.CreateOnError<T>(exception)));
         }
 
         public void OnCompleted()
         {
-            messages.Add(new Recorded<Notification<T>>(scheduler.Clock, Notification.CreateOnCompleted<T>()));
+            _messages.Add(new Recorded<Notification<T>>(_scheduler.Clock, Notification.CreateOnCompleted<T>()));
         }
 
         public IList<Recorded<Notification<T>>> Messages
         {
-            get { return messages; }
+            get { return _messages; }
         }
     }
 }

Rx.NET/Source/src/Microsoft.Reactive.Testing/ReactiveAssert.cs

@@ -285,7 +285,7 @@ namespace Microsoft.Reactive.Testing
                 throw new ArgumentNullException(nameof(expected));
             }
 
-            ReactiveAssert.AreElementsEqual(expected, actual);
+            AreElementsEqual(expected, actual);
         }
 
         /// <summary>
@@ -329,7 +329,7 @@ namespace Microsoft.Reactive.Testing
                 throw new ArgumentNullException(nameof(expected));
             }
 
-            ReactiveAssert.AreElementsEqual(expected, actual);
+            AreElementsEqual(expected, actual);
         }
     }
 }

Rx.NET/Source/src/Microsoft.Reactive.Testing/ReactiveTest.cs

@@ -36,7 +36,7 @@ namespace Microsoft.Reactive.Testing
         /// <returns>Recorded OnNext notification.</returns>
         public static Recorded<Notification<T>> OnNext<T>(long ticks, T value)
         {
-            return new Recorded<Notification<T>>(ticks, Notification.CreateOnNext<T>(value));
+            return new Recorded<Notification<T>>(ticks, Notification.CreateOnNext(value));
         }
 
         /// <summary>
@@ -188,7 +188,7 @@ namespace Microsoft.Reactive.Testing
 
             public override bool Equals(Notification<T> other)
             {
-                if (Object.ReferenceEquals(this, other))
+                if (ReferenceEquals(this, other))
                 {
                     return true;
                 }
@@ -218,7 +218,7 @@ namespace Microsoft.Reactive.Testing
 
             public override bool Equals(Notification<T> other)
             {
-                if (Object.ReferenceEquals(this, other))
+                if (ReferenceEquals(this, other))
                 {
                     return true;
                 }

Rx.NET/Source/src/Microsoft.Reactive.Testing/TestScheduler.cs

@@ -30,7 +30,7 @@ namespace Microsoft.Reactive.Testing
                 dueTime = Clock + 1;
             }
 
-            return base.ScheduleAbsolute<TState>(state, dueTime, action);
+            return base.ScheduleAbsolute(state, dueTime, action);
         }
 
         /// <summary>

Rx.NET/Source/src/System.Reactive/Concurrency/LocalScheduler.TimerQueue.cs

@@ -428,7 +428,7 @@ namespace System.Reactive.Concurrency
             private readonly SingleAssignmentDisposable _disposable;
             private int _hasRun;
 
-            public WorkItem(LocalScheduler scheduler, DateTimeOffset dueTime)
+            protected WorkItem(LocalScheduler scheduler, DateTimeOffset dueTime)
             {
                 Scheduler = scheduler;
                 DueTime = dueTime;

Rx.NET/Source/src/System.Reactive/Concurrency/Scheduler.Async.cs

@@ -10,6 +10,41 @@ namespace System.Reactive.Concurrency
 {
     public static partial class Scheduler
     {
+        private sealed class AsyncInvocation<TState> : IDisposable
+        {
+            private readonly CancellationTokenSource _cts = new CancellationTokenSource();
+            private IDisposable _run;
+
+            public IDisposable Run(IScheduler self, TState s, Func<IScheduler, TState, CancellationToken, Task<IDisposable>> action)
+            {
+                if (_cts.IsCancellationRequested)
+                    return Disposable.Empty;
+
+                action(new CancelableScheduler(self, _cts.Token), s, _cts.Token).ContinueWith(
+                    (t, @thisObject) =>
+                    {
+                        if (!t.IsCanceled)
+                        {
+                            var @this = (AsyncInvocation<TState>)@thisObject;
+
+                            t.Exception?.Handle(e => e is OperationCanceledException);
+
+                            Disposable.SetSingle(ref @this._run, t.Result);
+                        }
+                    },
+                    this,
+                    TaskContinuationOptions.ExecuteSynchronously);
+
+                return this;
+            }
+
+            public void Dispose()
+            {
+                _cts.Cancel();
+                Disposable.TryDispose(ref _run);
+            }
+        }
+
         /// <summary>
         /// Yields execution of the current work item on the scheduler to another work item on the scheduler.
         /// The caller should await the result of calling Yield to schedule the remainder of the current work item (known as the continuation).
@@ -435,25 +470,7 @@ namespace System.Reactive.Concurrency
 
         private static IDisposable InvokeAsync<TState>(IScheduler self, TState s, Func<IScheduler, TState, CancellationToken, Task<IDisposable>> action)
         {
-            var c = new CancellationDisposable();
-            var d = new SingleAssignmentDisposable();
-
-            action(new CancelableScheduler(self, c.Token), s, c.Token).ContinueWith(t =>
-            {
-                if (t.IsCanceled)
-                {
-                    return;
-                }
-
-                if (t.Exception != null)
-                {
-                    t.Exception.Handle(e => e is OperationCanceledException);
-                }
-
-                d.Disposable = t.Result;
-            }, TaskContinuationOptions.ExecuteSynchronously);
-
-            return StableCompositeDisposable.Create(c, d);
+            return new AsyncInvocation<TState>().Run(self, s, action);
         }
 
         private static IDisposable InvokeAsync<TState>(IScheduler self, TState s, Func<IScheduler, TState, CancellationToken, Task> action)

Rx.NET/Source/src/System.Reactive/Concurrency/Scheduler.Recursive.cs

@@ -177,7 +177,7 @@ namespace System.Reactive.Concurrency
 
             protected readonly CompositeDisposable Group;
 
-            public InvokeRecBaseState(IScheduler scheduler)
+            protected InvokeRecBaseState(IScheduler scheduler)
             {
                 Scheduler = scheduler;
                 Group = new CompositeDisposable();
@@ -204,12 +204,12 @@ namespace System.Reactive.Concurrency
             internal void InvokeNext(TState state)
             {
                 var sad = new SingleAssignmentDisposable();
+
                 Group.Add(sad);
-                sad.Disposable = Scheduler.Schedule((state, sad, @this: this), (_, nextState) =>
+                sad.Disposable = scheduler.ScheduleAction((state, sad, @this: this), nextState =>
                 {
                     [email protected](nextState.sad);
                     [email protected](nextState.state);
-                    return Disposable.Empty;
                 });
             }
 
@@ -233,12 +233,11 @@ namespace System.Reactive.Concurrency
             internal void InvokeNext(TState state, TimeSpan time)
             {
                 var sad = new SingleAssignmentDisposable();
+
                 Group.Add(sad);
-                sad.Disposable = Scheduler.Schedule((state, sad, @this: this), time, (_, nextState) =>
-                {
-                    [email protected](nextState.sad);
+                sad.Disposable = scheduler.ScheduleAction((state, sad, @this: this), time, nextState => {
+                    [email protected](nextState.sad);
                     [email protected](nextState.state);
-                    return Disposable.Empty;
                 });
             }
 
@@ -262,12 +261,11 @@ namespace System.Reactive.Concurrency
             internal void InvokeNext(TState state, DateTimeOffset dtOffset)
             {
                 var sad = new SingleAssignmentDisposable();
+
                 Group.Add(sad);
-                sad.Disposable = Scheduler.Schedule((state, sad, @this: this), dtOffset, (_, nextState) =>
-                {
-                    [email protected](nextState.sad);
+                sad.Disposable = scheduler.ScheduleAction((state, sad, @this: this), dtOffset, nextState => {
+                    [email protected](nextState.sad);
                     [email protected](nextState.state);
-                    return Disposable.Empty;
                 });
             }
 

Rx.NET/Source/src/System.Reactive/Concurrency/SchedulerWrapper.cs

@@ -11,13 +11,13 @@ namespace System.Reactive.Concurrency
         protected readonly IScheduler _scheduler;
         private readonly ConditionalWeakTable<IScheduler, IScheduler> _cache;
 
-        public SchedulerWrapper(IScheduler scheduler)
+        protected SchedulerWrapper(IScheduler scheduler)
         {
             _scheduler = scheduler;
             _cache = new ConditionalWeakTable<IScheduler, IScheduler>();
         }
 
-        public SchedulerWrapper(IScheduler scheduler, ConditionalWeakTable<IScheduler, IScheduler> cache)
+        protected SchedulerWrapper(IScheduler scheduler, ConditionalWeakTable<IScheduler, IScheduler> cache)
         {
             _scheduler = scheduler;
             _cache = cache;

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

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

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

@@ -10,7 +10,7 @@ namespace System.Reactive
 {
     internal abstract class TailRecursiveSink<TSource> : IdentitySink<TSource>
     {
-        public TailRecursiveSink(IObserver<TSource> observer)
+        protected TailRecursiveSink(IObserver<TSource> observer)
             : base(observer)
         {
         }

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

@@ -89,12 +89,12 @@ namespace System.Reactive.Linq.ObservableImpl
                 {
                     var disp = _append
                         ? _source.SubscribeSafe(this)
-                        : _scheduler.Schedule(this, PrependValue);
+                        : _scheduler.ScheduleAction(this, PrependValue);
 
                     SetUpstream(disp);
                 }
 
-                private static IDisposable PrependValue(IScheduler scheduler, _ sink)
+                private static IDisposable PrependValue(_ sink)
                 {
                     sink.ForwardOnNext(sink._value);
                     return sink._source.SubscribeSafe(sink);
@@ -104,7 +104,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 {
                     if (_append)
                     {
-                        var disposable = _scheduler.Schedule(this, AppendValue);
+                        var disposable = _scheduler.ScheduleAction(this, AppendValue);
                         Disposable.TrySetSingle(ref _schedulerDisposable, disposable);
                     }
                     else
@@ -113,11 +113,10 @@ namespace System.Reactive.Linq.ObservableImpl
                     }
                 }
 
-                private static IDisposable AppendValue(IScheduler scheduler, _ sink)
+                private static void AppendValue(_ sink)
                 {
                     sink.ForwardOnNext(sink._value);
                     sink.ForwardOnCompleted();
-                    return Disposable.Empty;
                 }
 
                 protected override void Dispose(bool disposing)

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

@@ -346,10 +346,10 @@ namespace System.Reactive.Linq.ObservableImpl
                         _nextShift += _timeShift;
                     }
 
-                    m.Disposable = _scheduler.Schedule((@this: this, isSpan, isShift), ts, (_, tuple) => [email protected](tuple.isSpan, tuple.isShift));
+                    m.Disposable = _scheduler.ScheduleAction((@this: this, isSpan, isShift), ts, tuple => [email protected](tuple.isSpan, tuple.isShift));
                 }
 
-                private IDisposable Tick(bool isSpan, bool isShift)
+                private void Tick(bool isSpan, bool isShift)
                 {
                     lock (_gate)
                     {
@@ -372,8 +372,6 @@ namespace System.Reactive.Linq.ObservableImpl
                     }
 
                     CreateTimer();
-
-                    return Disposable.Empty;
                 }
 
                 public override void OnNext(TSource value)
@@ -559,19 +557,17 @@ namespace System.Reactive.Linq.ObservableImpl
                     var m = new SingleAssignmentDisposable();
                     Disposable.TrySetSerial(ref _timerSerial, m);
 
-                    m.Disposable = _parent._scheduler.Schedule((@this: this, id), _parent._timeSpan, (_, tuple) => [email protected](tuple.id));
+                    m.Disposable = _parent._scheduler.ScheduleAction((@this: this, id), _parent._timeSpan, tuple => [email protected](tuple.id));
                 }
 
-                private IDisposable Tick(int id)
+                private void Tick(int id)
                 {
-                    var d = Disposable.Empty;
-
                     var newId = 0;
                     lock (_gate)
                     {
                         if (id != _windowId)
                         {
-                            return d;
+                            return;
                         }
 
                         _n = 0;
@@ -583,8 +579,6 @@ namespace System.Reactive.Linq.ObservableImpl
 
                         CreateTimer(newId);
                     }
-
-                    return d;
                 }
 
                 public override void OnNext(TSource value)

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

@@ -236,7 +236,7 @@ namespace System.Reactive.Linq.ObservableImpl
         private readonly bool[] _hasValue;
         private readonly bool[] _isDone;
 
-        public CombineLatestSink(int arity, IObserver<TResult> observer)
+        protected CombineLatestSink(int arity, IObserver<TResult> observer)
             : base(observer)
         {
             _gate = new object();

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

@@ -17,7 +17,7 @@ namespace System.Reactive.Linq.ObservableImpl
             protected readonly IObservable<TSource> _source;
             protected readonly IScheduler _scheduler;
 
-            public Base(IObservable<TSource> source, IScheduler scheduler)
+            protected Base(IObservable<TSource> source, IScheduler scheduler)
             {
                 _source = source;
                 _scheduler = scheduler;
@@ -28,7 +28,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 protected IStopwatch _watch;
                 protected IScheduler _scheduler;
 
-                public _(TParent parent, IObserver<TSource> observer)
+                protected _(TParent parent, IObserver<TSource> observer)
                     : base(observer)
                 {
                     _scheduler = parent._scheduler;
@@ -51,7 +51,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 protected readonly object _gate = new object();
                 protected IDisposable _cancelable;
 
-                public S(TParent parent, IObserver<TSource> observer)
+                protected S(TParent parent, IObserver<TSource> observer)
                     : base(parent, observer)
                 {
                 }
@@ -258,7 +258,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 protected IDisposable _cancelable;
                 private readonly SemaphoreSlim _evt = new SemaphoreSlim(0);
 
-                public L(TParent parent, IObserver<TSource> observer)
+                protected L(TParent parent, IObserver<TSource> observer)
                     : base(parent, observer)
                 {
                 }
@@ -396,7 +396,7 @@ namespace System.Reactive.Linq.ObservableImpl
                         if (shouldWait)
                         {
                             var timer = new ManualResetEventSlim();
-                            _scheduler.Schedule(timer, waitTime, (_, slimTimer) => { slimTimer.Set(); return Disposable.Empty; });
+                            _scheduler.ScheduleAction(timer, waitTime, slimTimer => { slimTimer.Set(); });
 
                             try
                             {
@@ -455,10 +455,10 @@ namespace System.Reactive.Linq.ObservableImpl
                 {
                     _ready = false;
 
-                    Disposable.TrySetSingle(ref _cancelable, parent._scheduler.Schedule(this, parent._dueTime, (_, @this) => @this.Start()));
+                    Disposable.TrySetSingle(ref _cancelable, parent._scheduler.ScheduleAction(this, parent._dueTime, @this => @this.Start()));
                 }
 
-                private IDisposable Start()
+                private void Start()
                 {
                     var next = default(TimeSpan);
                     var shouldRun = false;
@@ -491,8 +491,6 @@ namespace System.Reactive.Linq.ObservableImpl
                     {
                         Disposable.TrySetSerial(ref _cancelable, _scheduler.Schedule((Base<Absolute>.S)this, next, (@this, a) => DrainQueue(a)));
                     }
-
-                    return Disposable.Empty;
                 }
             }
 
@@ -508,10 +506,10 @@ namespace System.Reactive.Linq.ObservableImpl
                     // ScheduleDrain might have already set a newer disposable
                     // using TrySetSerial would cancel it, stopping the emission
                     // and hang the consumer
-                    Disposable.TrySetSingle(ref _cancelable, parent._scheduler.Schedule(this, parent._dueTime, (_, @this) => @this.Start()));
+                    Disposable.TrySetSingle(ref _cancelable, parent._scheduler.ScheduleAction(this, parent._dueTime, @this => @this.Start()));
                 }
 
-                private IDisposable Start()
+                private void Start()
                 {
                     lock (_gate)
                     {
@@ -528,8 +526,6 @@ namespace System.Reactive.Linq.ObservableImpl
                     }
 
                     ScheduleDrain();
-
-                    return Disposable.Empty;
                 }
             }
         }
@@ -586,7 +582,7 @@ namespace System.Reactive.Linq.ObservableImpl
         {
             protected readonly IObservable<TSource> _source;
 
-            public Base(IObservable<TSource> source)
+            protected Base(IObservable<TSource> source)
             {
                 _source = source;
             }
@@ -598,7 +594,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 private readonly Func<TSource, IObservable<TDelay>> _delaySelector;
 
-                public _(Func<TSource, IObservable<TDelay>> delaySelector, IObserver<TSource> observer)
+                protected _(Func<TSource, IObservable<TDelay>> delaySelector, IObserver<TSource> observer)
                     : base(observer)
                 {
                     _delaySelector = delaySelector;

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

@@ -11,7 +11,7 @@ namespace System.Reactive.Linq.ObservableImpl
         private readonly IObservable<TSource> _source;
         private readonly IScheduler _scheduler;
 
-        public DelaySubscription(IObservable<TSource> source, IScheduler scheduler)
+        protected DelaySubscription(IObservable<TSource> source, IScheduler scheduler)
         {
             _source = source;
             _scheduler = scheduler;
@@ -56,12 +56,12 @@ namespace System.Reactive.Linq.ObservableImpl
 
             public void Run(IObservable<TSource> source, IScheduler scheduler, DateTimeOffset dueTime)
             {
-                SetUpstream(scheduler.Schedule((@this: this, source), dueTime, (self, tuple) => tuple.source.SubscribeSafe(tuple.@this)));
+                SetUpstream(scheduler.ScheduleAction((@this: this, source), dueTime, 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)));
+                SetUpstream(scheduler.ScheduleAction((@this: this, source), dueTime, tuple => tuple.source.SubscribeSafe(tuple.@this)));
             }
         }
     }

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

@@ -29,11 +29,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
             public void Run(IScheduler scheduler)
             {
-                SetUpstream(scheduler.Schedule(this, (s, target) =>
-                {
-                    target.OnCompleted();
-                    return Disposable.Empty;
-                }));
+                SetUpstream(scheduler.ScheduleAction(this, target => target.OnCompleted()));
             }
         }
     }

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

@@ -195,7 +195,7 @@ namespace System.Reactive.Linq.ObservableImpl
         private readonly IScheduler _scheduler;
         private readonly object _gate;
 
-        public EventProducer(IScheduler scheduler)
+        protected EventProducer(IScheduler scheduler)
         {
             _scheduler = scheduler;
             _gate = new object();
@@ -321,11 +321,11 @@ namespace System.Reactive.Linq.ObservableImpl
                     // the GetSchedulerForCurrentContext method).
                     //
                     var onNext = _parent.GetHandler(_subject.OnNext);
-                    _parent._scheduler.Schedule(onNext, AddHandler);
+                    _parent._scheduler.ScheduleAction(onNext, AddHandler);
                 }
             }
 
-            private IDisposable AddHandler(IScheduler self, TDelegate onNext)
+            private void AddHandler(TDelegate onNext)
             {
                 var removeHandler = default(IDisposable);
                 try
@@ -335,7 +335,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 catch (Exception exception)
                 {
                     _subject.OnError(exception);
-                    return Disposable.Empty;
+                    return;
                 }
 
                 //
@@ -347,8 +347,6 @@ namespace System.Reactive.Linq.ObservableImpl
                 // remove handler to run on the scheduler.
                 //
                 _removeHandler.Disposable = removeHandler;
-
-                return Disposable.Empty;
             }
         }
     }
@@ -358,7 +356,7 @@ namespace System.Reactive.Linq.ObservableImpl
         private readonly Action<TDelegate> _addHandler;
         private readonly Action<TDelegate> _removeHandler;
 
-        public ClassicEventProducer(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler)
+        protected ClassicEventProducer(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler)
             : base(scheduler)
         {
             _addHandler = addHandler;

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

@@ -25,7 +25,7 @@ namespace System.Reactive.Linq.ObservableImpl
         {
             protected readonly IComparer<TSource> _comparer;
 
-            public _(IComparer<TSource> comparer, IObserver<TSource> observer)
+            protected _(IComparer<TSource> comparer, IObserver<TSource> observer)
                 : base(observer)
             {
                 _comparer = comparer;

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

@@ -25,7 +25,7 @@ namespace System.Reactive.Linq.ObservableImpl
         {
             protected readonly IComparer<TSource> _comparer;
 
-            public _(IComparer<TSource> comparer, IObserver<TSource> observer)
+            protected _(IComparer<TSource> comparer, IObserver<TSource> observer)
                 : base(observer)
             {
                 _comparer = comparer;

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

@@ -12,7 +12,7 @@ namespace System.Reactive.Linq.ObservableImpl
     {
         private readonly IObservable<TSource> _source;
 
-        public PushToPullAdapter(IObservable<TSource> source)
+        protected PushToPullAdapter(IObservable<TSource> source)
         {
             _source = source;
         }

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

@@ -140,7 +140,7 @@ namespace System.Reactive.Linq.ObservableImpl
                                 {
                                     var cancelable = (SingleAssignmentDisposable)Volatile.Read(ref closureParent._serial);
 
-                                    cancelable.Disposable = closureParent._scheduler.Schedule((cancelable, closureParent), closureParent._disconnectTime, (self, tuple2) =>
+                                    cancelable.Disposable = closureParent._scheduler.ScheduleAction((cancelable, closureParent), closureParent._disconnectTime, tuple2 =>
                                     {
                                         lock (tuple2.closureParent._gate)
                                         {
@@ -150,8 +150,6 @@ namespace System.Reactive.Linq.ObservableImpl
                                                 tuple2.closureParent._connectableSubscription = null;
                                             }
                                         }
-
-                                        return Disposable.Empty;
                                     });
                                 }
                             }

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

@@ -196,7 +196,6 @@ namespace System.Reactive.Linq.ObservableImpl
             internal sealed class _ : IdentitySink<TResult>
             {
                 private readonly TResult _value;
-
                 private readonly int _remaining;
 
                 public _(TResult value, int remaining, IObserver<TResult> observer)

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

@@ -111,7 +111,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 public void Run(Time parent)
                 {
-                    SetUpstream(parent._scheduler.Schedule(this, parent._duration, (_, state) => state.Tick()));
+                    SetUpstream(parent._scheduler.ScheduleAction(this, parent._duration, state => state.Tick()));
                     Disposable.SetSingle(ref _sourceDisposable, parent._source.SubscribeSafe(this));
                 }
 
@@ -124,10 +124,9 @@ namespace System.Reactive.Linq.ObservableImpl
                     base.Dispose(disposing);
                 }
 
-                private IDisposable Tick()
+                private void Tick()
                 {
                     _open = true;
-                    return Disposable.Empty;
                 }
 
                 public override void OnNext(TSource value)

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

@@ -170,7 +170,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
             public void Run(SkipUntil<TSource> parent)
             {
-                Disposable.SetSingle(ref _task, parent._scheduler.Schedule(this, parent._startTime, (_, state) => state.Tick()));
+                Disposable.SetSingle(ref _task, parent._scheduler.ScheduleAction(this, parent._startTime, state => state.Tick()));
                 Run(parent._source);
             }
 
@@ -183,10 +183,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 base.Dispose(disposing);
             }
 
-            private IDisposable Tick()
+            private void Tick()
             {
                 _open = true;
-                return Disposable.Empty;
             }
 
             public override void OnNext(TSource value)

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

@@ -122,7 +122,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 {
                     _gate = new object();
 
-                    Disposable.SetSingle(ref _task, parent._scheduler.Schedule(this, parent._duration, (_, state) => state.Tick()));
+                    Disposable.SetSingle(ref _task, parent._scheduler.ScheduleAction(this, parent._duration, state => state.Tick()));
                     Run(parent._source);
                 }
 
@@ -135,13 +135,12 @@ namespace System.Reactive.Linq.ObservableImpl
                     base.Dispose(disposing);
                 }
 
-                private IDisposable Tick()
+                private void Tick()
                 {
                     lock (_gate)
                     {
                         ForwardOnCompleted();
                     }
-                    return Disposable.Empty;
                 }
 
                 public override void OnNext(TSource value)

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

@@ -147,7 +147,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
             public void Run(TakeUntil<TSource> parent)
             {
-                Disposable.SetSingle(ref _timerDisposable, parent._scheduler.Schedule(this, parent._endTime, (_, state) => state.Tick()));
+                Disposable.SetSingle(ref _timerDisposable, parent._scheduler.ScheduleAction(this, parent._endTime, state => state.Tick()));
                 Run(parent._source);
             }
 
@@ -160,10 +160,9 @@ namespace System.Reactive.Linq.ObservableImpl
                 base.Dispose(disposing);
             }
 
-            private IDisposable Tick()
+            private void Tick()
             {
                 OnCompleted();
-                return Disposable.Empty;
             }
 
             public override void OnNext(TSource value)

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

@@ -64,10 +64,10 @@ namespace System.Reactive.Linq.ObservableImpl
                 }
 
                 Disposable.TrySetSerial(ref _serialCancelable, null);
-                Disposable.TrySetSerial(ref _serialCancelable, _scheduler.Schedule((@this: this, currentid), _dueTime, (_, tuple) => [email protected](tuple.currentid)));
+                Disposable.TrySetSerial(ref _serialCancelable, _scheduler.ScheduleAction((@this: this, currentid), _dueTime, tuple => [email protected](tuple.currentid)));
             }
 
-            private IDisposable Propagate(ulong currentid)
+            private void Propagate(ulong currentid)
             {
                 lock (_gate)
                 {
@@ -78,8 +78,6 @@ namespace System.Reactive.Linq.ObservableImpl
 
                     _hasValue = false;
                 }
-
-                return Disposable.Empty;
             }
 
             public override void OnError(Exception error)

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

@@ -70,7 +70,7 @@ namespace System.Reactive.Linq.ObservableImpl
                     if (Disposable.TrySetMultiple(ref _timerDisposable, null))
                     {
 
-                        var d = _scheduler.Schedule((idx, instance: this), _dueTime, (_, state) => { state.instance.Timeout(state.idx); return Disposable.Empty; });
+                        var d = _scheduler.ScheduleAction((idx, instance: this), _dueTime, state => { state.instance.Timeout(state.idx); });
 
                         Disposable.TrySetMultiple(ref _timerDisposable, d);
                     }
@@ -159,7 +159,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 public void Run(Absolute parent)
                 {
-                    SetUpstream(parent._scheduler.Schedule(this, parent._dueTime, (_, @this) => @this.Timeout()));
+                    SetUpstream(parent._scheduler.ScheduleAction(this, parent._dueTime, @this => @this.Timeout()));
 
                     Disposable.TrySetSingle(ref _serialDisposable, parent._source.SubscribeSafe(this));
                 }
@@ -173,13 +173,12 @@ namespace System.Reactive.Linq.ObservableImpl
                     base.Dispose(disposing);
                 }
 
-                private IDisposable Timeout()
+                private void Timeout()
                 {
                     if (Interlocked.Increment(ref _wip) == 1)
                     {
                         Disposable.TrySetSerial(ref _serialDisposable, _other.SubscribeSafe(GetForwarder()));
                     }
-                    return Disposable.Empty;
                 }
 
                 public override void OnNext(TSource value)

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

@@ -14,7 +14,7 @@ namespace System.Reactive.Linq.ObservableImpl
         {
             private readonly IScheduler _scheduler;
 
-            public Single(IScheduler scheduler)
+            protected Single(IScheduler scheduler)
             {
                 _scheduler = scheduler;
             }
@@ -58,19 +58,18 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 public void Run(Single parent, DateTimeOffset dueTime)
                 {
-                    SetUpstream(parent._scheduler.Schedule(this, dueTime, (_, state) => state.Invoke()));
+                    SetUpstream(parent._scheduler.ScheduleAction(this, dueTime, state => state.Invoke()));
                 }
 
                 public void Run(Single parent, TimeSpan dueTime)
                 {
-                    SetUpstream(parent._scheduler.Schedule(this, dueTime, (_, state) => state.Invoke()));
+                    SetUpstream(parent._scheduler.ScheduleAction(this, dueTime, state => state.Invoke()));
                 }
 
-                private IDisposable Invoke()
+                private void Invoke()
                 {
                     ForwardOnNext(0);
                     ForwardOnCompleted();
-                    return Disposable.Empty;
                 }
             }
         }
@@ -80,7 +79,7 @@ namespace System.Reactive.Linq.ObservableImpl
             private readonly TimeSpan _period;
             private readonly IScheduler _scheduler;
 
-            public Periodic(TimeSpan period, IScheduler scheduler)
+            protected Periodic(TimeSpan period, IScheduler scheduler)
             {
                 _period = period;
                 _scheduler = scheduler;

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

@@ -208,10 +208,10 @@ namespace System.Reactive.Linq.ObservableImpl
                         _nextShift += _timeShift;
                     }
 
-                    m.Disposable = _scheduler.Schedule((@this: this, isSpan, isShift), ts, (_, tuple) => [email protected](tuple.isSpan, tuple.isShift));
+                    m.Disposable = _scheduler.ScheduleAction((@this: this, isSpan, isShift), ts, tuple => [email protected](tuple.isSpan, tuple.isShift));
                 }
 
-                private IDisposable Tick(bool isSpan, bool isShift)
+                private void Tick(bool isSpan, bool isShift)
                 {
                     lock (_gate)
                     {
@@ -234,8 +234,6 @@ namespace System.Reactive.Linq.ObservableImpl
                     }
 
                     CreateTimer();
-
-                    return Disposable.Empty;
                 }
 
                 public override void OnNext(TSource value)
@@ -424,19 +422,17 @@ namespace System.Reactive.Linq.ObservableImpl
                     var m = new SingleAssignmentDisposable();
                     _timerD.Disposable = m;
 
-                    m.Disposable = _scheduler.Schedule((@this: this, window), _timeSpan, (_, tuple) => [email protected](tuple.window));
+                    m.Disposable = _scheduler.ScheduleAction((@this: this, window), _timeSpan, tuple => [email protected](tuple.window));
                 }
 
-                private IDisposable Tick(Subject<TSource> window)
+                private void Tick(Subject<TSource> window)
                 {
-                    var d = Disposable.Empty;
-
                     var newWindow = default(Subject<TSource>);
                     lock (_gate)
                     {
                         if (window != _s)
                         {
-                            return d;
+                            return;
                         }
 
                         _n = 0;
@@ -448,8 +444,6 @@ namespace System.Reactive.Linq.ObservableImpl
                     }
 
                     CreateTimer(newWindow);
-
-                    return d;
                 }
 
                 public override void OnNext(TSource value)

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

@@ -390,7 +390,7 @@ namespace System.Reactive.Linq.ObservableImpl
         private readonly ICollection[] _queues;
         private readonly bool[] _isDone;
 
-        public ZipSink(int arity, IObserver<TResult> observer)
+        protected ZipSink(int arity, IObserver<TResult> observer)
             : base(observer)
         {
             _gate = new object();

Rx.NET/Source/src/System.Reactive/Notification.cs

@@ -665,7 +665,7 @@ namespace System.Reactive
 
             protected override IDisposable SubscribeCore(IObserver<T> observer)
             {
-                return _scheduler.Schedule((_parent, observer), (scheduler, state) =>
+                return _scheduler.ScheduleAction((_parent, observer), state =>
                 {
                     var parent = state._parent;
                     var o = state.observer;
@@ -676,7 +676,6 @@ namespace System.Reactive
                     {
                         o.OnCompleted();
                     }
-                    return Disposable.Empty;
                 });
             }
         }

Rx.NET/Source/src/System.Reactive/ObservableBase.cs

@@ -50,7 +50,7 @@ namespace System.Reactive
                 // exception thrown in OnNext to circle back to OnError, which looks like the
                 // sequence can't make up its mind.
                 //
-                CurrentThreadScheduler.Instance.Schedule(autoDetachObserver, ScheduledSubscribe);
+                CurrentThreadScheduler.Instance.ScheduleAction(autoDetachObserver, ScheduledSubscribe);
             }
             else
             {
@@ -79,7 +79,7 @@ namespace System.Reactive
             return autoDetachObserver;
         }
 
-        private IDisposable ScheduledSubscribe(IScheduler _, AutoDetachObserver<T> autoDetachObserver)
+        private void ScheduledSubscribe(AutoDetachObserver<T> autoDetachObserver)
         {
             try
             {
@@ -101,8 +101,6 @@ namespace System.Reactive
                     throw;
                 }
             }
-
-            return Disposable.Empty;
         }
 
         /// <summary>

Rx.NET/Source/src/System.Reactive/Subjects/ReplaySubject.cs

@@ -229,7 +229,7 @@ namespace System.Reactive.Subjects
             private Exception _error;
             private bool _isDisposed;
 
-            public ReplayBase()
+            protected ReplayBase()
             {
                 _observers = ImmutableList<IScheduledObserver<T>>.Empty;
 

Rx.NET/Source/tests/Tests.System.Reactive/MockDisposable.cs

@@ -10,17 +10,17 @@ namespace ReactiveTests
 {
     public class MockDisposable : List<long>, IDisposable
     {
-        private TestScheduler scheduler;
+        private TestScheduler _scheduler;
 
         public MockDisposable(TestScheduler scheduler)
         {
-            this.scheduler = scheduler ?? throw new ArgumentNullException(nameof(scheduler));
+            this._scheduler = scheduler ?? throw new ArgumentNullException(nameof(scheduler));
             Add(scheduler.Clock);
         }
 
         public void Dispose()
         {
-            Add(scheduler.Clock);
+            Add(_scheduler.Clock);
         }
     }
 }

Rx.NET/Source/tests/Tests.System.Reactive/MockEnumerable.cs

@@ -12,17 +12,17 @@ namespace ReactiveTests
     {
         public readonly TestScheduler Scheduler;
         public readonly List<Subscription> Subscriptions = new List<Subscription>();
-        private IEnumerable<T> underlyingEnumerable;
+        private IEnumerable<T> _underlyingEnumerable;
 
         public MockEnumerable(TestScheduler scheduler, IEnumerable<T> underlyingEnumerable)
         {
             Scheduler = scheduler ?? throw new ArgumentNullException(nameof(scheduler));
-            this.underlyingEnumerable = underlyingEnumerable ?? throw new ArgumentNullException(nameof(underlyingEnumerable));
+            this._underlyingEnumerable = underlyingEnumerable ?? throw new ArgumentNullException(nameof(underlyingEnumerable));
         }
 
         public IEnumerator<T> GetEnumerator()
         {
-            return new MockEnumerator(Scheduler, Subscriptions, underlyingEnumerable.GetEnumerator());
+            return new MockEnumerator(Scheduler, Subscriptions, _underlyingEnumerable.GetEnumerator());
         }
 
         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
@@ -32,19 +32,19 @@ namespace ReactiveTests
 
         private class MockEnumerator : IEnumerator<T>
         {
-            private readonly List<Subscription> subscriptions;
-            private IEnumerator<T> enumerator;
-            private TestScheduler scheduler;
-            private readonly int index;
-            private bool disposed = false;
+            private readonly List<Subscription> _subscriptions;
+            private IEnumerator<T> _enumerator;
+            private TestScheduler _scheduler;
+            private readonly int _index;
+            private bool _disposed;
 
             public MockEnumerator(TestScheduler scheduler, List<Subscription> subscriptions, IEnumerator<T> enumerator)
             {
-                this.subscriptions = subscriptions;
-                this.enumerator = enumerator;
-                this.scheduler = scheduler;
+                this._subscriptions = subscriptions;
+                this._enumerator = enumerator;
+                this._scheduler = scheduler;
 
-                index = subscriptions.Count;
+                _index = subscriptions.Count;
                 subscriptions.Add(new Subscription(scheduler.Clock));
             }
 
@@ -52,22 +52,22 @@ namespace ReactiveTests
             {
                 get
                 {
-                    if (disposed)
+                    if (_disposed)
                     {
                         throw new ObjectDisposedException("this");
                     }
 
-                    return enumerator.Current;
+                    return _enumerator.Current;
                 }
             }
 
             public void Dispose()
             {
-                if (!disposed)
+                if (!_disposed)
                 {
-                    disposed = true;
-                    enumerator.Dispose();
-                    subscriptions[index] = new Subscription(subscriptions[index].Subscribe, scheduler.Clock);
+                    _disposed = true;
+                    _enumerator.Dispose();
+                    _subscriptions[_index] = new Subscription(_subscriptions[_index].Subscribe, _scheduler.Clock);
                 }
             }
 
@@ -78,22 +78,22 @@ namespace ReactiveTests
 
             public bool MoveNext()
             {
-                if (disposed)
+                if (_disposed)
                 {
                     throw new ObjectDisposedException("this");
                 }
 
-                return enumerator.MoveNext();
+                return _enumerator.MoveNext();
             }
 
             public void Reset()
             {
-                if (disposed)
+                if (_disposed)
                 {
                     throw new ObjectDisposedException("this");
                 }
 
-                enumerator.Reset();
+                _enumerator.Reset();
             }
         }
 

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/DefaultSchedulerTest.cs

@@ -16,9 +16,9 @@ namespace ReactiveTests.Tests
         [Fact]
         public void Schedule_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => DefaultScheduler.Instance.Schedule<int>(42, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => DefaultScheduler.Instance.Schedule<int>(42, DateTimeOffset.Now, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => DefaultScheduler.Instance.Schedule<int>(42, TimeSpan.Zero, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => DefaultScheduler.Instance.Schedule(42, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => DefaultScheduler.Instance.Schedule(42, DateTimeOffset.Now, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => DefaultScheduler.Instance.Schedule(42, TimeSpan.Zero, default));
             ReactiveAssert.Throws<ArgumentNullException>(() => DefaultScheduler.Instance.SchedulePeriodic(42, TimeSpan.FromSeconds(1), default));
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => DefaultScheduler.Instance.SchedulePeriodic(42, TimeSpan.FromSeconds(-1), _ => _));
         }

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/EventLoopSchedulerTest.cs

@@ -27,9 +27,9 @@ namespace ReactiveTests.Tests
 #if !NO_THREAD
             ReactiveAssert.Throws<ArgumentNullException>(() => new EventLoopScheduler(null));
 #endif
-            ReactiveAssert.Throws<ArgumentNullException>(() => el.Schedule<int>(42, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => el.Schedule<int>(42, DateTimeOffset.Now, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => el.Schedule<int>(42, TimeSpan.Zero, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => el.Schedule(42, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => el.Schedule(42, DateTimeOffset.Now, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => el.Schedule(42, TimeSpan.Zero, default));
             ReactiveAssert.Throws<ArgumentNullException>(() => el.SchedulePeriodic(42, TimeSpan.FromSeconds(1), default));
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => el.SchedulePeriodic(42, TimeSpan.FromSeconds(-1), _ => _));
         }

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ImmediateSchedulerTest.cs

@@ -51,16 +51,16 @@ namespace ReactiveTests.Tests
         [Fact]
         public void Immediate_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Immediate.Schedule<int>(42, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Immediate.Schedule<int>(42, DateTimeOffset.Now, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Immediate.Schedule<int>(42, TimeSpan.Zero, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Immediate.Schedule(42, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Immediate.Schedule(42, DateTimeOffset.Now, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Immediate.Schedule(42, TimeSpan.Zero, default));
         }
 
         [Fact]
         public void Immediate_Simple1()
         {
             var _x = 0;
-            Scheduler.Immediate.Schedule<int>(42, (self, x) => { _x = x; return Disposable.Empty; });
+            Scheduler.Immediate.Schedule(42, (self, x) => { _x = x; return Disposable.Empty; });
             Assert.Equal(42, _x);
         }
 
@@ -68,7 +68,7 @@ namespace ReactiveTests.Tests
         public void Immediate_Simple2()
         {
             var _x = 0;
-            Scheduler.Immediate.Schedule<int>(42, DateTimeOffset.Now, (self, x) => { _x = x; return Disposable.Empty; });
+            Scheduler.Immediate.Schedule(42, DateTimeOffset.Now, (self, x) => { _x = x; return Disposable.Empty; });
             Assert.Equal(42, _x);
         }
 
@@ -76,7 +76,7 @@ namespace ReactiveTests.Tests
         public void Immediate_Simple3()
         {
             var _x = 0;
-            Scheduler.Immediate.Schedule<int>(42, TimeSpan.Zero, (self, x) => { _x = x; return Disposable.Empty; });
+            Scheduler.Immediate.Schedule(42, TimeSpan.Zero, (self, x) => { _x = x; return Disposable.Empty; });
             Assert.Equal(42, _x);
         }
 
@@ -85,7 +85,7 @@ namespace ReactiveTests.Tests
         {
             var _x = 0;
             var _y = 0;
-            Scheduler.Immediate.Schedule<int>(42, (self, x) => { _x = x; return self.Schedule<int>(43, (self2, y) => { _y = y; return Disposable.Empty; }); });
+            Scheduler.Immediate.Schedule(42, (self, x) => { _x = x; return self.Schedule(43, (self2, y) => { _y = y; return Disposable.Empty; }); });
             Assert.Equal(42, _x);
             Assert.Equal(43, _y);
         }
@@ -95,7 +95,7 @@ namespace ReactiveTests.Tests
         {
             var _x = 0;
             var _y = 0;
-            Scheduler.Immediate.Schedule<int>(42, (self, x) => { _x = x; return self.Schedule<int>(43, DateTimeOffset.Now, (self2, y) => { _y = y; return Disposable.Empty; }); });
+            Scheduler.Immediate.Schedule(42, (self, x) => { _x = x; return self.Schedule(43, DateTimeOffset.Now, (self2, y) => { _y = y; return Disposable.Empty; }); });
             Assert.Equal(42, _x);
             Assert.Equal(43, _y);
         }
@@ -105,7 +105,7 @@ namespace ReactiveTests.Tests
         {
             var _x = 0;
             var _y = 0;
-            Scheduler.Immediate.Schedule<int>(42, (self, x) => { _x = x; return self.Schedule<int>(43, TimeSpan.FromMilliseconds(100), (self2, y) => { _y = y; return Disposable.Empty; }); });
+            Scheduler.Immediate.Schedule(42, (self, x) => { _x = x; return self.Schedule(43, TimeSpan.FromMilliseconds(100), (self2, y) => { _y = y; return Disposable.Empty; }); });
             Assert.Equal(42, _x);
             Assert.Equal(43, _y);
         }

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/NewThreadSchedulerTest.cs

@@ -18,12 +18,12 @@ namespace ReactiveTests.Tests
         public void NewThread_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new NewThreadScheduler(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => NewThreadScheduler.Default.Schedule<int>(42, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => NewThreadScheduler.Default.Schedule<int>(42, DateTimeOffset.Now, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => NewThreadScheduler.Default.Schedule<int>(42, TimeSpan.Zero, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => NewThreadScheduler.Default.SchedulePeriodic<int>(42, TimeSpan.FromSeconds(1), default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => NewThreadScheduler.Default.ScheduleLongRunning<int>(42, default));
-            ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => NewThreadScheduler.Default.SchedulePeriodic<int>(42, TimeSpan.FromSeconds(-1), _ => _));
+            ReactiveAssert.Throws<ArgumentNullException>(() => NewThreadScheduler.Default.Schedule(42, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => NewThreadScheduler.Default.Schedule(42, DateTimeOffset.Now, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => NewThreadScheduler.Default.Schedule(42, TimeSpan.Zero, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => NewThreadScheduler.Default.SchedulePeriodic(42, TimeSpan.FromSeconds(1), default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => NewThreadScheduler.Default.ScheduleLongRunning(42, default));
+            ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => NewThreadScheduler.Default.SchedulePeriodic(42, TimeSpan.FromSeconds(-1), _ => _));
         }
 
         [Fact]

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/SchedulerTest.cs

@@ -264,13 +264,13 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Scheduler.SchedulePeriodic(ThreadPoolScheduler.Instance, TimeSpan.FromSeconds(-1), () => { }));
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.SchedulePeriodic(ThreadPoolScheduler.Instance, TimeSpan.FromSeconds(1), default));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.SchedulePeriodic<int>(null, 42, TimeSpan.FromSeconds(1), _ => { }));
-            ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Scheduler.SchedulePeriodic<int>(ThreadPoolScheduler.Instance, 42, TimeSpan.FromSeconds(-1), _ => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.SchedulePeriodic<int>(ThreadPoolScheduler.Instance, 42, TimeSpan.FromSeconds(1), default(Action<int>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.SchedulePeriodic(null, 42, TimeSpan.FromSeconds(1), _ => { }));
+            ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Scheduler.SchedulePeriodic(ThreadPoolScheduler.Instance, 42, TimeSpan.FromSeconds(-1), _ => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.SchedulePeriodic(ThreadPoolScheduler.Instance, 42, TimeSpan.FromSeconds(1), default(Action<int>)));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.SchedulePeriodic<int>(null, 42, TimeSpan.FromSeconds(1), _ => _));
-            ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Scheduler.SchedulePeriodic<int>(ThreadPoolScheduler.Instance, 42, TimeSpan.FromSeconds(-1), _ => _));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.SchedulePeriodic<int>(ThreadPoolScheduler.Instance, 42, TimeSpan.FromSeconds(1), default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.SchedulePeriodic(null, 42, TimeSpan.FromSeconds(1), _ => _));
+            ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Scheduler.SchedulePeriodic(ThreadPoolScheduler.Instance, 42, TimeSpan.FromSeconds(-1), _ => _));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.SchedulePeriodic(ThreadPoolScheduler.Instance, 42, TimeSpan.FromSeconds(1), default));
         }
 #endif
 

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/SynchronizationContextSchedulerTest.cs

@@ -23,9 +23,9 @@ namespace ReactiveTests.Tests
 
             ReactiveAssert.Throws<ArgumentNullException>(() => new SynchronizationContextScheduler(null));
             ReactiveAssert.Throws<ArgumentNullException>(() => new SynchronizationContextScheduler(null, true));
-            ReactiveAssert.Throws<ArgumentNullException>(() => s.Schedule<int>(42, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => s.Schedule<int>(42, DateTimeOffset.Now, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => s.Schedule<int>(42, TimeSpan.Zero, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => s.Schedule(42, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => s.Schedule(42, DateTimeOffset.Now, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => s.Schedule(42, TimeSpan.Zero, default));
         }
 
         [Fact]
@@ -151,7 +151,7 @@ namespace ReactiveTests.Tests
             var s = new SynchronizationContextScheduler(ms);
 
             var started = 0;
-            s.Schedule<int>(42, TimeSpan.Zero, (self, x) => { started = ms.Started; return Disposable.Empty; });
+            s.Schedule(42, TimeSpan.Zero, (self, x) => { started = ms.Started; return Disposable.Empty; });
 
             Assert.True(started == 1);
             Assert.True(ms.Count == 1);

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/TaskPoolSchedulerTest.cs

@@ -17,9 +17,9 @@ namespace ReactiveTests.Tests
         public void TaskPool_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new TaskPoolScheduler(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => TaskPoolScheduler.Default.Schedule<int>(42, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => TaskPoolScheduler.Default.Schedule<int>(42, DateTimeOffset.Now, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => TaskPoolScheduler.Default.Schedule<int>(42, TimeSpan.Zero, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => TaskPoolScheduler.Default.Schedule(42, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => TaskPoolScheduler.Default.Schedule(42, DateTimeOffset.Now, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => TaskPoolScheduler.Default.Schedule(42, TimeSpan.Zero, default));
             ReactiveAssert.Throws<ArgumentNullException>(() => TaskPoolScheduler.Default.SchedulePeriodic(42, TimeSpan.FromSeconds(1), default));
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => TaskPoolScheduler.Default.SchedulePeriodic(42, TimeSpan.FromSeconds(-1), _ => _));
         }

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ThreadPoolSchedulerTest.cs

@@ -7,7 +7,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reactive.Concurrency;
-using System.Reactive.Disposables;
 using System.Threading;
 using Microsoft.Reactive.Testing;
 using Xunit;
@@ -20,9 +19,9 @@ namespace ReactiveTests.Tests
         [Fact]
         public void Schedule_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.Schedule<int>(42, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.Schedule<int>(42, DateTimeOffset.Now, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.Schedule<int>(42, TimeSpan.Zero, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.Schedule(42, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.Schedule(42, DateTimeOffset.Now, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.Schedule(42, TimeSpan.Zero, default));
         }
 
         [Fact]
@@ -144,7 +143,7 @@ namespace ReactiveTests.Tests
         [Fact]
         public void ScheduleLongRunning_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.ScheduleLongRunning<int>(42, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.ScheduleLongRunning(42, default));
         }
 
         [Fact]
@@ -328,4 +327,4 @@ namespace ReactiveTests.Tests
 #endif
     }
 }
-#endif
+#endif

Rx.NET/Source/tests/Tests.System.Reactive/Tests/ConnectableObservableTest.cs

@@ -21,7 +21,7 @@ namespace ReactiveTests.Tests
             var y = 0;
 
             var s2 = new Subject<int>();
-            var co2 = new ConnectableObservable<int>(Observable.Return<int>(1), s2);
+            var co2 = new ConnectableObservable<int>(Observable.Return(1), s2);
 
             co2.Subscribe(x => y = x);
             Assert.NotEqual(1, y);
@@ -35,7 +35,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),
@@ -64,7 +64,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),
@@ -87,7 +87,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),
@@ -112,7 +112,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),
@@ -145,7 +145,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),

Rx.NET/Source/tests/Tests.System.Reactive/Tests/DefaultConcurrencyAbstractionLayerTest.cs

@@ -4,7 +4,6 @@
 
 #if !NO_REMOTING
 using System;
-using System.IO;
 using System.Reactive.Concurrency;
 using System.Reactive.PlatformServices;
 using System.Runtime.CompilerServices;
@@ -373,4 +372,4 @@ namespace ReactiveTests.Tests
         }
     }
 }
-#endif
+#endif

Rx.NET/Source/tests/Tests.System.Reactive/Tests/EventPatternSourceBaseTest.cs

@@ -49,7 +49,7 @@ namespace ReactiveTests.Tests
         {
             add
             {
-                base.Add(value, GetInvoke(value));
+                Add(value, GetInvoke(value));
             }
 
             remove

Rx.NET/Source/tests/Tests.System.Reactive/Tests/ImmutableListTest.cs

@@ -1,10 +1,12 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information.
 
+#if SIGNED
 using System.Linq;
 using System.Reactive;
 using Xunit;
+#endif
 
 namespace ReactiveTests.Tests
 {

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Internal/ExceptionHelperTest.cs

@@ -11,50 +11,50 @@ namespace ReactiveTests.Tests
 
     public class ExceptionHelperTest
     {
-        private Exception errors;
+        private Exception _errors;
 
         [Fact]
         public void ExceptionHelper_TrySetException_Empty()
         {
             var ex = new InvalidOperationException();
 
-            Assert.True(ExceptionHelper.TrySetException(ref errors, ex));
+            Assert.True(ExceptionHelper.TrySetException(ref _errors, ex));
 
-            Assert.Equal(ex, errors);
+            Assert.Equal(ex, _errors);
         }
 
         [Fact]
         public void ExceptionHelper_TrySetException_Not_Empty()
         {
             var ex1 = new InvalidOperationException();
-            errors = ex1;
+            _errors = ex1;
 
             var ex2 = new NotSupportedException();
 
-            Assert.False(ExceptionHelper.TrySetException(ref errors, ex2));
+            Assert.False(ExceptionHelper.TrySetException(ref _errors, ex2));
 
-            Assert.Equal(ex1, errors);
+            Assert.Equal(ex1, _errors);
         }
 
         [Fact]
         public void ExceptionHelper_TrySetException_Terminate_Empty()
         {
-            var ex = ExceptionHelper.Terminate(ref errors);
+            var ex = ExceptionHelper.Terminate(ref _errors);
 
             Assert.Null(ex);
-            Assert.Equal(errors, ExceptionHelper.Terminated);
+            Assert.Equal(_errors, ExceptionHelper.Terminated);
         }
 
         [Fact]
         public void ExceptionHelper_TrySetException_Terminate_Not_Empty()
         {
             var ex1 = new InvalidOperationException();
-            errors = ex1;
+            _errors = ex1;
 
-            var ex = ExceptionHelper.Terminate(ref errors);
+            var ex = ExceptionHelper.Terminate(ref _errors);
 
             Assert.Equal(ex, ex1);
-            Assert.Equal(errors, ExceptionHelper.Terminated);
+            Assert.Equal(_errors, ExceptionHelper.Terminated);
         }
 
 
@@ -62,17 +62,17 @@ namespace ReactiveTests.Tests
         public void ExceptionHelper_TrySetException_Terminate_Twice()
         {
             var ex1 = new InvalidOperationException();
-            errors = ex1;
+            _errors = ex1;
 
-            var ex = ExceptionHelper.Terminate(ref errors);
+            var ex = ExceptionHelper.Terminate(ref _errors);
 
             Assert.Equal(ex, ex1);
-            Assert.Equal(errors, ExceptionHelper.Terminated);
+            Assert.Equal(_errors, ExceptionHelper.Terminated);
 
-            ex = ExceptionHelper.Terminate(ref errors);
+            ex = ExceptionHelper.Terminate(ref _errors);
 
             Assert.Equal(ex, ExceptionHelper.Terminated);
-            Assert.Equal(errors, ExceptionHelper.Terminated);
+            Assert.Equal(_errors, ExceptionHelper.Terminated);
         }
 
         [Fact]
@@ -80,23 +80,23 @@ namespace ReactiveTests.Tests
         {
             var ex1 = new InvalidOperationException();
 
-            Assert.True(ExceptionHelper.TryAddException(ref errors, ex1));
+            Assert.True(ExceptionHelper.TryAddException(ref _errors, ex1));
 
-            Assert.Equal(ex1, errors);
+            Assert.Equal(ex1, _errors);
         }
 
         [Fact]
         public void ExceptionHelper_TryAddException_Not_Empty()
         {
             var ex1 = new InvalidOperationException();
-            errors = ex1;
+            _errors = ex1;
 
             var ex2 = new NotImplementedException();
 
-            Assert.True(ExceptionHelper.TryAddException(ref errors, ex2));
+            Assert.True(ExceptionHelper.TryAddException(ref _errors, ex2));
 
-            Assert.True(errors is AggregateException);
-            var x = errors as AggregateException;
+            Assert.True(_errors is AggregateException);
+            var x = _errors as AggregateException;
 
             Assert.Equal(2, x.InnerExceptions.Count);
             Assert.True(x.InnerExceptions[0] is InvalidOperationException);
@@ -109,14 +109,14 @@ namespace ReactiveTests.Tests
             var ex1 = new InvalidOperationException();
             var ex2 = new NotImplementedException();
 
-            errors = new AggregateException(ex1, ex2);
+            _errors = new AggregateException(ex1, ex2);
 
             var ex3 = new InvalidCastException();
 
-            Assert.True(ExceptionHelper.TryAddException(ref errors, ex3));
+            Assert.True(ExceptionHelper.TryAddException(ref _errors, ex3));
 
-            Assert.True(errors is AggregateException);
-            var x = errors as AggregateException;
+            Assert.True(_errors is AggregateException);
+            var x = _errors as AggregateException;
 
             Assert.Equal(3, x.InnerExceptions.Count);
             Assert.True(x.InnerExceptions[0] is InvalidOperationException);
@@ -127,13 +127,13 @@ namespace ReactiveTests.Tests
         [Fact]
         public void ExceptionHelper_TryAddException_Terminated()
         {
-            errors = ExceptionHelper.Terminated;
+            _errors = ExceptionHelper.Terminated;
 
             var ex = new InvalidCastException();
 
-            Assert.False(ExceptionHelper.TryAddException(ref errors, ex));
+            Assert.False(ExceptionHelper.TryAddException(ref _errors, ex));
 
-            Assert.Equal(errors, ExceptionHelper.Terminated);
+            Assert.Equal(_errors, ExceptionHelper.Terminated);
         }
     }
 }

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Internal/HalfSerializerTest.cs

@@ -11,22 +11,22 @@ namespace ReactiveTests.Tests
 {
     public class HalfSerializerTest
     {
-        private int wip;
-        private Exception error;
-        private Consumer consumer = new Consumer();
+        private int _wip;
+        private Exception _error;
+        private Consumer _consumer = new Consumer();
 
         [Fact]
         public void HalfSerializer_OnNext()
         {
-            HalfSerializer.ForwardOnNext(consumer, 1, ref wip, ref error);
+            HalfSerializer.ForwardOnNext(_consumer, 1, ref _wip, ref _error);
 
-            Assert.Equal(0, wip);
-            Assert.Null(error);
+            Assert.Equal(0, _wip);
+            Assert.Null(_error);
 
-            Assert.Equal(1, consumer.items.Count);
-            Assert.Equal(1, consumer.items[0]);
-            Assert.Equal(0, consumer.done);
-            Assert.Null(consumer.exc);
+            Assert.Equal(1, _consumer.Items.Count);
+            Assert.Equal(1, _consumer.Items[0]);
+            Assert.Equal(0, _consumer.Done);
+            Assert.Null(_consumer.Exc);
         }
 
         [Fact]
@@ -34,16 +34,16 @@ namespace ReactiveTests.Tests
         {
             var ex = new InvalidOperationException();
 
-            HalfSerializer.ForwardOnError(consumer, ex, ref wip, ref error);
+            HalfSerializer.ForwardOnError(_consumer, ex, ref _wip, ref _error);
 
-            Assert.Equal(1, wip);
-            Assert.Equal(error, ExceptionHelper.Terminated);
+            Assert.Equal(1, _wip);
+            Assert.Equal(_error, ExceptionHelper.Terminated);
 
-            HalfSerializer.ForwardOnNext(consumer, 2, ref wip, ref error);
+            HalfSerializer.ForwardOnNext(_consumer, 2, ref _wip, ref _error);
 
-            Assert.Equal(0, consumer.items.Count);
-            Assert.Equal(0, consumer.done);
-            Assert.Equal(ex, consumer.exc);
+            Assert.Equal(0, _consumer.Items.Count);
+            Assert.Equal(0, _consumer.Done);
+            Assert.Equal(ex, _consumer.Exc);
         }
 
         [Fact]
@@ -51,52 +51,52 @@ namespace ReactiveTests.Tests
         {
             var ex = new InvalidOperationException();
 
-            HalfSerializer.ForwardOnError(consumer, ex, ref wip, ref error);
+            HalfSerializer.ForwardOnError(_consumer, ex, ref _wip, ref _error);
 
-            Assert.Equal(1, wip);
-            Assert.Equal(error, ExceptionHelper.Terminated);
+            Assert.Equal(1, _wip);
+            Assert.Equal(_error, ExceptionHelper.Terminated);
 
-            HalfSerializer.ForwardOnNext(consumer, 2, ref wip, ref error);
+            HalfSerializer.ForwardOnNext(_consumer, 2, ref _wip, ref _error);
             var ex2 = new NotSupportedException();
-            HalfSerializer.ForwardOnError(consumer, ex2, ref wip, ref error);
-            HalfSerializer.ForwardOnCompleted(consumer, ref wip, ref error);
+            HalfSerializer.ForwardOnError(_consumer, ex2, ref _wip, ref _error);
+            HalfSerializer.ForwardOnCompleted(_consumer, ref _wip, ref _error);
 
-            Assert.Equal(0, consumer.items.Count);
-            Assert.Equal(0, consumer.done);
-            Assert.Equal(ex, consumer.exc);
+            Assert.Equal(0, _consumer.Items.Count);
+            Assert.Equal(0, _consumer.Done);
+            Assert.Equal(ex, _consumer.Exc);
         }
 
         [Fact]
         public void HalfSerializer_OnCompleted()
         {
-            HalfSerializer.ForwardOnCompleted(consumer, ref wip, ref error);
+            HalfSerializer.ForwardOnCompleted(_consumer, ref _wip, ref _error);
 
-            Assert.Equal(1, wip);
-            Assert.Equal(error, ExceptionHelper.Terminated);
+            Assert.Equal(1, _wip);
+            Assert.Equal(_error, ExceptionHelper.Terminated);
 
-            HalfSerializer.ForwardOnNext(consumer, 2, ref wip, ref error);
+            HalfSerializer.ForwardOnNext(_consumer, 2, ref _wip, ref _error);
 
-            Assert.Equal(0, consumer.items.Count);
-            Assert.Equal(1, consumer.done);
-            Assert.Null(consumer.exc);
+            Assert.Equal(0, _consumer.Items.Count);
+            Assert.Equal(1, _consumer.Done);
+            Assert.Null(_consumer.Exc);
         }
 
         [Fact]
         public void HalfSerializer_OnCompleted_Ignore_Further_Events()
         {
-            HalfSerializer.ForwardOnCompleted(consumer, ref wip, ref error);
+            HalfSerializer.ForwardOnCompleted(_consumer, ref _wip, ref _error);
 
-            Assert.Equal(1, wip);
-            Assert.Equal(error, ExceptionHelper.Terminated);
+            Assert.Equal(1, _wip);
+            Assert.Equal(_error, ExceptionHelper.Terminated);
 
-            HalfSerializer.ForwardOnNext(consumer, 2, ref wip, ref error);
+            HalfSerializer.ForwardOnNext(_consumer, 2, ref _wip, ref _error);
             var ex2 = new NotSupportedException();
-            HalfSerializer.ForwardOnError(consumer, ex2, ref wip, ref error);
-            HalfSerializer.ForwardOnCompleted(consumer, ref wip, ref error);
+            HalfSerializer.ForwardOnError(_consumer, ex2, ref _wip, ref _error);
+            HalfSerializer.ForwardOnCompleted(_consumer, ref _wip, ref _error);
 
-            Assert.Equal(0, consumer.items.Count);
-            Assert.Equal(1, consumer.done);
-            Assert.Null(consumer.exc);
+            Assert.Equal(0, _consumer.Items.Count);
+            Assert.Equal(1, _consumer.Done);
+            Assert.Null(_consumer.Exc);
         }
 
         // Practically simulates concurrent invocation of the HalfSerializer methods
@@ -105,15 +105,15 @@ namespace ReactiveTests.Tests
         {
             var c = new ReentrantConsumer(this, true);
 
-            HalfSerializer.ForwardOnNext(c, 1, ref wip, ref error);
+            HalfSerializer.ForwardOnNext(c, 1, ref _wip, ref _error);
 
-            Assert.Equal(1, wip);
-            Assert.Equal(error, ExceptionHelper.Terminated);
+            Assert.Equal(1, _wip);
+            Assert.Equal(_error, ExceptionHelper.Terminated);
 
-            Assert.Equal(1, consumer.items.Count);
-            Assert.Equal(1, consumer.items[0]);
-            Assert.Equal(0, consumer.done);
-            Assert.Equal(c.x, consumer.exc);
+            Assert.Equal(1, _consumer.Items.Count);
+            Assert.Equal(1, _consumer.Items[0]);
+            Assert.Equal(0, _consumer.Done);
+            Assert.Equal(c.X, _consumer.Exc);
         }
 
         // Practically simulates concurrent invocation of the HalfSerializer methods
@@ -122,73 +122,73 @@ namespace ReactiveTests.Tests
         {
             var c = new ReentrantConsumer(this, false);
 
-            HalfSerializer.ForwardOnNext(c, 1, ref wip, ref error);
+            HalfSerializer.ForwardOnNext(c, 1, ref _wip, ref _error);
 
-            Assert.Equal(1, wip);
-            Assert.Equal(error, ExceptionHelper.Terminated);
+            Assert.Equal(1, _wip);
+            Assert.Equal(_error, ExceptionHelper.Terminated);
 
-            Assert.Equal(1, consumer.items.Count);
-            Assert.Equal(1, consumer.items[0]);
-            Assert.Equal(1, consumer.done);
-            Assert.Null(consumer.exc);
+            Assert.Equal(1, _consumer.Items.Count);
+            Assert.Equal(1, _consumer.Items[0]);
+            Assert.Equal(1, _consumer.Done);
+            Assert.Null(_consumer.Exc);
         }
 
         private sealed class Consumer : ISink<int>
         {
-            internal List<int> items = new List<int>();
+            internal List<int> Items = new List<int>();
 
-            internal int done;
-            internal Exception exc;
+            internal int Done;
+            internal Exception Exc;
 
             public void ForwardOnCompleted()
             {
-                done++;
+                Done++;
             }
 
             public void ForwardOnError(Exception error)
             {
-                exc = error;
+                Exc = error;
             }
 
             public void ForwardOnNext(int value)
             {
-                items.Add(value);
+                Items.Add(value);
             }
         }
 
         private sealed class ReentrantConsumer : ISink<int>
         {
-            private readonly HalfSerializerTest parent;
-            private readonly bool errorReenter;
+            private readonly HalfSerializerTest _parent;
+            private readonly bool _errorReenter;
 
-            internal readonly Exception x = new IndexOutOfRangeException();
+            internal readonly Exception X = new IndexOutOfRangeException();
 
             public ReentrantConsumer(HalfSerializerTest parent, bool errorReenter)
             {
-                this.parent = parent;
-                this.errorReenter = errorReenter;
+                this._parent = parent;
+                this._errorReenter = errorReenter;
             }
 
             public void ForwardOnCompleted()
             {
-                parent.consumer.ForwardOnCompleted();
+                _parent._consumer.ForwardOnCompleted();
             }
 
             public void ForwardOnError(Exception error)
             {
-                parent.consumer.ForwardOnError(error);
+                _parent._consumer.ForwardOnError(error);
             }
 
             public void ForwardOnNext(int value)
             {
-                parent.consumer.ForwardOnNext(value);
-                if (errorReenter)
+                _parent._consumer.ForwardOnNext(value);
+                if (_errorReenter)
                 {
-                    HalfSerializer.ForwardOnError(this, x, ref parent.wip, ref parent.error);
+                    HalfSerializer.ForwardOnError(this, X, ref _parent._wip, ref _parent._error);
                 }
                 else
                 {
-                    HalfSerializer.ForwardOnCompleted(this, ref parent.wip, ref parent.error);
+                    HalfSerializer.ForwardOnCompleted(this, ref _parent._wip, ref _parent._error);
                 }
             }
         }

Rx.NET/Source/tests/Tests.System.Reactive/Tests/LicenseHeaderTest.cs

@@ -14,8 +14,8 @@ namespace Tests.System.Reactive.Tests
     /// </summary>
     public class LicenseHeaderTest
     {
-        private static readonly bool fixHeaders = true;
-        private static readonly string[] lines = {
+        private static readonly bool FixHeaders = true;
+        private static readonly string[] Lines = {
             "// Licensed to the .NET Foundation under one or more agreements.",
             "// The .NET Foundation licenses this file to you under the Apache 2.0 License.",
             "// See the LICENSE file in the project root for more information.",
@@ -64,17 +64,17 @@ namespace Tests.System.Reactive.Tests
                 // analysis
                 var content = File.ReadAllText(file);
 
-                if (!content.StartsWith(lines[0]))
+                if (!content.StartsWith(Lines[0]))
                 {
                     count++;
                     error.Append(file).Append("\r\n");
 
-                    if (fixHeaders)
+                    if (FixHeaders)
                     {
                         var newContent = new StringBuilder();
                         var separator = content.Contains("\r\n") ? "\r\n" : "\n";
 
-                        foreach (var s in lines)
+                        foreach (var s in Lines)
                         {
                             newContent.Append(s).Append(separator);
                         }

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AggregateTest.cs

@@ -17,13 +17,13 @@ namespace ReactiveTests.Tests
         public void Aggregate_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Aggregate<int, int>(default, 1, (x, y) => x + y));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Aggregate<int, int>(DummyObservable<int>.Instance, 1, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Aggregate(DummyObservable<int>.Instance, 1, default));
 
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Aggregate<int>(default, (x, y) => x + y));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Aggregate<int>(DummyObservable<int>.Instance, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Aggregate(DummyObservable<int>.Instance, default));
 
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Aggregate<int, int, int>(default, 1, (x, y) => x + y, x => x));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Aggregate<int, int, int>(DummyObservable<int>.Instance, 1, default, x => x));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Aggregate(DummyObservable<int>.Instance, 1, default, x => x));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Aggregate<int, int, int>(DummyObservable<int>.Instance, 1, (x, y) => x + y, default));
         }
 
@@ -67,7 +67,7 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(250, 42 + 24),
+                OnNext(250, 42 + 24),
                 OnCompleted<int>(250)
             );
 
@@ -225,7 +225,7 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(250, (42 + 24) * 5),
+                OnNext(250, (42 + 24) * 5),
                 OnCompleted<int>(250)
             );
 
@@ -412,7 +412,7 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(250, 24),
+                OnNext(250, 24),
                 OnCompleted<int>(250)
             );
 

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AndTest.cs

@@ -20,20 +20,20 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(null, someObservable));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, null));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
         }
 
         [Fact]

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AverageTest.cs

@@ -1415,7 +1415,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "b"),
                 OnNext(220, "fo"),
                 OnNext(230, "qux"),
@@ -1439,7 +1439,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "b"),
                 OnNext(220, "fo"),
                 OnNext(230, "qux"),
@@ -1463,7 +1463,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "b"),
                 OnNext(220, "fo"),
                 OnNext(230, "qux"),
@@ -1487,7 +1487,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "b"),
                 OnNext(220, "fo"),
                 OnNext(230, "qux"),
@@ -1511,7 +1511,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "b"),
                 OnNext(220, "fo"),
                 OnNext(230, "qux"),
@@ -1535,7 +1535,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "b"),
                 OnNext(220, "fo"),
                 OnNext(230, "qux"),
@@ -1559,7 +1559,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "b"),
                 OnNext(220, "fo"),
                 OnNext(230, "qux"),
@@ -1583,7 +1583,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "b"),
                 OnNext(220, "fo"),
                 OnNext(230, "qux"),
@@ -1607,7 +1607,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "b"),
                 OnNext(220, "fo"),
                 OnNext(230, "qux"),
@@ -1631,7 +1631,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "b"),
                 OnNext(220, "fo"),
                 OnNext(230, "qux"),

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AwaitTest.cs

@@ -18,7 +18,7 @@ namespace ReactiveTests.Tests
         [Fact]
         public void Await_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.GetAwaiter<int>(default(IObservable<int>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.GetAwaiter(default(IObservable<int>)));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.GetAwaiter<int>(default));
 
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.GetAwaiter(Observable.Empty<int>()).OnCompleted(null));

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CastTest.cs

@@ -26,7 +26,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<object>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext<object>(210, new B(0)),
                 OnNext<object>(220, new D(1)),
                 OnNext<object>(240, new B(2)),
@@ -39,9 +39,9 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<B>(210, new B(0)),
+                OnNext(210, new B(0)),
                 OnNext<B>(220, new D(1)),
-                OnNext<B>(240, new B(2)),
+                OnNext(240, new B(2)),
                 OnNext<B>(270, new D(3)),
                 OnCompleted<B>(300)
             );
@@ -58,7 +58,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<object>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext<object>(210, new B(0)),
                 OnNext<object>(220, new D(1)),
                 OnNext<object>(240, new B(2)),
@@ -71,9 +71,9 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<B>(210, new B(0)),
+                OnNext(210, new B(0)),
                 OnNext<B>(220, new D(1)),
-                OnNext<B>(240, new B(2)),
+                OnNext(240, new B(2)),
                 OnNext<B>(270, new D(3)),
                 OnError<B>(300, ex)
             );
@@ -88,7 +88,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<object>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext<object>(210, new B(0)),
                 OnNext<object>(220, new D(1)),
                 OnNext<object>(240, new B(2)),
@@ -102,9 +102,9 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<B>(210, new B(0)),
+                OnNext(210, new B(0)),
                 OnNext<B>(220, new D(1)),
-                OnNext<B>(240, new B(2))
+                OnNext(240, new B(2))
             );
 
             xs.Subscriptions.AssertEqual(
@@ -117,7 +117,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<object>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext<object>(210, new B(0)),
                 OnNext<object>(220, new D(1)),
                 OnNext<object>(240, new B(2)),
@@ -131,9 +131,9 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<B>(210, new B(0)),
+                OnNext(210, new B(0)),
                 OnNext<B>(220, new D(1)),
-                OnNext<B>(240, new B(2)),
+                OnNext(240, new B(2)),
                 OnError<B>(250, e => e is InvalidCastException)
             );
 
@@ -149,7 +149,7 @@ namespace ReactiveTests.Tests
 
         public A(int id)
         {
-            this._id = id;
+            _id = id;
         }
 
         public bool Equals(A other)
@@ -203,7 +203,7 @@ namespace ReactiveTests.Tests
 
         public E(int id)
         {
-            this._id = id;
+            _id = id;
         }
 
         public bool Equals(E other)

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CatchTest.cs

@@ -22,9 +22,9 @@ namespace ReactiveTests.Tests
         public void Catch_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Catch<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Catch<int>((IEnumerable<IObservable<int>>)null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Catch<int>(DummyObservable<int>.Instance, null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Catch<int>(null, DummyObservable<int>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Catch((IEnumerable<IObservable<int>>)null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Catch(DummyObservable<int>.Instance, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Catch(null, DummyObservable<int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Catch<int, Exception>(null, _ => DummyObservable<int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Catch<int, Exception>(DummyObservable<int>.Instance, null));
         }
@@ -52,20 +52,20 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs1 = scheduler.CreateColdObservable<int>(
+            var xs1 = scheduler.CreateColdObservable(
                 OnNext(10, 1),
                 OnNext(20, 2),
                 OnNext(30, 3),
                 OnError<int>(40, new Exception())
             );
 
-            var xs2 = scheduler.CreateColdObservable<int>(
+            var xs2 = scheduler.CreateColdObservable(
                 OnNext(10, 4),
                 OnNext(20, 5),
                 OnError<int>(30, new Exception())
             );
 
-            var xs3 = scheduler.CreateColdObservable<int>(
+            var xs3 = scheduler.CreateColdObservable(
                 OnNext(10, 6),
                 OnNext(20, 7),
                 OnNext(30, 8),
@@ -728,7 +728,7 @@ namespace ReactiveTests.Tests
             var scheduler = new TestScheduler();
 
             var res = scheduler.Start(() =>
-                Observable.Catch<int>((IEnumerable<IObservable<int>>)new IObservable<int>[0])
+                Observable.Catch((IEnumerable<IObservable<int>>)new IObservable<int>[0])
             );
 
             res.Messages.AssertEqual(
@@ -743,7 +743,7 @@ namespace ReactiveTests.Tests
             var ex = new Exception();
 
             var res = scheduler.Start(() =>
-                Observable.Catch<int>(Catch_IteratorThrows_Source(ex, true))
+                Observable.Catch(Catch_IteratorThrows_Source(ex, true))
             );
 
             res.Messages.AssertEqual(
@@ -928,7 +928,7 @@ namespace ReactiveTests.Tests
 
             var scheduler = new TestScheduler();
 
-            var o = scheduler.CreateColdObservable<int>(
+            var o = scheduler.CreateColdObservable(
                 OnNext(10, 1),
                 OnNext(20, 2),
                 OnNext(30, 3),

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CollectTest.cs

@@ -181,7 +181,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
             var n = 0;
-            var ys = xs.Collect<int, int>(() =>
+            var ys = xs.Collect(() =>
             {
                 if (n++ == 0)
                 {
@@ -232,7 +232,7 @@ namespace ReactiveTests.Tests
             );
 
             var ex = new Exception();
-            var ys = xs.Collect<int, int>(() => 0, (x, y) => x + y, x => { throw ex; });
+            var ys = xs.Collect(() => 0, (x, y) => x + y, x => { throw ex; });
             var e = default(IEnumerator<int>);
 
             var ex_ = default(Exception);
@@ -273,7 +273,7 @@ namespace ReactiveTests.Tests
             );
 
             var ex = new Exception();
-            var ys = xs.Collect<int, int>(() => 0, (x, y) => { throw ex; });
+            var ys = xs.Collect(() => 0, (x, y) => { throw ex; });
             var e = default(IEnumerator<int>);
 
             var ex_ = default(Exception);

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CombineLatestTest.cs

@@ -3702,7 +3702,7 @@ namespace ReactiveTests.Tests
             var e2 = scheduler.CreateHotObservable(new[] { OnNext(150, 1), OnNext(230, 3), OnNext(260, 6), OnCompleted<int>(290) });
 
             var res = scheduler.Start(() =>
-                Observable.CombineLatest<int>(new IObservable<int>[] { e0, e1, e2 }.AsEnumerable())
+                Observable.CombineLatest(new IObservable<int>[] { e0, e1, e2 }.AsEnumerable())
             );
 
             res.Messages.AssertEqual(
@@ -3771,10 +3771,10 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(230, new[] { 1, 2, 3 }.Sum()),
-                OnNext<int>(240, new[] { 1, 5, 3 }.Sum()),
-                OnNext<int>(250, new[] { 4, 5, 3 }.Sum()),
-                OnNext<int>(260, new[] { 4, 5, 6 }.Sum()),
+                OnNext(230, new[] { 1, 2, 3 }.Sum()),
+                OnNext(240, new[] { 1, 5, 3 }.Sum()),
+                OnNext(250, new[] { 4, 5, 3 }.Sum()),
+                OnNext(260, new[] { 4, 5, 6 }.Sum()),
                 OnCompleted<int>(420)
             );
 
@@ -3842,13 +3842,13 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(230, new[] { 1, 2, 3 }.Sum()),
-                OnNext<int>(240, new[] { 1, 5, 3 }.Sum()),
-                OnNext<int>(250, new[] { 4, 5, 3 }.Sum()),
-                OnNext<int>(260, new[] { 4, 5, 6 }.Sum()),
-                OnNext<int>(280, new[] { 4, 5, 8 }.Sum()),
-                OnNext<int>(290, new[] { 4, 7, 8 }.Sum()),
-                OnNext<int>(310, new[] { 4, 9, 8 }.Sum()),
+                OnNext(230, new[] { 1, 2, 3 }.Sum()),
+                OnNext(240, new[] { 1, 5, 3 }.Sum()),
+                OnNext(250, new[] { 4, 5, 3 }.Sum()),
+                OnNext(260, new[] { 4, 5, 6 }.Sum()),
+                OnNext(280, new[] { 4, 5, 8 }.Sum()),
+                OnNext(290, new[] { 4, 7, 8 }.Sum()),
+                OnNext(310, new[] { 4, 9, 8 }.Sum()),
                 OnCompleted<int>(410)
             );
 
@@ -3915,8 +3915,8 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(230, new[] { 1, 2, 3 }.Sum()),
-                OnNext<int>(240, new[] { 1, 5, 3 }.Sum()),
+                OnNext(230, new[] { 1, 2, 3 }.Sum()),
+                OnNext(240, new[] { 1, 5, 3 }.Sum()),
                 OnError<int>(250, ex)
             );
 

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ConcatTest.cs

@@ -92,20 +92,20 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs1 = scheduler.CreateColdObservable<int>(
+            var xs1 = scheduler.CreateColdObservable(
                 OnNext(10, 1),
                 OnNext(20, 2),
                 OnNext(30, 3),
                 OnCompleted<int>(40)
             );
 
-            var xs2 = scheduler.CreateColdObservable<int>(
+            var xs2 = scheduler.CreateColdObservable(
                 OnNext(10, 4),
                 OnNext(20, 5),
                 OnCompleted<int>(30)
             );
 
-            var xs3 = scheduler.CreateColdObservable<int>(
+            var xs3 = scheduler.CreateColdObservable(
                 OnNext(10, 6),
                 OnNext(20, 7),
                 OnNext(30, 8),
@@ -864,7 +864,7 @@ namespace ReactiveTests.Tests
             var invoked = default(long);
 
             var xs = o1;
-            var ys = Observable.Defer<int>(new Func<IObservable<int>>(() => { invoked = scheduler.Clock; throw ex; }));
+            var ys = Observable.Defer(new Func<IObservable<int>>(() => { invoked = scheduler.Clock; throw ex; }));
 
             var res = scheduler.Start(() =>
                 xs.Concat(ys)
@@ -892,7 +892,7 @@ namespace ReactiveTests.Tests
 
             var scheduler = new TestScheduler();
 
-            var o = scheduler.CreateColdObservable<int>(
+            var o = scheduler.CreateColdObservable(
                 OnNext(10, 1),
                 OnNext(20, 2),
                 OnNext(30, 3),

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CreateAsyncTest.cs

@@ -22,12 +22,12 @@ namespace ReactiveTests.Tests
         [Fact]
         public void CreateAsync_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create<int>(default(Func<IObserver<int>, Task>)));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create<int>(default(Func<IObserver<int>, CancellationToken, Task>)));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create<int>(default(Func<IObserver<int>, Task<IDisposable>>)));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create<int>(default(Func<IObserver<int>, CancellationToken, Task<IDisposable>>)));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create<int>(default(Func<IObserver<int>, Task<Action>>)));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create<int>(default(Func<IObserver<int>, CancellationToken, Task<Action>>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create(default(Func<IObserver<int>, Task>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create(default(Func<IObserver<int>, CancellationToken, Task>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create(default(Func<IObserver<int>, Task<IDisposable>>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create(default(Func<IObserver<int>, CancellationToken, Task<IDisposable>>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create(default(Func<IObserver<int>, Task<Action>>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create(default(Func<IObserver<int>, CancellationToken, Task<Action>>)));
         }
 
         [Fact]

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CreateTest.cs

@@ -21,7 +21,7 @@ namespace ReactiveTests.Tests
         [Fact]
         public void Create_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create<int>(default(Func<IObserver<int>, Action>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create(default(Func<IObserver<int>, Action>)));
 
             //
             // BREAKING CHANGE v2.0 > v1.x - Returning null from Subscribe means "nothing to do upon unsubscription"
@@ -121,7 +121,7 @@ namespace ReactiveTests.Tests
         public void Create_Exception()
         {
             ReactiveAssert.Throws<InvalidOperationException>(() =>
-                Observable.Create<int>(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).Subscribe());
+                Observable.Create(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).Subscribe());
         }
 
         [Fact]
@@ -203,7 +203,7 @@ namespace ReactiveTests.Tests
         [Fact]
         public void CreateWithDisposable_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create<int>(default(Func<IObserver<int>, IDisposable>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create(default(Func<IObserver<int>, IDisposable>)));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create<int>(o => DummyDisposable.Instance).Subscribe(null));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create<int>(o =>
             {
@@ -296,7 +296,7 @@ namespace ReactiveTests.Tests
         public void CreateWithDisposable_Exception()
         {
             ReactiveAssert.Throws<InvalidOperationException>(() =>
-                Observable.Create<int>(new Func<IObserver<int>, IDisposable>(o => { throw new InvalidOperationException(); })).Subscribe());
+                Observable.Create(new Func<IObserver<int>, IDisposable>(o => { throw new InvalidOperationException(); })).Subscribe());
         }
 
         [Fact]
@@ -379,20 +379,20 @@ namespace ReactiveTests.Tests
         public void Iterate_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.Create<int>(default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.Create(DummyFunc<IObserver<int>, IEnumerable<IObservable<Object>>>.Instance).Subscribe(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.Create(DummyFunc<IObserver<int>, IEnumerable<IObservable<object>>>.Instance).Subscribe(null));
         }
 
-        private IEnumerable<IObservable<Object>> ToIterate_Complete(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs, IObserver<int> observer)
+        private IEnumerable<IObservable<object>> ToIterate_Complete(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs, IObserver<int> observer)
         {
             observer.OnNext(1);
-            yield return xs.Select(x => new Object());
+            yield return xs.Select(x => new object());
 
             observer.OnNext(2);
-            yield return ys.Select(x => new Object());
+            yield return ys.Select(x => new object());
 
             observer.OnNext(3);
             observer.OnCompleted();
-            yield return zs.Select(x => new Object());
+            yield return zs.Select(x => new object());
 
             observer.OnNext(4);
         }
@@ -447,16 +447,16 @@ namespace ReactiveTests.Tests
             );
         }
 
-        private IEnumerable<IObservable<Object>> ToIterate_Complete_Implicit(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs, IObserver<int> observer)
+        private IEnumerable<IObservable<object>> ToIterate_Complete_Implicit(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs, IObserver<int> observer)
         {
             observer.OnNext(1);
-            yield return xs.Select(x => new Object());
+            yield return xs.Select(x => new object());
 
             observer.OnNext(2);
-            yield return ys.Select(x => new Object());
+            yield return ys.Select(x => new object());
 
             observer.OnNext(3);
-            yield return zs.Select(x => new Object());
+            yield return zs.Select(x => new object());
 
             observer.OnNext(4);
         }
@@ -512,13 +512,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        private IEnumerable<IObservable<Object>> ToIterate_Throw(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs, IObserver<int> observer, Exception ex)
+        private IEnumerable<IObservable<object>> ToIterate_Throw(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs, IObserver<int> observer, Exception ex)
         {
             observer.OnNext(1);
-            yield return xs.Select(x => new Object());
+            yield return xs.Select(x => new object());
 
             observer.OnNext(2);
-            yield return ys.Select(x => new Object());
+            yield return ys.Select(x => new object());
 
             observer.OnNext(3);
 
@@ -527,7 +527,7 @@ namespace ReactiveTests.Tests
                 throw ex;
             }
 
-            yield return zs.Select(x => new Object());
+            yield return zs.Select(x => new object());
 
             observer.OnNext(4);
             observer.OnCompleted();
@@ -584,19 +584,19 @@ namespace ReactiveTests.Tests
             );
         }
 
-        private IEnumerable<IObservable<Object>> ToIterate_Error(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs, IObserver<int> observer, Exception ex)
+        private IEnumerable<IObservable<object>> ToIterate_Error(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs, IObserver<int> observer, Exception ex)
         {
             observer.OnNext(1);
-            yield return xs.Select(x => new Object());
+            yield return xs.Select(x => new object());
 
             observer.OnNext(2);
             observer.OnError(ex);
 
-            yield return ys.Select(x => new Object());
+            yield return ys.Select(x => new object());
 
             observer.OnNext(3);
 
-            yield return zs.Select(x => new Object());
+            yield return zs.Select(x => new object());
 
             observer.OnNext(4);
             observer.OnCompleted();
@@ -652,16 +652,16 @@ namespace ReactiveTests.Tests
             );
         }
 
-        private IEnumerable<IObservable<Object>> ToIterate_Complete_Dispose(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs, IObserver<int> observer)
+        private IEnumerable<IObservable<object>> ToIterate_Complete_Dispose(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs, IObserver<int> observer)
         {
             observer.OnNext(1);
-            yield return xs.Select(x => new Object());
+            yield return xs.Select(x => new object());
 
             observer.OnNext(2);
-            yield return ys.Select(x => new Object());
+            yield return ys.Select(x => new object());
 
             observer.OnNext(3);
-            yield return zs.Select(x => new Object());
+            yield return zs.Select(x => new object());
 
             observer.OnNext(4);
         }
@@ -727,7 +727,7 @@ namespace ReactiveTests.Tests
             xs.AssertEqual(new[] { 100, 1000 }.ToObservable());
         }
 
-        private static IEnumerable<IObservable<Object>> _IteratorScenario(int x, int y, IObserver<int> results)
+        private static IEnumerable<IObservable<object>> _IteratorScenario(int x, int y, IObserver<int> results)
         {
             var xs = Observable.Range(1, x).ToListObservable();
             yield return xs;
@@ -744,16 +744,16 @@ namespace ReactiveTests.Tests
         public void Iterate_Void_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.Create(default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.Create(DummyFunc<IEnumerable<IObservable<Object>>>.Instance).Subscribe(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.Create(DummyFunc<IEnumerable<IObservable<object>>>.Instance).Subscribe(null));
         }
 
-        private IEnumerable<IObservable<Object>> ToIterate_Void_Complete(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs)
+        private IEnumerable<IObservable<object>> ToIterate_Void_Complete(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs)
         {
-            yield return xs.Select(x => new Object());
+            yield return xs.Select(x => new object());
 
-            yield return ys.Select(x => new Object());
+            yield return ys.Select(x => new object());
 
-            yield return zs.Select(x => new Object());
+            yield return zs.Select(x => new object());
         }
 
         [Fact]
@@ -803,13 +803,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        private IEnumerable<IObservable<Object>> ToIterate_Void_Complete_Implicit(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs)
+        private IEnumerable<IObservable<object>> ToIterate_Void_Complete_Implicit(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs)
         {
-            yield return xs.Select(x => new Object());
+            yield return xs.Select(x => new object());
 
-            yield return ys.Select(x => new Object());
+            yield return ys.Select(x => new object());
 
-            yield return zs.Select(x => new Object());
+            yield return zs.Select(x => new object());
         }
 
         [Fact]
@@ -859,18 +859,18 @@ namespace ReactiveTests.Tests
             );
         }
 
-        private IEnumerable<IObservable<Object>> ToIterate_Void_Throw(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs, Exception ex)
+        private IEnumerable<IObservable<object>> ToIterate_Void_Throw(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs, Exception ex)
         {
-            yield return xs.Select(x => new Object());
+            yield return xs.Select(x => new object());
 
-            yield return ys.Select(x => new Object());
+            yield return ys.Select(x => new object());
 
             if (xs != null)
             {
                 throw ex;
             }
 
-            yield return zs.Select(x => new Object());
+            yield return zs.Select(x => new object());
         }
 
         [Fact]
@@ -921,13 +921,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        private IEnumerable<IObservable<Object>> ToIterate_Void_Complete_Dispose(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs)
+        private IEnumerable<IObservable<object>> ToIterate_Void_Complete_Dispose(IObservable<int> xs, IObservable<int> ys, IObservable<int> zs)
         {
-            yield return xs.Select(x => new Object());
+            yield return xs.Select(x => new object());
 
-            yield return ys.Select(x => new Object());
+            yield return ys.Select(x => new object());
 
-            yield return zs.Select(x => new Object());
+            yield return zs.Select(x => new object());
         }
 
         [Fact]
@@ -994,7 +994,7 @@ namespace ReactiveTests.Tests
             Assert.IsType<InvalidOperationException>(notification.Exception);
         }
 
-        private static IEnumerable<IObservable<Object>> _IteratorScenario_Void(int x, int y)
+        private static IEnumerable<IObservable<object>> _IteratorScenario_Void(int x, int y)
         {
             var xs = Observable.Range(1, x).ToListObservable();
             yield return xs;

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DeferAsyncTest.cs

@@ -25,7 +25,7 @@ namespace ReactiveTests.Tests
         [Fact]
         public void DeferAsync_Simple()
         {
-            var xs = Observable.Defer<int>(() => Task.Factory.StartNew(() => Observable.Return(42)));
+            var xs = Observable.Defer(() => Task.Factory.StartNew(() => Observable.Return(42)));
 
             var res = xs.ToEnumerable().ToList();
 
@@ -35,7 +35,7 @@ namespace ReactiveTests.Tests
         [Fact]
         public void DeferAsync_WithCancel_Simple()
         {
-            var xs = Observable.DeferAsync<int>(ct => Task.Factory.StartNew(() => Observable.Return(42)));
+            var xs = Observable.DeferAsync(ct => Task.Factory.StartNew(() => Observable.Return(42)));
 
             var res = xs.ToEnumerable().ToList();
 
@@ -51,7 +51,7 @@ namespace ReactiveTests.Tests
                 var e = new ManualResetEvent(false);
                 var called = false;
 
-                var xs = Observable.DeferAsync<int>(ct => Task.Factory.StartNew(() =>
+                var xs = Observable.DeferAsync(ct => Task.Factory.StartNew(() =>
                 {
                     e.Set();
 

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DeferTest.cs

@@ -16,9 +16,9 @@ namespace ReactiveTests.Tests
         [Fact]
         public void Defer_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Defer<int>(default(Func<IObservable<int>>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Defer(default(Func<IObservable<int>>)));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Defer(() => DummyObservable<int>.Instance).Subscribe(null));
-            ReactiveAssert.Throws</*some*/Exception>(() => Observable.Defer<int>(() => default(IObservable<int>)).Subscribe());
+            ReactiveAssert.Throws</*some*/Exception>(() => Observable.Defer(() => default(IObservable<int>)).Subscribe());
         }
 
         [Fact]
@@ -34,7 +34,7 @@ namespace ReactiveTests.Tests
                 {
                     invoked++;
                     xs = scheduler.CreateColdObservable(
-                        OnNext<long>(100, scheduler.Clock),
+                        OnNext(100, scheduler.Clock),
                         OnCompleted<long>(200));
                     return xs;
                 })
@@ -66,7 +66,7 @@ namespace ReactiveTests.Tests
                 {
                     invoked++;
                     xs = scheduler.CreateColdObservable(
-                        OnNext<long>(100, scheduler.Clock),
+                        OnNext(100, scheduler.Clock),
                         OnError<long>(200, ex));
                     return xs;
                 })
@@ -97,7 +97,7 @@ namespace ReactiveTests.Tests
                 {
                     invoked++;
                     xs = scheduler.CreateColdObservable(
-                        OnNext<long>(100, scheduler.Clock),
+                        OnNext(100, scheduler.Clock),
                         OnNext<long>(200, invoked),
                         OnNext<long>(1100, 1000));
                     return xs;
@@ -125,7 +125,7 @@ namespace ReactiveTests.Tests
             var ex = new Exception();
 
             var res = scheduler.Start(() =>
-                Observable.Defer<int>(new Func<IObservable<int>>(() =>
+                Observable.Defer(new Func<IObservable<int>>(() =>
                 {
                     invoked++;
                     throw ex;

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DelayTest.cs

@@ -1191,7 +1191,7 @@ namespace ReactiveTests.Tests
             );
 
             var ys = scheduler.CreateColdObservable(
-                OnNext<string>(80, "")
+                OnNext(80, "")
             );
 
             var res = scheduler.Start(() =>
@@ -1244,9 +1244,9 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(250 + 2 * 10, 2),
-                OnNext<int>(350 + 3 * 10, 3),
-                OnNext<int>(450 + 4 * 10, 4),
+                OnNext(250 + 2 * 10, 2),
+                OnNext(350 + 3 * 10, 3),
+                OnNext(450 + 4 * 10, 4),
                 OnCompleted<int>(550)
             );
 
@@ -1278,9 +1278,9 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(250 + 2 * 10, 2),
-                OnNext<int>(350 + 3 * 10, 3),
-                OnNext<int>(450 + 4 * 10, 4),
+                OnNext(250 + 2 * 10, 2),
+                OnNext(350 + 3 * 10, 3),
+                OnNext(450 + 4 * 10, 4),
                 OnCompleted<int>(450 + 4 * 10)
             );
 
@@ -1317,8 +1317,8 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(250 + 2 * 10, 2),
-                OnNext<int>(350 + 3 * 10, 3),
+                OnNext(250 + 2 * 10, 2),
+                OnNext(350 + 3 * 10, 3),
                 OnError<int>(450 + 4 * 10, ex)
             );
 
@@ -1352,8 +1352,8 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(250 + 2 * 10, 2),
-                OnNext<int>(350 + 3 * 10, 3),
+                OnNext(250 + 2 * 10, 2),
+                OnNext(350 + 3 * 10, 3),
                 OnError<int>(460, ex)
             );
 
@@ -1395,8 +1395,8 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(250 + 2 * 10, 2),
-                OnNext<int>(350 + 3 * 10, 3),
+                OnNext(250 + 2 * 10, 2),
+                OnNext(350 + 3 * 10, 3),
                 OnError<int>(450, ex)
             );
 
@@ -1429,9 +1429,9 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(250 + 2 * 10, 2),
-                OnNext<int>(350 + 3 * 10, 3),
-                OnNext<int>(450 + 4 * 10, 4),
+                OnNext(250 + 2 * 10, 2),
+                OnNext(350 + 3 * 10, 3),
+                OnNext(450 + 4 * 10, 4),
                 OnCompleted<int>(550)
             );
 
@@ -1473,9 +1473,9 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(250 + 20, 0),
-                OnNext<int>(350 + 10, 1),
-                OnNext<int>(450 + 30, 2),
+                OnNext(250 + 20, 0),
+                OnNext(350 + 10, 1),
+                OnNext(450 + 30, 2),
                 OnCompleted<int>(550)
             );
 
@@ -1584,7 +1584,7 @@ namespace ReactiveTests.Tests
             );
 
             var ys = scheduler.CreateColdObservable(
-                OnNext<string>(10, "!")
+                OnNext(10, "!")
             );
 
             var res = scheduler.Start(() =>
@@ -1621,7 +1621,7 @@ namespace ReactiveTests.Tests
             );
 
             var ys = scheduler.CreateColdObservable(
-                OnNext<string>(100, "!")
+                OnNext(100, "!")
             );
 
             var res = scheduler.Start(() =>

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DistinctUntilChangedTest.cs

@@ -19,13 +19,13 @@ namespace ReactiveTests.Tests
             var someObservable = Observable.Empty<int>();
 
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DistinctUntilChanged<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DistinctUntilChanged<int>(null, EqualityComparer<int>.Default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DistinctUntilChanged<int>(someObservable, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DistinctUntilChanged(null, EqualityComparer<int>.Default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DistinctUntilChanged(someObservable, null));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DistinctUntilChanged<int, int>(null, _ => _));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DistinctUntilChanged<int, int>(someObservable, null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DistinctUntilChanged<int, int>(someObservable, _ => _, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DistinctUntilChanged(someObservable, _ => _, null));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DistinctUntilChanged<int, int>(null, _ => _, EqualityComparer<int>.Default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DistinctUntilChanged<int, int>(someObservable, null, EqualityComparer<int>.Default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DistinctUntilChanged(someObservable, null, EqualityComparer<int>.Default));
         }
 
         [Fact]

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DoTest.cs

@@ -18,20 +18,20 @@ namespace ReactiveTests.Tests
         {
             var someObservable = Observable.Empty<int>();
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do<int>(someObservable, (Action<int>)null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do(someObservable, (Action<int>)null));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do<int>(null, _ => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do<int>(someObservable, x => { }, (Action)null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do<int>(someObservable, null, () => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do(someObservable, x => { }, (Action)null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do(someObservable, null, () => { }));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do<int>(null, x => { }, () => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do<int>(someObservable, x => { }, (Action<Exception>)null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do<int>(someObservable, null, (Exception _) => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do(someObservable, x => { }, (Action<Exception>)null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do(someObservable, null, (Exception _) => { }));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do<int>(null, x => { }, (Exception _) => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do<int>(someObservable, x => { }, (Exception _) => { }, null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do<int>(someObservable, x => { }, null, () => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do<int>(someObservable, null, (Exception _) => { }, () => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do(someObservable, x => { }, (Exception _) => { }, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do(someObservable, x => { }, null, () => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do(someObservable, null, (Exception _) => { }, () => { }));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do<int>(null, x => { }, (Exception _) => { }, () => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do<int>(null, Observer.Create<int>(i => { })));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do<int>(someObservable, default(IObserver<int>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do(null, Observer.Create<int>(i => { })));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do(someObservable, default(IObserver<int>)));
         }
 
         [Fact]

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/EmptyTest.cs

@@ -19,7 +19,7 @@ namespace ReactiveTests.Tests
         public void Empty_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Empty<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Empty<int>(null, 42));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Empty(null, 42));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Empty<int>(DummyScheduler.Instance).Subscribe(null));
         }
 
@@ -75,7 +75,7 @@ namespace ReactiveTests.Tests
             var scheduler = new TestScheduler();
 
             var res = scheduler.Start(() =>
-                Observable.Empty<int>(scheduler, 42)
+                Observable.Empty(scheduler, 42)
             );
 
             res.Messages.AssertEqual(
@@ -88,7 +88,7 @@ namespace ReactiveTests.Tests
         {
             var e = new ManualResetEvent(false);
 
-            Observable.Empty<int>(42).Subscribe(
+            Observable.Empty(42).Subscribe(
                 _ => { Assert.True(false); },
                 _ => { Assert.True(false); },
                 () => e.Set()

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ExpandTest.cs

@@ -71,7 +71,7 @@ namespace ReactiveTests.Tests
             );
 
             var res = scheduler.Start(() =>
-                xs.Expand(x => scheduler.CreateColdObservable<int>(
+                xs.Expand(x => scheduler.CreateColdObservable(
                     OnNext(100 + x, 2 * x),
                     OnNext(200 + x, 3 * x),
                     OnCompleted<int>(300 + x)
@@ -96,7 +96,7 @@ namespace ReactiveTests.Tests
             );
 
             var res = scheduler.Start(() =>
-                xs.Expand(x => scheduler.CreateColdObservable<int>(
+                xs.Expand(x => scheduler.CreateColdObservable(
                     OnNext(100 + x, 2 * x),
                     OnNext(200 + x, 3 * x),
                     OnCompleted<int>(300 + x)

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FinallyTest.cs

@@ -18,7 +18,7 @@ namespace ReactiveTests.Tests
             var someObservable = Observable.Empty<int>();
 
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Finally<int>(null, () => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Finally<int>(someObservable, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Finally(someObservable, null));
         }
 
         [Fact]

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstOrDefaultTest.cs

@@ -41,7 +41,7 @@ namespace ReactiveTests.Tests
         public void FirstOrDefault_Return()
         {
             var value = 42;
-            Assert.Equal(value, Observable.Return<int>(value).FirstOrDefault());
+            Assert.Equal(value, Observable.Return(value).FirstOrDefault());
         }
 
         [Fact]

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstTest.cs

@@ -38,21 +38,21 @@ namespace ReactiveTests.Tests
         public void First_Return()
         {
             var value = 42;
-            Assert.Equal(value, Observable.Return<int>(value).First());
+            Assert.Equal(value, Observable.Return(value).First());
         }
 
         [Fact]
         public void FirstPredicate_Return()
         {
             var value = 42;
-            Assert.Equal(value, Observable.Return<int>(value).First(i => i % 2 == 0));
+            Assert.Equal(value, Observable.Return(value).First(i => i % 2 == 0));
         }
 
         [Fact]
         public void FirstPredicate_Return_NoMatch()
         {
             var value = 42;
-            ReactiveAssert.Throws<InvalidOperationException>(() => Observable.Return<int>(value).First(i => i % 2 != 0));
+            ReactiveAssert.Throws<InvalidOperationException>(() => Observable.Return(value).First(i => i % 2 != 0));
         }
 
         [Fact]

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForTest.cs

@@ -27,9 +27,9 @@ namespace ReactiveTests.Tests
             var scheduler = new TestScheduler();
 
             var results = scheduler.Start(() => Observable.For(new[] { 1, 2, 3 }, x => scheduler.CreateColdObservable(
-                OnNext<int>((ushort)(x * 100 + 10), x * 10 + 1),
-                OnNext<int>((ushort)(x * 100 + 20), x * 10 + 2),
-                OnNext<int>((ushort)(x * 100 + 30), x * 10 + 3),
+                OnNext((ushort)(x * 100 + 10), x * 10 + 1),
+                OnNext((ushort)(x * 100 + 20), x * 10 + 2),
+                OnNext((ushort)(x * 100 + 30), x * 10 + 3),
                 OnCompleted<int>((ushort)(x * 100 + 40)))));
 
             results.Messages.AssertEqual(
@@ -62,9 +62,9 @@ namespace ReactiveTests.Tests
             var ex = new Exception();
 
             var results = scheduler.Start(() => Observable.For(For_Error_Core(ex), x => scheduler.CreateColdObservable(
-                OnNext<int>((ushort)(x * 100 + 10), x * 10 + 1),
-                OnNext<int>((ushort)(x * 100 + 20), x * 10 + 2),
-                OnNext<int>((ushort)(x * 100 + 30), x * 10 + 3),
+                OnNext((ushort)(x * 100 + 10), x * 10 + 1),
+                OnNext((ushort)(x * 100 + 20), x * 10 + 2),
+                OnNext((ushort)(x * 100 + 30), x * 10 + 3),
                 OnCompleted<int>((ushort)(x * 100 + 40)))));
 
             results.Messages.AssertEqual(

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForkJoinTest.cs

@@ -582,7 +582,7 @@ namespace ReactiveTests.Tests
                 OnCompleted<int>(220)
             );
 
-            var results = scheduler.Start(() => xs.ForkJoin<int, int, int>(ys, (x, y) => x + y));
+            var results = scheduler.Start(() => xs.ForkJoin(ys, (x, y) => x + y));
 
             results.Messages.AssertEqual(
                 OnCompleted<int>(220)
@@ -611,7 +611,7 @@ namespace ReactiveTests.Tests
                 OnCompleted<int>(220)
             );
 
-            var results = scheduler.Start(() => xs.ForkJoin<int, int, int>(ys, (x, y) => x + y));
+            var results = scheduler.Start(() => xs.ForkJoin(ys, (x, y) => x + y));
 
             results.Messages.AssertEqual(
                 OnCompleted<int>(220)

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromAsyncPatternTest.cs

@@ -28,7 +28,7 @@ namespace ReactiveTests.Tests
         public void FromAsyncPattern_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsyncPattern(null, iar => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsyncPattern<int>(null, iar => 0));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsyncPattern(null, iar => 0));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsyncPattern<int>(null, iar => { }));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsyncPattern<int, int>(null, iar => 0));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsyncPattern<int, int>(null, iar => { }));
@@ -99,7 +99,7 @@ namespace ReactiveTests.Tests
             Func<IAsyncResult, int> end = iar => { Assert.Same(x, iar); return 1; };
 
             var res = Observable.FromAsyncPattern(begin, end)().Materialize().ToEnumerable().ToArray();
-            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext<int>(1), Notification.CreateOnCompleted<int>() }));
+            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
         [Fact]
@@ -154,7 +154,7 @@ namespace ReactiveTests.Tests
             Func<IAsyncResult, int> end = iar => { Assert.Same(x, iar); return 1; };
 
             var res = Observable.FromAsyncPattern(begin, end)(2).Materialize().ToEnumerable().ToArray();
-            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext<int>(1), Notification.CreateOnCompleted<int>() }));
+            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
         [Fact]
@@ -215,7 +215,7 @@ namespace ReactiveTests.Tests
             Func<IAsyncResult, int> end = iar => { Assert.Same(x, iar); return 1; };
 
             var res = Observable.FromAsyncPattern(begin, end)(2, 3).Materialize().ToEnumerable().ToArray();
-            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext<int>(1), Notification.CreateOnCompleted<int>() }));
+            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
         [Fact]
@@ -278,7 +278,7 @@ namespace ReactiveTests.Tests
             Func<IAsyncResult, int> end = iar => { Assert.Same(x, iar); return 1; };
 
             var res = Observable.FromAsyncPattern(begin, end)(2, 3, 4).Materialize().ToEnumerable().ToArray();
-            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext<int>(1), Notification.CreateOnCompleted<int>() }));
+            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
         [Fact]
         public void FromAsyncPatternAction3()
@@ -342,7 +342,7 @@ namespace ReactiveTests.Tests
             Func<IAsyncResult, int> end = iar => { Assert.Same(x, iar); return 1; };
 
             var res = Observable.FromAsyncPattern(begin, end)(2, 3, 4, 5).Materialize().ToEnumerable().ToArray();
-            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext<int>(1), Notification.CreateOnCompleted<int>() }));
+            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
         [Fact]
@@ -409,7 +409,7 @@ namespace ReactiveTests.Tests
             Func<IAsyncResult, int> end = iar => { Assert.Same(x, iar); return 1; };
 
             var res = Observable.FromAsyncPattern(begin, end)(2, 3, 4, 5, 6).Materialize().ToEnumerable().ToArray();
-            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext<int>(1), Notification.CreateOnCompleted<int>() }));
+            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
         [Fact]
@@ -478,7 +478,7 @@ namespace ReactiveTests.Tests
             Func<IAsyncResult, int> end = iar => { Assert.Same(x, iar); return 1; };
 
             var res = Observable.FromAsyncPattern(begin, end)(2, 3, 4, 5, 6, 7).Materialize().ToEnumerable().ToArray();
-            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext<int>(1), Notification.CreateOnCompleted<int>() }));
+            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
         [Fact]
@@ -549,7 +549,7 @@ namespace ReactiveTests.Tests
             Func<IAsyncResult, int> end = iar => { Assert.Same(x, iar); return 1; };
 
             var res = Observable.FromAsyncPattern(begin, end)(2, 3, 4, 5, 6, 7, 8).Materialize().ToEnumerable().ToArray();
-            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext<int>(1), Notification.CreateOnCompleted<int>() }));
+            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
         [Fact]
@@ -622,7 +622,7 @@ namespace ReactiveTests.Tests
             Func<IAsyncResult, int> end = iar => { Assert.Same(x, iar); return 1; };
 
             var res = Observable.FromAsyncPattern(begin, end)(2, 3, 4, 5, 6, 7, 8, 9).Materialize().ToEnumerable().ToArray();
-            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext<int>(1), Notification.CreateOnCompleted<int>() }));
+            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
         [Fact]
@@ -697,7 +697,7 @@ namespace ReactiveTests.Tests
             Func<IAsyncResult, int> end = iar => { Assert.Same(x, iar); return 1; };
 
             var res = Observable.FromAsyncPattern(begin, end)(2, 3, 4, 5, 6, 7, 8, 9, 10).Materialize().ToEnumerable().ToArray();
-            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext<int>(1), Notification.CreateOnCompleted<int>() }));
+            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
         [Fact]
@@ -774,7 +774,7 @@ namespace ReactiveTests.Tests
             Func<IAsyncResult, int> end = iar => { Assert.Same(x, iar); return 1; };
 
             var res = Observable.FromAsyncPattern(begin, end)(2, 3, 4, 5, 6, 7, 8, 9, 10, 11).Materialize().ToEnumerable().ToArray();
-            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext<int>(1), Notification.CreateOnCompleted<int>() }));
+            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
         [Fact]
@@ -853,7 +853,7 @@ namespace ReactiveTests.Tests
             Func<IAsyncResult, int> end = iar => { Assert.Same(x, iar); return 1; };
 
             var res = Observable.FromAsyncPattern(begin, end)(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12).Materialize().ToEnumerable().ToArray();
-            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext<int>(1), Notification.CreateOnCompleted<int>() }));
+            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
         [Fact]
@@ -934,7 +934,7 @@ namespace ReactiveTests.Tests
             Func<IAsyncResult, int> end = iar => { Assert.Same(x, iar); return 1; };
 
             var res = Observable.FromAsyncPattern(begin, end)(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13).Materialize().ToEnumerable().ToArray();
-            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext<int>(1), Notification.CreateOnCompleted<int>() }));
+            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
         [Fact]
@@ -1017,7 +1017,7 @@ namespace ReactiveTests.Tests
             Func<IAsyncResult, int> end = iar => { Assert.Same(x, iar); return 1; };
 
             var res = Observable.FromAsyncPattern(begin, end)(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14).Materialize().ToEnumerable().ToArray();
-            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext<int>(1), Notification.CreateOnCompleted<int>() }));
+            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
         [Fact]
@@ -1102,7 +1102,7 @@ namespace ReactiveTests.Tests
             Func<IAsyncResult, int> end = iar => { Assert.Same(x, iar); return 1; };
 
             var res = Observable.FromAsyncPattern(begin, end)(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15).Materialize().ToEnumerable().ToArray();
-            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext<int>(1), Notification.CreateOnCompleted<int>() }));
+            Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
         [Fact]

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromAsyncTest.cs

@@ -32,13 +32,13 @@ namespace ReactiveTests.Tests
         {
             var s = Scheduler.Immediate;
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsync<int>(default(Func<Task<int>>)));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsync<int>(default(Func<CancellationToken, Task<int>>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsync(default(Func<Task<int>>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsync(default(Func<CancellationToken, Task<int>>)));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsync<int>(default(Func<Task<int>>), s));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsync<int>(() => _doneTask, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsync<int>(default(Func<CancellationToken, Task<int>>), s));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsync<int>(ct => _doneTask, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsync(default(Func<Task<int>>), s));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsync(() => _doneTask, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsync(default(Func<CancellationToken, Task<int>>), s));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsync(ct => _doneTask, default));
         }
 
         [Fact]
@@ -78,7 +78,7 @@ namespace ReactiveTests.Tests
         {
             var ex = new Exception();
 
-            var xs = Observable.FromAsync<int>(() =>
+            var xs = Observable.FromAsync(() =>
                 Task.Factory.StartNew<int>(() => { throw ex; })
             );
 
@@ -122,7 +122,7 @@ namespace ReactiveTests.Tests
         {
             var ex = new Exception();
 
-            var xs = Observable.FromAsync<int>(ct =>
+            var xs = Observable.FromAsync(ct =>
                 Task.Factory.StartNew<int>(() => { throw ex; })
             );
 

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromEventPatternTest.cs

@@ -832,7 +832,7 @@ namespace ReactiveTests.Tests
         public event EventHandler E5;
         public void M5(int i)
         {
-            E5?.Invoke(this, new FromEventPattern.TestEventArgs { Id = i });
+            E5?.Invoke(this, new TestEventArgs { Id = i });
         }
 
         public static event EventHandler<TestEventArgs> E6;
@@ -944,8 +944,8 @@ namespace ReactiveTests.Tests
 
         public override void Post(SendOrPostCallback d, object state)
         {
-            var old = SynchronizationContext.Current;
-            SynchronizationContext.SetSynchronizationContext(this);
+            var old = Current;
+            SetSynchronizationContext(this);
             try
             {
                 PostCount++;
@@ -953,7 +953,7 @@ namespace ReactiveTests.Tests
             }
             finally
             {
-                SynchronizationContext.SetSynchronizationContext(old);
+                SetSynchronizationContext(old);
             }
         }
     }

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromEventTest.cs

@@ -283,7 +283,7 @@ namespace ReactiveTests.Tests
 
                 addEvt.WaitOne();
 
-                subscribeOnCtx = object.ReferenceEquals(addCtx, ctx);
+                subscribeOnCtx = ReferenceEquals(addCtx, ctx);
 
                 src.OnBar(42);
                 fstNext = res.SequenceEqual(new[] { 42 });
@@ -303,7 +303,7 @@ namespace ReactiveTests.Tests
 
                 remEvt.WaitOne();
 
-                disposeOnCtx = object.ReferenceEquals(remCtx, ctx);
+                disposeOnCtx = ReferenceEquals(remCtx, ctx);
 
                 src.OnBar(44);
                 thdNext = res.SequenceEqual(new[] { 42, 43 });

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GetEnumeratorTest.cs

@@ -27,7 +27,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateColdObservable<int>(
+            var xs = scheduler.CreateColdObservable(
                 OnNext(10, 2),
                 OnNext(20, 3),
                 OnNext(30, 5),
@@ -79,7 +79,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateColdObservable<int>(
+            var xs = scheduler.CreateColdObservable(
                 OnNext(10, 2),
                 OnNext(30, 3),
                 OnNext(50, 5),
@@ -131,7 +131,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateColdObservable<int>(
+            var xs = scheduler.CreateColdObservable(
                 OnNext(10, 2),
                 OnNext(30, 3),
                 OnNext(50, 5),

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GroupByTest.cs

@@ -3480,18 +3480,18 @@ namespace ReactiveTests.Tests
 
     internal class GroupByComparer : IEqualityComparer<string>
     {
-        private TestScheduler scheduler;
-        private readonly int equalsThrowsAfter;
-        private readonly ushort getHashCodeThrowsAfter;
+        private TestScheduler _scheduler;
+        private readonly int _equalsThrowsAfter;
+        private readonly ushort _getHashCodeThrowsAfter;
 
         public Exception HashCodeException = new Exception();
         public Exception EqualsException = new Exception();
 
         public GroupByComparer(TestScheduler scheduler, ushort equalsThrowsAfter, ushort getHashCodeThrowsAfter)
         {
-            this.scheduler = scheduler;
-            this.equalsThrowsAfter = equalsThrowsAfter;
-            this.getHashCodeThrowsAfter = getHashCodeThrowsAfter;
+            this._scheduler = scheduler;
+            this._equalsThrowsAfter = equalsThrowsAfter;
+            this._getHashCodeThrowsAfter = getHashCodeThrowsAfter;
         }
 
         public GroupByComparer(TestScheduler scheduler)
@@ -3501,7 +3501,7 @@ namespace ReactiveTests.Tests
 
         public bool Equals(string x, string y)
         {
-            if (scheduler.Clock > equalsThrowsAfter)
+            if (_scheduler.Clock > _equalsThrowsAfter)
             {
                 throw EqualsException;
             }
@@ -3511,7 +3511,7 @@ namespace ReactiveTests.Tests
 
         public int GetHashCode(string obj)
         {
-            if (scheduler.Clock > getHashCodeThrowsAfter)
+            if (_scheduler.Clock > _getHashCodeThrowsAfter)
             {
                 throw HashCodeException;
             }

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IfTest.cs

@@ -157,7 +157,7 @@ namespace ReactiveTests.Tests
         [Fact]
         public void If_Default_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.If<int>(null, DummyObservable<int>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.If(null, DummyObservable<int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.If<int>(DummyFunc<bool>.Instance, null));
         }
 

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastOrDefaultTest.cs

@@ -38,7 +38,7 @@ namespace ReactiveTests.Tests
         public void LastOrDefault_Return()
         {
             var value = 42;
-            Assert.Equal(value, Observable.Return<int>(value).LastOrDefault());
+            Assert.Equal(value, Observable.Return(value).LastOrDefault());
         }
 
         [Fact]

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastTest.cs

@@ -38,7 +38,7 @@ namespace ReactiveTests.Tests
         public void Last_Return()
         {
             var value = 42;
-            Assert.Equal(value, Observable.Return<int>(value).Last());
+            Assert.Equal(value, Observable.Return(value).Last());
         }
 
         [Fact]

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LatestTest.cs

@@ -73,7 +73,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ManySelectTest.cs

@@ -18,10 +18,10 @@ namespace ReactiveTests.Tests
         [Fact]
         public void ManySelect_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.ManySelect<int, int>(null, DummyFunc<IObservable<int>, int>.Instance, DummyScheduler.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.ManySelect(null, DummyFunc<IObservable<int>, int>.Instance, DummyScheduler.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.ManySelect<int, int>(DummyObservable<int>.Instance, null, DummyScheduler.Instance));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.ManySelect<int, int>(DummyObservable<int>.Instance, DummyFunc<IObservable<int>, int>.Instance, null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.ManySelect<int, int>(null, DummyFunc<IObservable<int>, int>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.ManySelect(DummyObservable<int>.Instance, DummyFunc<IObservable<int>, int>.Instance, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.ManySelect(null, DummyFunc<IObservable<int>, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.ManySelect<int, int>(DummyObservable<int>.Instance, null));
         }
 

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MaxTest.cs

@@ -2105,7 +2105,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2129,7 +2129,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2153,7 +2153,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2177,7 +2177,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2201,7 +2201,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2225,7 +2225,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2249,7 +2249,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2273,7 +2273,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2297,7 +2297,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2321,7 +2321,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2345,7 +2345,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "bar"),
                 OnNext(220, "qux"),
                 OnNext(230, "foo"),
@@ -2369,7 +2369,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "bar"),
                 OnNext(220, "qux"),
                 OnNext(230, "foo"),

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MergeTest.cs

@@ -43,7 +43,7 @@ namespace ReactiveTests.Tests
         [Fact]
         public void Merge_DefaultScheduler()
         {
-            var xs = Observable.Merge<int>(Observable.Return(42), Observable.Return(43), Observable.Return(44));
+            var xs = Observable.Merge(Observable.Return(42), Observable.Return(43), Observable.Return(44));
             var res = xs.ToList().Single();
             Assert.True(new[] { 42, 43, 44 }.SequenceEqual(res));
         }
@@ -1164,7 +1164,7 @@ namespace ReactiveTests.Tests
                 OnCompleted<int>(300)
             );
 
-            var xs = scheduler.CreateHotObservable<IObservable<int>>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext<IObservable<int>>(210, ys1),
                 OnNext<IObservable<int>>(260, ys2),
                 OnNext<IObservable<int>>(270, ys3),

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MinTest.cs

@@ -2106,7 +2106,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2130,7 +2130,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2154,7 +2154,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2178,7 +2178,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2202,7 +2202,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2226,7 +2226,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2250,7 +2250,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2274,7 +2274,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2298,7 +2298,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2322,7 +2322,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "fo"),
                 OnNext(220, "b"),
                 OnNext(230, "qux"),
@@ -2346,7 +2346,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "qux"),
                 OnNext(220, "foo"),
                 OnNext(230, "bar"),
@@ -2370,7 +2370,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<string>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, "qux"),
                 OnNext(220, "foo"),
                 OnNext(230, "bar"),

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MostRecentTest.cs

@@ -73,7 +73,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MulticastTest.cs

@@ -19,9 +19,9 @@ namespace ReactiveTests.Tests
         [Fact]
         public void Multicast_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Multicast<int, int>(null, new Subject<int>()));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Multicast(null, new Subject<int>()));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Multicast<int, int>(DummyObservable<int>.Instance, null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Multicast<int, int, int>(null, () => new Subject<int>(), xs => xs));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Multicast(null, () => new Subject<int>(), xs => xs));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Multicast<int, int, int>(DummyObservable<int>.Instance, null, xs => xs));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Multicast<int, int, int>(DummyObservable<int>.Instance, () => new Subject<int>(), null));
         }

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/NeverTest.cs

@@ -16,7 +16,7 @@ namespace ReactiveTests.Tests
         public void Never_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Never<int>().Subscribe(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Never<int>(42).Subscribe(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Never(42).Subscribe(null));
         }
 
         [Fact]
@@ -41,7 +41,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = Observable.Never<int>(42);
+            var xs = Observable.Never(42);
 
             var res = scheduler.CreateObserver<int>();
 

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/NextTest.cs

@@ -70,7 +70,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ObserveOnTest.cs

@@ -51,7 +51,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => DispatcherObservable.ObserveOnDispatcher<int>(default(IObservable<int>)));
 #endif
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ObserveOn<int>(default, new SynchronizationContext()));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ObserveOn<int>(someObservable, default(SynchronizationContext)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ObserveOn(someObservable, default(SynchronizationContext)));
         }
 
 #if HAS_WINFORMS
@@ -649,16 +649,16 @@ namespace ReactiveTests.Tests
 
     internal class MyCtx : SynchronizationContext
     {
-        private IScheduler scheduler;
+        private IScheduler _scheduler;
 
         public MyCtx(IScheduler scheduler)
         {
-            this.scheduler = scheduler;
+            _scheduler = scheduler;
         }
 
         public override void Post(SendOrPostCallback d, object state)
         {
-            scheduler.Schedule(state, (self, s) => { d(s); return Disposable.Empty; });
+            _scheduler.Schedule(state, (self, s) => { d(s); return Disposable.Empty; });
         }
     }
 }

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/OfTypeTest.cs

@@ -26,7 +26,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<object>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext<object>(210, new B(0)),
                 OnNext<object>(220, new A(1)),
                 OnNext<object>(230, new E(2)),
@@ -49,12 +49,12 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<B>(210, new B(0)),
+                OnNext(210, new B(0)),
                 OnNext<B>(240, new D(3)),
-                OnNext<B>(260, new B(5)),
-                OnNext<B>(270, new B(6)),
+                OnNext(260, new B(5)),
+                OnNext(270, new B(6)),
                 OnNext<B>(280, new D(7)),
-                OnNext<B>(340, new B(10)),
+                OnNext(340, new B(10)),
                 OnCompleted<B>(350)
             );
 
@@ -70,7 +70,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<object>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext<object>(210, new B(0)),
                 OnNext<object>(220, new A(1)),
                 OnNext<object>(230, new E(2)),
@@ -93,12 +93,12 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<B>(210, new B(0)),
+                OnNext(210, new B(0)),
                 OnNext<B>(240, new D(3)),
-                OnNext<B>(260, new B(5)),
-                OnNext<B>(270, new B(6)),
+                OnNext(260, new B(5)),
+                OnNext(270, new B(6)),
                 OnNext<B>(280, new D(7)),
-                OnNext<B>(340, new B(10)),
+                OnNext(340, new B(10)),
                 OnError<B>(350, ex)
             );
 
@@ -112,7 +112,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<object>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext<object>(210, new B(0)),
                 OnNext<object>(220, new A(1)),
                 OnNext<object>(230, new E(2)),
@@ -136,10 +136,10 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<B>(210, new B(0)),
+                OnNext(210, new B(0)),
                 OnNext<B>(240, new D(3)),
-                OnNext<B>(260, new B(5)),
-                OnNext<B>(270, new B(6))
+                OnNext(260, new B(5)),
+                OnNext(270, new B(6))
             );
 
             xs.Subscriptions.AssertEqual(

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/OnErrorResumeNextTest.cs

@@ -23,11 +23,11 @@ namespace ReactiveTests.Tests
             var xs = DummyObservable<int>.Instance;
 
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.OnErrorResumeNext<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.OnErrorResumeNext<int>((IEnumerable<IObservable<int>>)null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.OnErrorResumeNext<int>(null, xs));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.OnErrorResumeNext<int>(xs, null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.OnErrorResumeNext<int>(null, xs));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.OnErrorResumeNext<int>(xs, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.OnErrorResumeNext((IEnumerable<IObservable<int>>)null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.OnErrorResumeNext(null, xs));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.OnErrorResumeNext(xs, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.OnErrorResumeNext(null, xs));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.OnErrorResumeNext(xs, null));
         }
 
         [Fact]
@@ -53,20 +53,20 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs1 = scheduler.CreateColdObservable<int>(
+            var xs1 = scheduler.CreateColdObservable(
                 OnNext(10, 1),
                 OnNext(20, 2),
                 OnNext(30, 3),
                 OnCompleted<int>(40)
             );
 
-            var xs2 = scheduler.CreateColdObservable<int>(
+            var xs2 = scheduler.CreateColdObservable(
                 OnNext(10, 4),
                 OnNext(20, 5),
                 OnError<int>(30, new Exception())
             );
 
-            var xs3 = scheduler.CreateColdObservable<int>(
+            var xs3 = scheduler.CreateColdObservable(
                 OnNext(10, 6),
                 OnNext(20, 7),
                 OnNext(30, 8),
@@ -247,7 +247,7 @@ namespace ReactiveTests.Tests
             );
 
             var o5 = scheduler.CreateHotObservable(
-                OnNext<int>(245, 5),
+                OnNext(245, 5),
                 OnCompleted<int>(250)
             );
 
@@ -463,7 +463,7 @@ namespace ReactiveTests.Tests
             var ex = new Exception();
 
             var res = scheduler.Start(() =>
-                Observable.OnErrorResumeNext<int>(Catch_IteratorThrows_Source(ex, true))
+                Observable.OnErrorResumeNext(Catch_IteratorThrows_Source(ex, true))
             );
 
             res.Messages.AssertEqual(
@@ -640,7 +640,7 @@ namespace ReactiveTests.Tests
 
             var scheduler = new TestScheduler();
 
-            var o = scheduler.CreateColdObservable<int>(
+            var o = scheduler.CreateColdObservable(
                 OnNext(10, 1),
                 OnNext(20, 2),
                 OnNext(30, 3),

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RefCountTest.cs

@@ -24,7 +24,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),
@@ -112,7 +112,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),
@@ -188,7 +188,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),
@@ -284,7 +284,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RepeatTest.cs

@@ -358,7 +358,7 @@ namespace ReactiveTests.Tests
 
             scheduler3.Start();
 
-            var xss = Observable.Create<int>(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).Repeat();
+            var xss = Observable.Create(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).Repeat();
 
             ReactiveAssert.Throws<InvalidOperationException>(() => xss.Subscribe());
         }
@@ -529,7 +529,7 @@ namespace ReactiveTests.Tests
 
             scheduler3.Start();
 
-            var xss = Observable.Create<int>(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).Repeat(3);
+            var xss = Observable.Create(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).Repeat(3);
 
             ReactiveAssert.Throws<InvalidOperationException>(() => xss.Subscribe());
         }
@@ -537,7 +537,7 @@ namespace ReactiveTests.Tests
         [Fact]
         public void Repeat_Observable_RepeatCount_Default_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Repeat<int>(default(IObservable<int>), 0));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Repeat(default(IObservable<int>), 0));
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => DummyObservable<int>.Instance.Repeat(-1));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.Repeat(0).Subscribe(null));
         }

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RepeatWhenTest.cs

@@ -59,7 +59,7 @@ namespace ReactiveTests.Tests
             var ex = new InvalidOperationException();
 
             var res = scheduler.Start(() =>
-                xs.RepeatWhen<int, object>(v => v.Select<object, object>(w => throw ex))
+                xs.RepeatWhen(v => v.Select<object, object>(w => throw ex))
             );
 
             res.Messages.AssertEqual(
@@ -83,7 +83,7 @@ namespace ReactiveTests.Tests
             var ex = new InvalidOperationException();
 
             var res = scheduler.Start(() =>
-                xs.RepeatWhen<int, object>(v => v.Take(1).Skip(1))
+                xs.RepeatWhen(v => v.Take(1).Skip(1))
             );
 
             res.Messages.AssertEqual(
@@ -289,7 +289,7 @@ namespace ReactiveTests.Tests
 
             scheduler3.Start();
 
-            var xss = Observable.Create<int>(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).RepeatWhen(v => v);
+            var xss = Observable.Create(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).RepeatWhen(v => v);
 
             ReactiveAssert.Throws<InvalidOperationException>(() => xss.Subscribe());
         }
@@ -473,7 +473,7 @@ namespace ReactiveTests.Tests
 
             scheduler3.Start();
 
-            var xss = Observable.Create<int>(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).RepeatWhen(v =>
+            var xss = Observable.Create(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).RepeatWhen(v =>
             {
                 var count = 0;
                 return v.TakeWhile(w => ++count < 3);