4.x: Clean unnecessary arguments, fix field namings, use patterns, inline out vars

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/Linq/Observable/Repeat.cs

@@ -28,7 +28,7 @@ namespace System.Reactive.Linq.ObservableImpl
             {
                 private readonly TResult _value;
 
-                IDisposable _task;
+                private IDisposable _task;
 
                 public _(TResult value, IObserver<TResult> observer)
                     : base(observer)
@@ -127,9 +127,9 @@ namespace System.Reactive.Linq.ObservableImpl
             {
                 private readonly TResult _value;
 
-                int _remaining;
+                private int _remaining;
 
-                IDisposable _task;
+                private IDisposable _task;
 
                 public _(TResult value, int repeatCount, IObserver<TResult> observer)
                     : base(observer)
@@ -197,8 +197,7 @@ namespace System.Reactive.Linq.ObservableImpl
             {
                 private readonly TResult _value;
 
-                int _remaining;
-
+                private readonly int _remaining;
                 public _(TResult value, int remaining, IObserver<TResult> observer)
                     : base(observer)
                 {

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

@@ -26,9 +26,9 @@ namespace System.Reactive.Linq.ObservableImpl
 
         internal sealed class _ : IdentitySink<TSource>
         {
-            IEnumerator<TSource> _enumerator;
+            private IEnumerator<TSource> _enumerator;
 
-            volatile bool _disposed;
+            private volatile bool _disposed;
 
             public _(IObserver<TSource> observer)
                 : base(observer)

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);

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

@@ -26,15 +26,15 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay(default(IObservable<int>), x => x));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay<int, int>(someObservable, null));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay<int>(null, DummyScheduler.Instance));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay<int>(DummyObservable<int>.Instance, null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay<int, int>(null, DummyFunc<IObservable<int>, IObservable<int>>.Instance, DummyScheduler.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay(DummyObservable<int>.Instance, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay(null, DummyFunc<IObservable<int>, IObservable<int>>.Instance, DummyScheduler.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay<int, int>(DummyObservable<int>.Instance, null, DummyScheduler.Instance));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay<int, int>(DummyObservable<int>.Instance, DummyFunc<IObservable<int>, IObservable<int>>.Instance, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay(DummyObservable<int>.Instance, DummyFunc<IObservable<int>, IObservable<int>>.Instance, null));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay(default(IObservable<int>), TimeSpan.FromSeconds(1)));
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Observable.Replay(someObservable, TimeSpan.FromSeconds(-1)));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay(default(IObservable<int>), x => x, TimeSpan.FromSeconds(1)));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay<int, int>(someObservable, null, TimeSpan.FromSeconds(1)));
-            ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Observable.Replay<int, int>(someObservable, x => x, TimeSpan.FromSeconds(-1)));
+            ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Observable.Replay(someObservable, x => x, TimeSpan.FromSeconds(-1)));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay(default(IObservable<int>), TimeSpan.FromSeconds(1), scheduler));
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Observable.Replay(someObservable, TimeSpan.FromSeconds(-1), scheduler));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay(someObservable, TimeSpan.FromSeconds(1), default));

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

@@ -331,7 +331,7 @@ namespace ReactiveTests.Tests
 
             ReactiveAssert.Throws<InvalidOperationException>(() => scheduler3.Start());
 
-            var xss = Observable.Create<int>(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).Retry(3);
+            var xss = Observable.Create(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).Retry(3);
 
             ReactiveAssert.Throws<InvalidOperationException>(() => xss.Subscribe());
         }

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

@@ -20,7 +20,7 @@ namespace ReactiveTests.Tests
         {
             var ct = CancellationToken.None;
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.RunAsync<int>(default(IObservable<int>), ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.RunAsync(default(IObservable<int>), ct));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.RunAsync<int>(default, ct));
         }
 

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

@@ -18,9 +18,9 @@ namespace ReactiveTests.Tests
             var someObservable = Observable.Empty<int>();
 
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Scan<int>(null, (_, __) => 0));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Scan<int>(someObservable, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Scan(someObservable, null));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Scan<int, int>(null, 0, (_, __) => 0));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Scan<int, int>(someObservable, 0, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Scan(someObservable, 0, null));
         }
 
         [Fact]

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

@@ -416,7 +416,7 @@ namespace ReactiveTests.Tests
         [Fact]
         public void SelectMany_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int>(DummyFunc<int, IObservable<int>>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, IObservable<int>>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, IObservable<int>>)null));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany(DummyFunc<int, IObservable<int>>.Instance).Subscribe(null));
         }
@@ -1003,7 +1003,7 @@ namespace ReactiveTests.Tests
         [Fact]
         public void SelectManyWithIndex_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int>(DummyFunc<int, int, IObservable<int>>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, int, IObservable<int>>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, int, IObservable<int>>)null));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany(DummyFunc<int, int, IObservable<int>>.Instance).Subscribe(null));
         }
