Misc. code improvements.

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

@@ -216,8 +216,6 @@ namespace System.Reactive.Concurrency
         {
             private readonly IAsyncScheduler _scheduler;
             private readonly CancellationToken _token;
-
-            private bool _done;
             private ExceptionDispatchInfo _error;
 
             public RendezVousAwaitable(IAsyncScheduler scheduler, CancellationToken token)
@@ -226,13 +224,13 @@ namespace System.Reactive.Concurrency
                 _token = token;
             }
 
-            public bool IsCompleted => _done;
+            public bool IsCompleted { get; private set; }
 
             public IAwaiter GetAwaiter() => this;
 
             public void GetResult()
             {
-                if (!_done)
+                if (!IsCompleted)
                 {
                     throw new InvalidOperationException(); // REVIEW: No support for blocking.
                 }
@@ -257,7 +255,7 @@ namespace System.Reactive.Concurrency
                     }
                     finally
                     {
-                        _done = true;
+                        IsCompleted = true;
                     }
 
                     return default;

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

@@ -13,10 +13,7 @@ namespace System.Reactive.Concurrency
 
         public SynchronizationContextAsyncScheduler(SynchronizationContext context)
         {
-            if (context == null)
-                throw new ArgumentNullException(nameof(context));
-
-            _context = context;
+            _context = context ?? throw new ArgumentNullException(nameof(context));
         }
 
         protected override Task Delay(TimeSpan dueTime, CancellationToken token) => Task.Delay(dueTime, token);

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

@@ -24,10 +24,7 @@ namespace System.Reactive.Concurrency
 
         public TaskPoolAsyncScheduler(TaskFactory factory)
         {
-            if (factory == null)
-                throw new ArgumentNullException(nameof(factory));
-
-            _factory = factory;
+            _factory = factory ?? throw new ArgumentNullException(nameof(factory));
         }
 
         protected override Task Delay(TimeSpan dueTime, CancellationToken token) => Task.Delay(dueTime, token);

AsyncRx.NET/System.Reactive.Async.Core/System/Reactive/AsyncObservable.cs

@@ -12,10 +12,7 @@ namespace System.Reactive
 
         public AsyncObservable(Func<IAsyncObserver<T>, ValueTask<IAsyncDisposable>> subscribeAsync)
         {
-            if (subscribeAsync == null)
-                throw new ArgumentNullException(nameof(subscribeAsync));
-
-            _subscribeAsync = subscribeAsync;
+            _subscribeAsync = subscribeAsync ?? throw new ArgumentNullException(nameof(subscribeAsync));
         }
 
         protected override ValueTask<IAsyncDisposable> SubscribeAsyncCore(IAsyncObserver<T> observer)

AsyncRx.NET/System.Reactive.Async.Core/System/Reactive/AsyncObserver.cs

@@ -14,16 +14,9 @@ namespace System.Reactive
 
         public AsyncObserver(Func<T, ValueTask> onNextAsync, Func<Exception, ValueTask> onErrorAsync, Func<ValueTask> onCompletedAsync)
         {
-            if (onNextAsync == null)
-                throw new ArgumentNullException(nameof(onNextAsync));
-            if (onErrorAsync == null)
-                throw new ArgumentNullException(nameof(onErrorAsync));
-            if (onCompletedAsync == null)
-                throw new ArgumentNullException(nameof(onCompletedAsync));
-
-            _onNextAsync = onNextAsync;
-            _onErrorAsync = onErrorAsync;
-            _onCompletedAsync = onCompletedAsync;
+            _onNextAsync = onNextAsync ?? throw new ArgumentNullException(nameof(onNextAsync));
+            _onErrorAsync = onErrorAsync ?? throw new ArgumentNullException(nameof(onErrorAsync));
+            _onCompletedAsync = onCompletedAsync ?? throw new ArgumentNullException(nameof(onCompletedAsync));
         }
 
         protected override ValueTask OnCompletedAsyncCore() => _onCompletedAsync();

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

@@ -23,10 +23,7 @@ namespace System.Reactive.Disposables
         {
             private Func<ValueTask> _dispose;
 
-            public AnonymousAsyncDisposable(Func<ValueTask> dispose)
-            {
-                _dispose = dispose;
-            }
+            public AnonymousAsyncDisposable(Func<ValueTask> dispose) => _dispose = dispose;
 
             public ValueTask DisposeAsync() => Interlocked.Exchange(ref _dispose, null)?.Invoke() ?? default;
         }

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

@@ -18,10 +18,7 @@ namespace System.Reactive.Disposables
 
         public CancellationAsyncDisposable(CancellationTokenSource cts)
         {
-            if (cts == null)
-                throw new ArgumentNullException(nameof(cts));
-
-            _cts = cts;
+            _cts = cts ?? throw new ArgumentNullException(nameof(cts));
         }
 
         public CancellationToken Token => _cts.Token;

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

