Fix compiler diagnostics in AsyncRx.NET

AsyncRx.NET/ApiCompare/Program.cs

@@ -9,9 +9,9 @@
 
 namespace ApiCompare
 {
-    class Program
+    internal class Program
     {
-        static void Main()
+        private static void Main()
         {
             var observable = typeof(Observable).GetMethods(BindingFlags.Public | BindingFlags.Static).Select(m => m.Name).Distinct();
             var asyncObservable = typeof(AsyncObservable).GetMethods(BindingFlags.Public | BindingFlags.Static).Select(m => m.Name).Distinct();

AsyncRx.NET/Playground/Program.cs

@@ -2,6 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT License.
 // See the LICENSE file in the project root for more information. 
 
+// The intention is that people will uncomment whichever method call in Main they want to try.
+// The following suppressions prevent warnings due to 'unused' members, and the fact that all of
+// the await statements in Main are commented out to start with
+#pragma warning disable IDE0051, CS1998
+
 using System;
 using System.Linq;
 using System.Reactive;
@@ -12,16 +17,9 @@
 
 namespace Playground
 {
-    static class Program
+    internal static class Program
     {
-        static void Main()
-        {
-            MainAsync().GetAwaiter().GetResult();
-
-            Console.ReadLine();
-        }
-
-        static async Task MainAsync()
+        private static async Task Main()
         {
             //await AggregateAsync();
             //await AllAsync();
@@ -45,34 +43,36 @@ static async Task MainAsync()
             //await TakeUntilAsync();
             //await TimerAsync();
             //await WhileAsync();
+
+            Console.ReadLine();
         }
 
-        static async Task AggregateAsync()
+        private static async Task AggregateAsync()
         {
             await AsyncObservable.Range(0, 10).Aggregate(0, (sum, x) => sum + x).SubscribeAsync(Print<int>());
         }
 
-        static async Task AllAsync()
+        private static async Task AllAsync()
         {
             await AsyncObservable.Range(0, 10).All(x => x < 10).SubscribeAsync(Print<bool>());
         }
 
-        static async Task AnyAsync()
+        private static async Task AnyAsync()
         {
             await AsyncObservable.Range(0, 10).Any(x => x == 5).SubscribeAsync(Print<bool>());
         }
 
-        static async Task AppendAsync()
+        private static async Task AppendAsync()
         {
             await AsyncObservable.Range(0, 10).Append(42).SubscribeAsync(Print<int>());
         }
 
-        static async Task AwaitAsync()
+        private static async Task AwaitAsync()
         {
             Console.WriteLine(await AsyncObservable.Range(0, 10));
         }
 
-        static async Task BufferTimeHoppingAsync()
+        private static async Task BufferTimeHoppingAsync()
         {
             await
                 AsyncObservable
@@ -82,7 +82,7 @@ static async Task BufferTimeHoppingAsync()
                     .SubscribeAsync(Print<string>()); // TODO: Use ForEachAsync.
         }
 
-        static async Task BufferTimeSlidingAsync()
+        private static async Task BufferTimeSlidingAsync()
         {
             await
                 AsyncObservable
@@ -93,7 +93,7 @@ static async Task BufferTimeSlidingAsync()
                     .SubscribeAsync(Print<string>()); // TODO: Use ForEachAsync.
         }
 
-        static async Task CombineLatestAsync()
+        private static async Task CombineLatestAsync()
         {
             await
                 AsyncObservable.CombineLatest(
@@ -104,7 +104,7 @@ static async Task CombineLatestAsync()
                 .SubscribeAsync(Print<string>()); // TODO: Use ForEachAsync.
         }
 
-        static async Task ConcatAsync()
+        private static async Task ConcatAsync()
         {
             await
                 AsyncObservable.Concat(
@@ -116,7 +116,7 @@ static async Task ConcatAsync()
                 .SubscribeAsync(Print<int>()); // TODO: Use ForEachAsync.
         }
 
-        static async Task DelayAsync()
+        private static async Task DelayAsync()
         {
             await
                 AsyncObservable.Timer(TimeSpan.Zero, TimeSpan.FromSeconds(1))
@@ -127,7 +127,7 @@ static async Task DelayAsync()
                     .SubscribeAsync(Print<string>()); // TODO: Use ForEachAsync.
         }
 
-        static async Task GroupByAsync()
+        private static async Task GroupByAsync()
         {
             await
                 AsyncObservable.Interval(TimeSpan.FromMilliseconds(250))
@@ -140,7 +140,7 @@ static async Task GroupByAsync()
                     });
         }
 
-        static async Task GroupBySelectManyAsync()
+        private static async Task GroupBySelectManyAsync()
         {
             await
                 AsyncObservable.Interval(TimeSpan.FromMilliseconds(250))
@@ -151,7 +151,7 @@ static async Task GroupBySelectManyAsync()
                     .SubscribeAsync(Print<string>());
         }
 
-        static async Task MergeAsync()
+        private static async Task MergeAsync()
         {
             var subject = new SequentialSimpleAsyncSubject<IAsyncObservable<int>>();
 
@@ -167,17 +167,17 @@ static async Task MergeAsync()
             await subject.OnCompletedAsync();
         }
 
-        static async Task PrependAsync()
+        private static async Task PrependAsync()
         {
             await AsyncObservable.Range(0, 10).Prepend(42).SubscribeAsync(Print<int>());
         }
 
-        static async Task RangeAsync()
+        private static async Task RangeAsync()
         {
             await AsyncObservable.Range(0, 10).SubscribeAsync(PrintAsync<int>()); // TODO: Use ForEachAsync.
         }
 
-        static async Task ReplaySubjectAsync()
+        private static async Task ReplaySubjectAsync()
         {
             var sub = new SequentialReplayAsyncSubject<int>(5);
 
@@ -208,12 +208,12 @@ static async Task ReplaySubjectAsync()
             await sub.OnNextAsync(47);
         }
 
-        static async Task ReturnAsync()
+        private static async Task ReturnAsync()
         {
             await AsyncObservable.Return(42).SubscribeAsync(Print<int>());
         }
 
-        static async Task SelectManyAsync()
+        private static async Task SelectManyAsync()
         {
             var res = from i in AsyncObservable.Range(0, 10)
                       from j in AsyncObservable.Range(i * 10, 10)
@@ -222,7 +222,7 @@ static async Task SelectManyAsync()
             await res.SubscribeAsync(Print<string>());
         }
 
-        static async Task SubjectAsync()
+        private static async Task SubjectAsync()
         {
             var subject = new SequentialSimpleAsyncSubject<int>();
 
@@ -238,24 +238,24 @@ static async Task SubjectAsync()
             await subject.OnCompletedAsync();
         }
 
-        static async Task TakeUntilAsync()
+        private static async Task TakeUntilAsync()
         {
             await AsyncObservable.Range(0, int.MaxValue).TakeUntil(DateTimeOffset.Now.AddSeconds(5)).SubscribeAsync(Print<int>()); // TODO: Use ForEachAsync.
         }
 
-        static async Task TimerAsync()
+        private static async Task TimerAsync()
         {
             await AsyncObservable.Timer(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2)).Take(5).Select(_ => DateTimeOffset.Now).SubscribeAsync(Print<DateTimeOffset>()); // TODO: Use ForEachAsync.
         }
 
-        static async Task WhileAsync()
+        private static async Task WhileAsync()
         {
             var i = 0;
 
             await AsyncObservable.While(() => ++i < 5, AsyncObservable.Range(0, 5)).SubscribeAsync(Print<int>()); // TODO: Use ForEachAsync.
         }
 
-        static IAsyncObserver<T> Print<T>()
+        private static IAsyncObserver<T> Print<T>()
         {
             return AsyncObserver.Create<T>(
                 x =>
@@ -276,7 +276,7 @@ static IAsyncObserver<T> Print<T>()
             );
         }
 
-        static IAsyncObserver<T> PrintAsync<T>()
+        private static IAsyncObserver<T> PrintAsync<T>()
         {
             return AsyncObserver.Create<T>(
                 async x =>

AsyncRx.NET/System.Reactive.Async/AsyncObservableBase.cs

@@ -27,7 +27,7 @@ public async ValueTask<IAsyncDisposable> SubscribeAsync(IAsyncObserver<T> observ
         private sealed class AutoDetachAsyncObserver : AsyncObserverBase<T>, IAsyncDisposable
         {
             private readonly IAsyncObserver<T> _observer;
-            private readonly object _gate = new object();
+            private readonly object _gate = new();
 
             private IAsyncDisposable _subscription;
             private ValueTask _task;
@@ -62,7 +62,7 @@ public async ValueTask AssignAsync(IAsyncDisposable subscription)
 
             public async ValueTask DisposeAsync()
             {
-                var task = default(ValueTask);
+                ValueTask task;
                 var subscription = default(IAsyncDisposable);
 
                 lock (_gate)

AsyncRx.NET/System.Reactive.Async/Concurrency/AsyncScheduler.cs

@@ -208,7 +208,7 @@ public RendezVousAwaitable(IAsyncScheduler scheduler, CancellationToken token)
                 _token = token;
             }
 
-            public RendezVousAwaiter GetAwaiter() => new RendezVousAwaiter(_scheduler, _token);
+            public RendezVousAwaiter GetAwaiter() => new(_scheduler, _token);
 
             public sealed class RendezVousAwaiter : INotifyCompletion
             {

AsyncRx.NET/System.Reactive.Async/Concurrency/AsyncSchedulerBase.cs

@@ -66,7 +66,7 @@ protected virtual async ValueTask<IAsyncDisposable> ScheduleAsyncCore(Func<Cance
 
         private sealed class CancellationAsyncDisposable : IAsyncDisposable
         {
-            private readonly CancellationTokenSource _cts = new CancellationTokenSource();
+            private readonly CancellationTokenSource _cts = new();
 
             public CancellationToken Token => _cts.Token;
 

AsyncRx.NET/System.Reactive.Async/Concurrency/ImmediateAsyncScheduler.cs

@@ -13,7 +13,7 @@ public sealed class ImmediateAsyncScheduler : AsyncSchedulerBase
 
         private ImmediateAsyncScheduler() { }
 
-        protected override ValueTask Delay(TimeSpan dueTime, CancellationToken token) => new ValueTask(Task.Delay(dueTime));
+        protected override ValueTask Delay(TimeSpan dueTime, CancellationToken token) => new(Task.Delay(dueTime));
 
         protected override ValueTask ScheduleAsyncCore(Func<CancellationToken, ValueTask> action, CancellationToken token) => action(token);
     }

AsyncRx.NET/System.Reactive.Async/Concurrency/SynchronizationContextAsyncScheduler.cs

@@ -16,7 +16,7 @@ public SynchronizationContextAsyncScheduler(SynchronizationContext context)
             _context = context ?? throw new ArgumentNullException(nameof(context));
         }
 
-        protected override ValueTask Delay(TimeSpan dueTime, CancellationToken token) => new ValueTask(Task.Delay(dueTime, token));
+        protected override ValueTask Delay(TimeSpan dueTime, CancellationToken token) => new(Task.Delay(dueTime, token));
 
         protected override ValueTask ScheduleAsyncCore(Func<CancellationToken, ValueTask> action, CancellationToken token)
         {

AsyncRx.NET/System.Reactive.Async/Concurrency/TaskPoolAsyncScheduler.cs

@@ -27,7 +27,7 @@ public TaskPoolAsyncScheduler(TaskFactory factory)
             _factory = factory ?? throw new ArgumentNullException(nameof(factory));
         }
 
-        protected override ValueTask Delay(TimeSpan dueTime, CancellationToken token) => new ValueTask(Task.Delay(dueTime, token));
+        protected override ValueTask Delay(TimeSpan dueTime, CancellationToken token) => new(Task.Delay(dueTime, token));
 
         protected override ValueTask ScheduleAsyncCore(Func<CancellationToken, ValueTask> action, CancellationToken token)
         {

AsyncRx.NET/System.Reactive.Async/Disposables/CompositeAsyncDisposable.cs

@@ -11,7 +11,7 @@ namespace System.Reactive.Disposables
 {
     public sealed class CompositeAsyncDisposable : IAsyncDisposable
     {
-        private readonly AsyncGate _gate = new AsyncGate();
+        private readonly AsyncGate _gate = new();
         private readonly List<IAsyncDisposable> _disposables;
         private bool _disposed;
 

AsyncRx.NET/System.Reactive.Async/Disposables/RefCountAsyncDisposable.cs

@@ -9,7 +9,7 @@ namespace System.Reactive.Disposables
 {
     public sealed class RefCountAsyncDisposable : IAsyncDisposable
     {
-        private readonly AsyncGate _gate = new AsyncGate();
+        private readonly AsyncGate _gate = new();
         private IAsyncDisposable _disposable;
         private bool _primaryDisposed;
         private int _count;

AsyncRx.NET/System.Reactive.Async/Disposables/SerialAsyncDisposable.cs

@@ -9,7 +9,7 @@ namespace System.Reactive.Disposables
 {
     public sealed class SerialAsyncDisposable : IAsyncDisposable
     {
-        private readonly AsyncGate _gate = new AsyncGate();
+        private readonly AsyncGate _gate = new();
 
         private IAsyncDisposable _disposable;
         private bool _disposed;

AsyncRx.NET/System.Reactive.Async/Internal/AsyncQueueLockAsyncObserver.cs

@@ -9,7 +9,7 @@ namespace System.Reactive
 {
     internal sealed class AsyncQueueLockAsyncObserver<T> : AsyncObserverBase<T>
     {
-        private readonly AsyncQueueLock _gate = new AsyncQueueLock();
+        private readonly AsyncQueueLock _gate = new();
         private readonly IAsyncObserver<T> _observer;
 
         public AsyncQueueLockAsyncObserver(IAsyncObserver<T> observer)

AsyncRx.NET/System.Reactive.Async/Internal/EventPatternSourceBaseInternal.cs

@@ -120,10 +120,7 @@ protected void Remove(Delegate handler)
                 }
             }
 
-            if (d != null)
-            {
-                d.DisposeAsync().GetAwaiter().GetResult();
-            }
+            d?.DisposeAsync().GetAwaiter().GetResult();
         }
     }
 }

AsyncRx.NET/System.Reactive.Async/Internal/EventSource.cs

@@ -91,10 +91,7 @@ private void Remove(Delegate handler)
                 }
             }
 
-            if (d != null)
-            {
-                d.DisposeAsync().GetAwaiter().GetResult();
-            }
+            d?.DisposeAsync().GetAwaiter().GetResult();
         }
     }
 }

AsyncRx.NET/System.Reactive.Async/Internal/FastImmediateAsyncObserver.cs

@@ -10,7 +10,7 @@ namespace System.Reactive
 {
     internal sealed class FastImmediateAsyncObserver<T> : ScheduledAsyncObserverBase<T>
     {
-        private readonly CancellationAsyncDisposable _disposable = new CancellationAsyncDisposable();
+        private readonly CancellationAsyncDisposable _disposable = new();
 
         public FastImmediateAsyncObserver(IAsyncObserver<T> observer)
             : base(observer)
@@ -19,9 +19,9 @@ public FastImmediateAsyncObserver(IAsyncObserver<T> observer)
 
         public override ValueTask DisposeAsync() => _disposable.DisposeAsync();
 
-        protected override ValueTaskAwaitable RendezVous(ValueTask task) => new ValueTaskAwaitable(task, continueOnCapturedContext: false, scheduler: null, CancellationToken.None);
+        protected override ValueTaskAwaitable RendezVous(ValueTask task) => new(task, continueOnCapturedContext: false, scheduler: null, CancellationToken.None);
 
-        protected override ValueTaskAwaitable<R> RendezVous<R>(ValueTask<R> task) => new ValueTaskAwaitable<R>(task, continueOnCapturedContext: false, scheduler: null, CancellationToken.None);
+        protected override ValueTaskAwaitable<R> RendezVous<R>(ValueTask<R> task) => new(task, continueOnCapturedContext: false, scheduler: null, CancellationToken.None);
 
         protected override ValueTask ScheduleAsync() => RunAsync(_disposable.Token);
     }