@@ -1622,11 +1622,11 @@ namespace ReactiveTests.Tests
         [Fact]
         public void SelectMany_Enumerable_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int>(DummyFunc<int, IEnumerable<int>>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, IEnumerable<int>>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, IEnumerable<int>>)null));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany(DummyFunc<int, IEnumerable<int>>.Instance).Subscribe(null));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int, int>(DummyFunc<int, IEnumerable<int>>.Instance, DummyFunc<int, int, int>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, IEnumerable<int>>.Instance, DummyFunc<int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, IEnumerable<int>>)null, DummyFunc<int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany(DummyFunc<int, IEnumerable<int>>.Instance, (Func<int, int, int>)null));
         }
@@ -2063,18 +2063,18 @@ namespace ReactiveTests.Tests
 
         private class CurrentThrowsEnumerable<T> : IEnumerable<T>
         {
-            private IEnumerable<T> e;
-            private readonly Exception ex;
+            private IEnumerable<T> _e;
+            private readonly Exception _ex;
 
             public CurrentThrowsEnumerable(IEnumerable<T> e, Exception ex)
             {
-                this.e = e;
-                this.ex = ex;
+                _e = e;
+                _ex = ex;
             }
 
             public IEnumerator<T> GetEnumerator()
             {
-                return new Enumerator(e.GetEnumerator(), ex);
+                return new Enumerator(_e.GetEnumerator(), _ex);
             }
 
             System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
@@ -2084,23 +2084,23 @@ namespace ReactiveTests.Tests
 
             private class Enumerator : IEnumerator<T>
             {
-                private IEnumerator<T> e;
-                private readonly Exception ex;
+                private IEnumerator<T> _e;
+                private readonly Exception _ex;
 
                 public Enumerator(IEnumerator<T> e, Exception ex)
                 {
-                    this.e = e;
-                    this.ex = ex;
+                    _e = e;
+                    _ex = ex;
                 }
 
                 public T Current
                 {
-                    get { throw ex; }
+                    get { throw _ex; }
                 }
 
                 public void Dispose()
                 {
-                    e.Dispose();
+                    _e.Dispose();
                 }
 
                 object System.Collections.IEnumerator.Current
@@ -2110,12 +2110,12 @@ namespace ReactiveTests.Tests
 
                 public bool MoveNext()
                 {
-                    return e.MoveNext();
+                    return _e.MoveNext();
                 }
 
                 public void Reset()
                 {
-                    e.Reset();
+                    _e.Reset();
                 }
             }
         }
@@ -2178,18 +2178,18 @@ namespace ReactiveTests.Tests
 
         private class MoveNextThrowsEnumerable<T> : IEnumerable<T>
         {
-            private IEnumerable<T> e;
-            private readonly Exception ex;
+            private IEnumerable<T> _e;
+            private readonly Exception _ex;
 
             public MoveNextThrowsEnumerable(IEnumerable<T> e, Exception ex)
             {
-                this.e = e;
-                this.ex = ex;
+                _e = e;
+                _ex = ex;
             }
 
             public IEnumerator<T> GetEnumerator()
             {
-                return new Enumerator(e.GetEnumerator(), ex);
+                return new Enumerator(_e.GetEnumerator(), _ex);
             }
 
             System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
@@ -2199,23 +2199,23 @@ namespace ReactiveTests.Tests
 
             private class Enumerator : IEnumerator<T>
             {
-                private IEnumerator<T> e;
-                private readonly Exception ex;
+                private IEnumerator<T> _e;
+                private readonly Exception _ex;
 
                 public Enumerator(IEnumerator<T> e, Exception ex)
                 {
-                    this.e = e;
-                    this.ex = ex;
+                    _e = e;
+                    _ex = ex;
                 }
 
                 public T Current
                 {
-                    get { return e.Current; }
+                    get { return _e.Current; }
                 }
 
                 public void Dispose()
                 {
-                    e.Dispose();
+                    _e.Dispose();
                 }
 
                 object System.Collections.IEnumerator.Current
@@ -2225,12 +2225,12 @@ namespace ReactiveTests.Tests
 
                 public bool MoveNext()
                 {
-                    throw ex;
+                    throw _ex;
                 }
 
                 public void Reset()
                 {
-                    e.Reset();
+                    _e.Reset();
                 }
             }
         }
@@ -2322,11 +2322,11 @@ namespace ReactiveTests.Tests
         [Fact]
         public void SelectManyWithIndex_Enumerable_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int>(DummyFunc<int, int, IEnumerable<int>>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, int, IEnumerable<int>>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, int, IEnumerable<int>>)null));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany(DummyFunc<int, int, IEnumerable<int>>.Instance).Subscribe(null));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int, int>(DummyFunc<int, int, IEnumerable<int>>.Instance, DummyFunc<int, int, int, int, int>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, int, IEnumerable<int>>.Instance, DummyFunc<int, int, int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, int, IEnumerable<int>>)null, DummyFunc<int, int, int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany(DummyFunc<int, int, IEnumerable<int>>.Instance, (Func<int, int, int, int, int>)null));
         }