@@ -16,10 +16,7 @@ namespace System.Reactive.Disposables
 
         public RefCountAsyncDisposable(IAsyncDisposable disposable)
         {
-            if (disposable == null)
-                throw new ArgumentNullException(nameof(disposable));
-
-            _disposable = disposable;
+            _disposable = disposable ?? throw new ArgumentNullException(nameof(disposable));
             _primaryDisposed = false;
             _count = 0;
         }

AsyncRx.NET/System.Reactive.Async.Linq/System/Runtime/CompilerServices/AsyncObservableMethodBuilder.cs

@@ -57,13 +57,10 @@ namespace System.Runtime.CompilerServices
         /// <exception cref="InvalidOperationException">The state machine was previously set.</exception>
         public void SetStateMachine(IAsyncStateMachine stateMachine)
         {
-            if (stateMachine == null)
-                throw new ArgumentNullException(nameof(stateMachine));
-
             if (_stateMachine != null)
                 throw new InvalidOperationException();
 
-            _stateMachine = stateMachine;
+            _stateMachine = stateMachine ?? throw new ArgumentNullException(nameof(stateMachine));
         }
 
         /// <summary>

AsyncRx.NET/System.Reactive.Async.Subjects/System/Reactive/Subjects/ReplayAsyncSubject.cs

@@ -13,7 +13,7 @@ namespace System.Reactive.Subjects
 {
     public abstract class ReplayAsyncSubject<T> : IAsyncSubject<T>
     {
-        protected readonly IAsyncSubject<T> _impl;
+        private readonly IAsyncSubject<T> _impl;
 
         public ReplayAsyncSubject(bool concurrent)
             : this(concurrent, int.MaxValue)
@@ -361,7 +361,7 @@ namespace System.Reactive.Subjects
 
         private abstract class ReplayManyBase : ReplayBufferBase
         {
-            protected readonly Queue<T> _values = new Queue<T>();
+            protected readonly Queue<T> Values = new Queue<T>();
 
             public ReplayManyBase(bool concurrent, Func<IAsyncObserver<T>, IScheduledAsyncObserver<T>> createObserver)
                 : base(concurrent, createObserver)
@@ -370,16 +370,16 @@ namespace System.Reactive.Subjects
 
             protected override Task NextAsync(T value)
             {
-                _values.Enqueue(value);
+                Values.Enqueue(value);
 
                 return Task.CompletedTask;
             }
 
             protected override async Task<int> ReplayAsync(IScheduledAsyncObserver<T> observer)
             {
-                var count = _values.Count;
+                var count = Values.Count;
 
-                foreach (var value in _values)
+                foreach (var value in Values)
                 {
                     await observer.OnNextAsync(value).ConfigureAwait(false);
                 }
@@ -400,9 +400,9 @@ namespace System.Reactive.Subjects
 
             protected override void Trim()
             {
-                while (_values.Count > _bufferSize)
+                while (Values.Count > _bufferSize)
                 {
-                    _values.Dequeue();
+                    Values.Dequeue();
                 }
             }
         }

AsyncRx.NET/System.Reactive.Bcl/System/Threading/AsyncLock.cs

@@ -9,30 +9,30 @@ namespace System.Threading
 {
     public sealed class AsyncLock
     {
-        private readonly object gate = new object();
-        private readonly SemaphoreSlim semaphore = new SemaphoreSlim(1, 1);
-        private readonly AsyncLocal<int> recursionCount = new AsyncLocal<int>();
+        private readonly object _gate = new object();
+        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
+        private readonly AsyncLocal<int> _recursionCount = new AsyncLocal<int>();
 
         public Task<Releaser> LockAsync()
         {
             var shouldAcquire = false;
 
-            lock (gate)
+            lock (_gate)
             {
-                if (recursionCount.Value == 0)
+                if (_recursionCount.Value == 0)
                 {
                     shouldAcquire = true;
-                    recursionCount.Value = 1;
+                    _recursionCount.Value = 1;
                 }
                 else
                 {
-                    recursionCount.Value++;
+                    _recursionCount.Value++;
                 }
             }
 
             if (shouldAcquire)
             {
-                return semaphore.WaitAsync().ContinueWith(_ => new Releaser(this));
+                return _semaphore.WaitAsync().ContinueWith(_ => new Releaser(this));
             }
 
             return Task.FromResult(new Releaser(this));
@@ -40,24 +40,24 @@ namespace System.Threading
 
         private void Release()
         {
-            lock (gate)
+            lock (_gate)
             {
-                Debug.Assert(recursionCount.Value > 0);
+                Debug.Assert(_recursionCount.Value > 0);
 
-                if (--recursionCount.Value == 0)
+                if (--_recursionCount.Value == 0)
                 {
-                    semaphore.Release();
+                    _semaphore.Release();
                 }
             }
         }
 
         public struct Releaser : IDisposable
         {
-            private readonly AsyncLock parent;
+            private readonly AsyncLock _parent;
 
-            public Releaser(AsyncLock parent) => this.parent = parent;
+            public Releaser(AsyncLock parent) => _parent = parent;
 
-            public void Dispose() => parent.Release();
+            public void Dispose() => _parent.Release();
         }
     }
 }