@@ -2974,23 +2974,23 @@ namespace ReactiveTests.Tests
         [Fact]
         public void SelectMany_QueryOperator_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int, int>(DummyFunc<int, IObservable<int>>.Instance, DummyFunc<int, int, int>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, IObservable<int>>.Instance, DummyFunc<int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, IObservable<int>>)null, DummyFunc<int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany(DummyFunc<int, IObservable<int>>.Instance, ((Func<int, int, int>)null)));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany(DummyFunc<int, IObservable<int>>.Instance, DummyFunc<int, int, int>.Instance).Subscribe(null));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int, int>(DummyFunc<int, Task<int>>.Instance, DummyFunc<int, int, int>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, Task<int>>.Instance, DummyFunc<int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, Task<int>>)null, DummyFunc<int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany(DummyFunc<int, Task<int>>.Instance, ((Func<int, int, int>)null)));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int, int>(DummyFunc<int, CancellationToken, Task<int>>.Instance, DummyFunc<int, int, int>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, CancellationToken, Task<int>>.Instance, DummyFunc<int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, CancellationToken, Task<int>>)null, DummyFunc<int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany(DummyFunc<int, CancellationToken, Task<int>>.Instance, ((Func<int, int, int>)null)));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int>(DummyFunc<int, Task<int>>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, Task<int>>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, Task<int>>)null));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int>(DummyFunc<int, CancellationToken, Task<int>>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, CancellationToken, Task<int>>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, CancellationToken, Task<int>>)null));
         }
 
@@ -3248,7 +3248,7 @@ namespace ReactiveTests.Tests
         [Fact]
         public void SelectManyWithIndex_QueryOperator_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int, int>(DummyFunc<int, int, IObservable<int>>.Instance, DummyFunc<int, int, int, int, int>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, int, IObservable<int>>.Instance, DummyFunc<int, int, int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, int, IObservable<int>>)null, DummyFunc<int, int, int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany(DummyFunc<int, int, IObservable<int>>.Instance, ((Func<int, int, int, int, int>)null)));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany(DummyFunc<int, int, IObservable<int>>.Instance, DummyFunc<int, int, int, int, int>.Instance).Subscribe(null));
@@ -5960,17 +5960,17 @@ namespace ReactiveTests.Tests
         [Fact]
         public void SelectManyWithIndex_Task_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int>(DummyFunc<int, int, Task<int>>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, int, Task<int>>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, int, Task<int>>)null));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int>(DummyFunc<int, int, CancellationToken, Task<int>>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, int, CancellationToken, Task<int>>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, int, CancellationToken, Task<int>>)null));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int, int>(DummyFunc<int, int, Task<int>>.Instance, DummyFunc<int, int, int, int>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, int, Task<int>>.Instance, DummyFunc<int, int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, int, Task<int>>)null, DummyFunc<int, int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany(DummyFunc<int, int, Task<int>>.Instance, ((Func<int, int, int, int>)null)));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany<int, int, int>(DummyFunc<int, int, CancellationToken, Task<int>>.Instance, DummyFunc<int, int, int, int>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).SelectMany(DummyFunc<int, int, CancellationToken, Task<int>>.Instance, DummyFunc<int, int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany((Func<int, int, CancellationToken, Task<int>>)null, DummyFunc<int, int, int, int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.SelectMany(DummyFunc<int, int, CancellationToken, Task<int>>.Instance, ((Func<int, int, int, int>)null)));
         }

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

@@ -19,36 +19,36 @@ namespace ReactiveTests.Tests
         [Fact]
         public void Select_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).Select<int, int>(DummyFunc<int, int>.Instance));
-            ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.Select<int, int>((Func<int, int>)null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.Select<int, int>(DummyFunc<int, int>.Instance).Subscribe(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).Select(DummyFunc<int, int>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.Select((Func<int, int>)null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.Select(DummyFunc<int, int>.Instance).Subscribe(null));
         }
 
         [Fact]
         public void Select_Throws()
         {
             ReactiveAssert.Throws<InvalidOperationException>(() =>
-                Observable.Return(1).Select<int, int>(x => x).Subscribe(
+                Observable.Return(1).Select(x => x).Subscribe(
                  x =>
                  {
                      throw new InvalidOperationException();
                  }));
             ReactiveAssert.Throws<InvalidOperationException>(() =>
-                Observable.Throw<int>(new Exception()).Select<int, int>(x => x).Subscribe(
+                Observable.Throw<int>(new Exception()).Select(x => x).Subscribe(
                  x => { },
                  exception =>
                  {
                      throw new InvalidOperationException();
                  }));
             ReactiveAssert.Throws<InvalidOperationException>(() =>
-                 Observable.Empty<int>().Select<int, int>(x => x).Subscribe(
+                 Observable.Empty<int>().Select(x => x).Subscribe(
                  x => { },
                  exception => { },
                  () =>
                  {
                      throw new InvalidOperationException();
                  }));
-            ReactiveAssert.Throws<InvalidOperationException>(() => Observable.Create<int>(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).Select(x => x).Subscribe());
+            ReactiveAssert.Throws<InvalidOperationException>(() => Observable.Create(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).Select(x => x).Subscribe());
         }
 
         [Fact]
@@ -268,36 +268,36 @@ namespace ReactiveTests.Tests
         [Fact]
         public void SelectWithIndex_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).Select<int, int>(DummyFunc<int, int, int>.Instance));
-            ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.Select<int, int>((Func<int, int, int>)null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.Select<int, int>(DummyFunc<int, int, int>.Instance).Subscribe(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).Select(DummyFunc<int, int, int>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.Select((Func<int, int, int>)null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.Select(DummyFunc<int, int, int>.Instance).Subscribe(null));
         }
 
         [Fact]
         public void SelectWithIndex_Throws()
         {
             ReactiveAssert.Throws<InvalidOperationException>(() =>
-                Observable.Return(1).Select<int, int>((x, index) => x).Subscribe(
+                Observable.Return(1).Select((x, index) => x).Subscribe(
                  x =>
                  {
                      throw new InvalidOperationException();
                  }));
             ReactiveAssert.Throws<InvalidOperationException>(() =>
-                Observable.Throw<int>(new Exception()).Select<int, int>((x, index) => x).Subscribe(
+                Observable.Throw<int>(new Exception()).Select((x, index) => x).Subscribe(
                  x => { },
                  exception =>
                  {
                      throw new InvalidOperationException();
                  }));
             ReactiveAssert.Throws<InvalidOperationException>(() =>
-                 Observable.Empty<int>().Select<int, int>((x, index) => x).Subscribe(
+                 Observable.Empty<int>().Select((x, index) => x).Subscribe(
                  x => { },
                  exception => { },
                  () =>
                  {
                      throw new InvalidOperationException();
                  }));
-            ReactiveAssert.Throws<InvalidOperationException>(() => Observable.Create<int>(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).Select((x, index) => x).Subscribe());
+            ReactiveAssert.Throws<InvalidOperationException>(() => Observable.Create(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).Select((x, index) => x).Subscribe());
         }
 
         [Fact]

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

@@ -18,17 +18,17 @@ namespace ReactiveTests.Tests
         [Fact]
         public void SequenceEqual_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual<int>(default, DummyObservable<int>.Instance));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual<int>(DummyObservable<int>.Instance, default(IObservable<int>)));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual<int>(default, DummyObservable<int>.Instance, EqualityComparer<int>.Default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual<int>(DummyObservable<int>.Instance, default(IObservable<int>), EqualityComparer<int>.Default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual<int>(DummyObservable<int>.Instance, DummyObservable<int>.Instance, default));
-
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual<int>(default, new[] { 42 }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual<int>(DummyObservable<int>.Instance, default(IEnumerable<int>)));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual<int>(default, new[] { 42 }, EqualityComparer<int>.Default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual<int>(DummyObservable<int>.Instance, default(IEnumerable<int>), EqualityComparer<int>.Default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual<int>(DummyObservable<int>.Instance, new[] { 42 }, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual(default, DummyObservable<int>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual(DummyObservable<int>.Instance, default(IObservable<int>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual(default, DummyObservable<int>.Instance, EqualityComparer<int>.Default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual(DummyObservable<int>.Instance, default(IObservable<int>), EqualityComparer<int>.Default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual(DummyObservable<int>.Instance, DummyObservable<int>.Instance, default));
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual(default, new[] { 42 }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual(DummyObservable<int>.Instance, default(IEnumerable<int>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual(default, new[] { 42 }, EqualityComparer<int>.Default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual(DummyObservable<int>.Instance, default(IEnumerable<int>), EqualityComparer<int>.Default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SequenceEqual(DummyObservable<int>.Instance, new[] { 42 }, default));
         }
 
         [Fact]

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

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

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

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

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

@@ -387,7 +387,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -413,7 +413,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),
@@ -441,7 +441,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -466,7 +466,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),
@@ -502,7 +502,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -528,7 +528,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnError<int>(210, ex)
             );
 

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

@@ -500,7 +500,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -526,7 +526,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -551,7 +551,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -577,7 +577,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnError<int>(210, ex)
             );
 
@@ -623,7 +623,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),
@@ -656,7 +656,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            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/SkipUntilTest.cs

@@ -456,7 +456,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -482,7 +482,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -507,7 +507,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -533,7 +533,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnError<int>(210, ex)
             );
 
@@ -579,7 +579,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),
@@ -612,7 +612,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            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/StartAsyncTest.cs

@@ -17,13 +17,13 @@ namespace ReactiveTests.Tests
     public class StartAsyncTest : ReactiveTest
     {
 
-        private readonly Task<int> doneTask;
+        private readonly Task<int> _doneTask;
 
         public StartAsyncTest()
         {
             var tcs = new TaskCompletionSource<int>();
             tcs.SetResult(42);
-            doneTask = tcs.Task;
+            _doneTask = tcs.Task;
         }
 
         #region Func
@@ -33,14 +33,14 @@ namespace ReactiveTests.Tests
         {
             var s = Scheduler.Immediate;
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync<int>(default(Func<Task<int>>)));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync<int>(default(Func<CancellationToken, Task<int>>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync(default(Func<Task<int>>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync(default(Func<CancellationToken, Task<int>>)));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync<int>(default(Func<Task<int>>), s));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync<int>(default(Func<CancellationToken, Task<int>>), s));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync(default(Func<Task<int>>), s));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync(default(Func<CancellationToken, Task<int>>), s));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync<int>(() => doneTask, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync<int>(ct => doneTask, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync(() => _doneTask, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync(ct => _doneTask, default));
         }
 
         [Fact]
@@ -81,7 +81,7 @@ namespace ReactiveTests.Tests
         {
             var ex = new Exception();
 
-            var xs = Observable.StartAsync<int>(() =>
+            var xs = Observable.StartAsync(() =>
                 Task.Factory.StartNew<int>(() =>
                 {
                     throw ex;
@@ -128,7 +128,7 @@ namespace ReactiveTests.Tests
         {
             var ex = new Exception();
 
-            var xs = Observable.StartAsync<int>(ct =>
+            var xs = Observable.StartAsync(ct =>
                 Task.Factory.StartNew<int>(() => { throw ex; })
             );
 
@@ -245,8 +245,8 @@ namespace ReactiveTests.Tests
 
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync(default(Func<Task>), s));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync(default(Func<CancellationToken, Task>), s));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync(() => (Task)doneTask, default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync(ct => (Task)doneTask, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync(() => (Task)_doneTask, default));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.StartAsync(ct => (Task)_doneTask, default));
         }
 
         [Fact]

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

@@ -24,7 +24,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Start(null, someScheduler));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Start<int>(null, someScheduler));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Start(() => { }, null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Start<int>(() => 1, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Start(() => 1, null));
         }
 
 

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

@@ -46,7 +46,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => DispatcherObservable.SubscribeOnDispatcher<int>(default(IObservable<int>)));
 #endif
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SubscribeOn<int>(default, new SynchronizationContext()));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SubscribeOn<int>(someObservable, default(SynchronizationContext)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SubscribeOn(someObservable, default(SynchronizationContext)));
         }
 
 #if HAS_WINFORMS

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

@@ -20,12 +20,12 @@ namespace ReactiveTests.Tests
         [Fact]
         public void SubscribeToEnumerable_ArgumentChecking()
         {
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Subscribe<int>(null, DummyObserver<int>.Instance));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Subscribe<int>(DummyEnumerable<int>.Instance, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Subscribe(null, DummyObserver<int>.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Subscribe(DummyEnumerable<int>.Instance, null));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Subscribe<int>(null, DummyObserver<int>.Instance, DummyScheduler.Instance));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Subscribe<int>(DummyEnumerable<int>.Instance, DummyObserver<int>.Instance, null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Subscribe<int>(DummyEnumerable<int>.Instance, null, DummyScheduler.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Subscribe(null, DummyObserver<int>.Instance, DummyScheduler.Instance));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Subscribe(DummyEnumerable<int>.Instance, DummyObserver<int>.Instance, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Subscribe(DummyEnumerable<int>.Instance, null, DummyScheduler.Instance));
             ReactiveAssert.Throws<NullReferenceException>(() => NullEnumeratorEnumerable<int>.Instance.Subscribe(Observer.Create<int>(x => { }), Scheduler.CurrentThread));
         }
 
@@ -180,20 +180,20 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default));
 
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default, _ => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default(Action<int>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, default(Action<int>)));
 
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default, _ => { }, () => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default, () => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, default(Action)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, default, () => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, _ => { }, default(Action)));
 
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default, _ => { }, (Exception _) => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default, (Exception _) => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, default(Action<Exception>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, default, (Exception _) => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, _ => { }, default(Action<Exception>)));
 
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default, _ => { }, (Exception _) => { }, () => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default, (Exception _) => { }, () => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, default, () => { }));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, (Exception _) => { }, default(Action)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, default, (Exception _) => { }, () => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, _ => { }, default, () => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, _ => { }, (Exception _) => { }, default(Action)));
         }
 
         [Fact]
@@ -281,26 +281,26 @@ namespace ReactiveTests.Tests
             var someObserver = Observer.Create<int>(_ => { });
             var ct = CancellationToken.None;
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default, someObserver, ct));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default(IObserver<int>), ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(default, someObserver, ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, default(IObserver<int>), ct));
 
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default, ct));
 
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default, _ => { }, ct));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default(Action<int>), ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, default(Action<int>), ct));
 
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default, _ => { }, () => { }, ct));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default, () => { }, ct));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, default(Action), ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, default, () => { }, ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, _ => { }, default(Action), ct));
 
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default, _ => { }, (Exception _) => { }, ct));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default, (Exception _) => { }, ct));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, default(Action<Exception>), ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, default, (Exception _) => { }, ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, _ => { }, default(Action<Exception>), ct));
 
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default, _ => { }, (Exception _) => { }, () => { }, ct));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default, (Exception _) => { }, () => { }, ct));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, default, () => { }, ct));
-            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, (Exception _) => { }, default, ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, default, (Exception _) => { }, () => { }, ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, _ => { }, default, () => { }, ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe(someObservable, _ => { }, (Exception _) => { }, default, ct));
         }
 
         [Fact]
@@ -462,7 +462,7 @@ namespace ReactiveTests.Tests
         [Fact]
         public void Subscribe_CT_Overloads_AlreadyCancelled()
         {
-            var xs = Observable.Defer<int>(() =>
+            var xs = Observable.Defer(() =>
             {
                 Assert.True(false);
                 return Observable.Return(42, Scheduler.Immediate);
@@ -487,7 +487,7 @@ namespace ReactiveTests.Tests
             var e = 0;
             var c = 0;
 
-            var xs = Observable.Defer<int>(() =>
+            var xs = Observable.Defer(() =>
             {
                 i++;
                 return Observable.Return(42, Scheduler.Immediate);

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

@@ -1394,7 +1394,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"),
@@ -1418,7 +1418,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"),
@@ -1442,7 +1442,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"),
@@ -1466,7 +1466,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"),
@@ -1490,7 +1490,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"),
@@ -1514,7 +1514,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"),
@@ -1538,7 +1538,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"),
@@ -1562,7 +1562,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"),
@@ -1586,7 +1586,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"),
@@ -1610,7 +1610,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"),

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

@@ -22,7 +22,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Synchronize<int>(default));
 
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Synchronize<int>(default, new object()));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Synchronize<int>(someObservable, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Synchronize(someObservable, null));
         }
 
 #if !NO_THREAD

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

@@ -330,7 +330,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -355,7 +355,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),
@@ -381,7 +381,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),
@@ -407,7 +407,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),
@@ -433,7 +433,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),
@@ -465,7 +465,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(240, 2),
                 OnNext(250, 3),
@@ -494,7 +494,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -521,7 +521,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnError<int>(210, ex)
             );
 

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

@@ -350,7 +350,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -374,7 +374,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -398,7 +398,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),
@@ -423,7 +423,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),
@@ -448,7 +448,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),
@@ -475,7 +475,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),
@@ -502,7 +502,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),
@@ -527,7 +527,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),
@@ -552,7 +552,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),
@@ -587,7 +587,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),
@@ -622,7 +622,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(240, 2),
                 OnNext(250, 3),
@@ -650,7 +650,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(240, 2),
                 OnNext(250, 3),
@@ -678,7 +678,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -704,7 +704,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -732,7 +732,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnError<int>(210, ex)
             );
 
@@ -756,7 +756,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnError<int>(210, ex)
             );
 

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

@@ -623,7 +623,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -647,7 +647,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),
@@ -674,7 +674,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -702,7 +702,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnError<int>(210, ex)
             );
 
@@ -749,7 +749,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),
@@ -782,7 +782,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            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/TakeUntilTest.cs

@@ -416,7 +416,7 @@ namespace ReactiveTests.Tests
 
             var r = scheduler.CreateHotObservable(
                 OnNext(150, 1),
-                OnNext<int>(240, 2)
+                OnNext(240, 2)
             );
 
             var res = scheduler.Start(() =>
@@ -472,7 +472,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -496,7 +496,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),
@@ -523,7 +523,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnCompleted<int>(230)
@@ -551,7 +551,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnError<int>(210, ex)
             );
 
@@ -598,7 +598,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),
@@ -631,7 +631,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(210, 1),
                 OnNext(220, 2),
                 OnNext(230, 3),
@@ -685,7 +685,7 @@ namespace ReactiveTests.Tests
         public void TakeUntil_Predicate_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil<int>(null, v => true));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil<int>(DummyObservable<int>.Instance, null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil(DummyObservable<int>.Instance, null));
         }
 
         [Fact]

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

@@ -20,21 +20,21 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Then<int, int>(null, _ => _));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Then<int, int>(someObservable, null));
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).Then<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).Then<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).Then<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).Then<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).Then<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).Then<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And<int, int>(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).Then<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).Then<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).Then<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).Then<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).Then<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).Then<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).Then<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).Then<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(someObservable).Then<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).Then<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).Then<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).Then<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).Then<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).Then<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).Then<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).Then<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).Then<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).Then<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).Then<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).Then<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).Then<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).Then<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).Then<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(someObservable).Then<int>(null));
         }
 
         [Fact]

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

@@ -325,11 +325,11 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(250 + 20, 0),
-                OnNext<int>(280 + 20, 1),
-                OnNext<int>(310 + 20, 2),
-                OnNext<int>(350 + 20, 3),
-                OnNext<int>(400 + 20, 4),
+                OnNext(250 + 20, 0),
+                OnNext(280 + 20, 1),
+                OnNext(310 + 20, 2),
+                OnNext(350 + 20, 3),
+                OnNext(400 + 20, 4),
                 OnCompleted<int>(550)
             );
 
@@ -387,9 +387,9 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(250 + 20, 0),
-                OnNext<int>(310 + 20, 2),
-                OnNext<int>(400 + 20, 4),
+                OnNext(250 + 20, 0),
+                OnNext(310 + 20, 2),
+                OnNext(400 + 20, 4),
                 OnCompleted<int>(550)
             );
 
@@ -447,9 +447,9 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(250 + 20, 0),
-                OnNext<int>(310 + 20, 2),
-                OnNext<int>(410, 4),
+                OnNext(250 + 20, 0),
+                OnNext(310 + 20, 2),
+                OnNext(410, 4),
                 OnCompleted<int>(410)
             );
 
@@ -492,8 +492,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)
             );
 
@@ -527,8 +527,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)
             );
 
@@ -570,8 +570,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)
             );
 
@@ -604,9 +604,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)
             );
 
@@ -641,9 +641,9 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(250 + 2 * 10, 2),
-                OnNext<int>(300 + 4 * 10, 4),
-                OnNext<int>(410 + 6 * 10, 6),
+                OnNext(250 + 2 * 10, 2),
+                OnNext(300 + 4 * 10, 4),
+                OnNext(410 + 6 * 10, 6),
                 OnCompleted<int>(550)
             );
 

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

@@ -19,11 +19,11 @@ namespace ReactiveTests.Tests
         public void Throw_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Throw<int>(null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Throw<int>(null, 42));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Throw(null, 42));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Throw<int>(new Exception(), null));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Throw<int>(new Exception(), null, 42));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Throw(new Exception(), null, 42));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Throw<int>(null, DummyScheduler.Instance));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Throw<int>(null, DummyScheduler.Instance, 42));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Throw(null, DummyScheduler.Instance, 42));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Throw<int>(new Exception(), DummyScheduler.Instance).Subscribe(null));
         }
 
@@ -84,7 +84,7 @@ namespace ReactiveTests.Tests
             var ex = new Exception();
 
             var res = scheduler.Start(() =>
-                Observable.Throw<int>(ex, scheduler, 42)
+                Observable.Throw(ex, scheduler, 42)
             );
 
             res.Messages.AssertEqual(
@@ -101,7 +101,7 @@ namespace ReactiveTests.Tests
 
             var res = default(Exception);
 
-            Observable.Throw<int>(ex, 42).Subscribe(
+            Observable.Throw(ex, 42).Subscribe(
                 _ => { Assert.True(false); },
                 err => { res = err; e.Set(); },
                 () => { Assert.True(false); }

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

@@ -330,7 +330,7 @@ namespace ReactiveTests.Tests
             var scheduler = new TestScheduler();
 
             var xs = scheduler.CreateHotObservable(
-                OnNext<int>(500, 42)
+                OnNext(500, 42)
             );
 
             var ys = scheduler.CreateColdObservable(
@@ -688,7 +688,7 @@ namespace ReactiveTests.Tests
                 OnCompleted<int>(450)
             );
 
-            var ys = scheduler.CreateColdObservable<string>(
+            var ys = scheduler.CreateColdObservable(
                 OnNext(100, "Boo!")
             );
 
@@ -727,14 +727,14 @@ namespace ReactiveTests.Tests
                 OnCompleted<int>(450)
             );
 
-            var ys = scheduler.CreateColdObservable<string>(
+            var ys = scheduler.CreateColdObservable(
                 OnNext(100, "Boo!")
             );
 
             var zs = scheduler.CreateColdObservable<string>(
             );
 
-            var ts = scheduler.CreateColdObservable<int>(
+            var ts = scheduler.CreateColdObservable(
                 OnNext(50, 42),
                 OnCompleted<int>(70)
             );
@@ -779,7 +779,7 @@ namespace ReactiveTests.Tests
             var ys = scheduler.CreateColdObservable<string>(
             );
 
-            var zs = scheduler.CreateColdObservable<string>(
+            var zs = scheduler.CreateColdObservable(
                 OnNext(50, "Boo!")
             );
 
@@ -788,8 +788,8 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(310, 1),
-                OnNext<int>(350, 2),
+                OnNext(310, 1),
+                OnNext(350, 2),
                 OnError<int>(400, ex => ex is TimeoutException)
             );
 
@@ -822,11 +822,11 @@ namespace ReactiveTests.Tests
             var ys = scheduler.CreateColdObservable<string>(
             );
 
-            var zs = scheduler.CreateColdObservable<string>(
+            var zs = scheduler.CreateColdObservable(
                 OnNext(50, "Boo!")
             );
 
-            var ts = scheduler.CreateColdObservable<int>(
+            var ts = scheduler.CreateColdObservable(
                 OnNext(50, 42),
                 OnCompleted<int>(70)
             );
@@ -872,7 +872,7 @@ namespace ReactiveTests.Tests
                 OnCompleted<int>(450)
             );
 
-            var zs = scheduler.CreateColdObservable<string>(
+            var zs = scheduler.CreateColdObservable(
                 OnNext(50, "Boo!")
             );
 
@@ -881,8 +881,8 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(310, 1),
-                OnNext<int>(350, 2),
+                OnNext(310, 1),
+                OnNext(350, 2),
                 OnError<int>(400, ex => ex is TimeoutException)
             );
 
@@ -908,11 +908,11 @@ namespace ReactiveTests.Tests
                 OnCompleted<int>(450)
             );
 
-            var zs = scheduler.CreateColdObservable<string>(
+            var zs = scheduler.CreateColdObservable(
                 OnNext(50, "Boo!")
             );
 
-            var ts = scheduler.CreateColdObservable<int>(
+            var ts = scheduler.CreateColdObservable(
                 OnNext(50, 42),
                 OnCompleted<int>(70)
             );
@@ -957,7 +957,7 @@ namespace ReactiveTests.Tests
             var ys = scheduler.CreateColdObservable<string>(
             );
 
-            var zs = scheduler.CreateColdObservable<string>(
+            var zs = scheduler.CreateColdObservable(
                 OnCompleted<string>(50)
             );
 
@@ -966,8 +966,8 @@ namespace ReactiveTests.Tests
             );
 
             res.Messages.AssertEqual(
-                OnNext<int>(310, 1),
-                OnNext<int>(350, 2),
+                OnNext(310, 1),
+                OnNext(350, 2),
                 OnError<int>(400, ex => ex is TimeoutException)
             );
 
@@ -1057,7 +1057,7 @@ namespace ReactiveTests.Tests
             var ys = scheduler.CreateColdObservable<string>(
             );
 
-            var zs = scheduler.CreateColdObservable<string>(
+            var zs = scheduler.CreateColdObservable(
                 OnError<string>(50, ex)
             );
 
@@ -1099,7 +1099,7 @@ namespace ReactiveTests.Tests
                 OnCompleted<int>(450)
             );
 
-            var ys = scheduler.CreateColdObservable<string>(
+            var ys = scheduler.CreateColdObservable(
                 OnError<string>(50, ex)
             );
 

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

@@ -757,17 +757,17 @@ namespace ReactiveTests.Tests
 
         public IDisposable Schedule<TState>(TState state, Func<IScheduler, TState, IDisposable> action)
         {
-            return _scheduler.Schedule<TState>(state, GetCatch(action));
+            return _scheduler.Schedule(state, GetCatch(action));
         }
 
         public IDisposable Schedule<TState>(TState state, TimeSpan dueTime, Func<IScheduler, TState, IDisposable> action)
         {
-            return _scheduler.Schedule<TState>(state, dueTime, GetCatch(action));
+            return _scheduler.Schedule(state, dueTime, GetCatch(action));
         }
 
         public IDisposable Schedule<TState>(TState state, DateTimeOffset dueTime, Func<IScheduler, TState, IDisposable> action)
         {
-            return _scheduler.Schedule<TState>(state, dueTime, GetCatch(action));
+            return _scheduler.Schedule(state, dueTime, GetCatch(action));
         }
 
         private Func<IScheduler, TState, IDisposable> GetCatch<TState>(Func<IScheduler, TState, IDisposable> action)

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

@@ -63,7 +63,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(150, 1),
                 OnCompleted<int>(400)
             );
@@ -88,7 +88,7 @@ namespace ReactiveTests.Tests
 
             var ex = new Exception();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(150, 1),
                 OnError<int>(400, ex)
             );
@@ -111,7 +111,7 @@ namespace ReactiveTests.Tests
         {
             var scheduler = new TestScheduler();
 
-            var xs = scheduler.CreateHotObservable<int>(
+            var xs = scheduler.CreateHotObservable(
                 OnNext(150, 1)
             );