More code cleanup.

Ix.NET/Source/System.Interactive.Async/AsyncIterator.cs

@@ -10,9 +10,9 @@ namespace System.Linq
 {
     internal abstract class AsyncIterator<TSource> : IAsyncEnumerable<TSource>, IAsyncEnumerator<TSource>
     {
-        private readonly int threadId;
+        private readonly int _threadId;
 
-        private bool currentIsInvalid = true;
+        private bool _currentIsInvalid = true;
 
         internal TSource current;
         internal AsyncIteratorState state = AsyncIteratorState.New;
@@ -20,12 +20,12 @@ namespace System.Linq
 
         protected AsyncIterator()
         {
-            threadId = Environment.CurrentManagedThreadId;
+            _threadId = Environment.CurrentManagedThreadId;
         }
 
         public IAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken token)
         {
-            var enumerator = state == AsyncIteratorState.New && threadId == Environment.CurrentManagedThreadId
+            var enumerator = state == AsyncIteratorState.New && _threadId == Environment.CurrentManagedThreadId
                 ? this
                 : Clone();
 
@@ -57,7 +57,7 @@ namespace System.Linq
         {
             get
             {
-                if (currentIsInvalid)
+                if (_currentIsInvalid)
                     throw new InvalidOperationException("Enumerator is in an invalid state");
 
                 return current;
@@ -79,13 +79,13 @@ namespace System.Linq
             {
                 var result = await MoveNextCore(token).ConfigureAwait(false);
 
-                currentIsInvalid = !result; // if move next is false, invalid otherwise valid
+                _currentIsInvalid = !result; // if move next is false, invalid otherwise valid
 
                 return result;
             }
             catch
             {
-                currentIsInvalid = true;
+                _currentIsInvalid = true;
                 await DisposeAsync().ConfigureAwait(false);
                 throw;
             }

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Amb.cs

@@ -39,31 +39,31 @@ namespace System.Linq
 
         private sealed class AmbAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly IAsyncEnumerable<TSource> first;
-            private readonly IAsyncEnumerable<TSource> second;
+            private readonly IAsyncEnumerable<TSource> _first;
+            private readonly IAsyncEnumerable<TSource> _second;
 
-            private IAsyncEnumerator<TSource> enumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public AmbAsyncIterator(IAsyncEnumerable<TSource> first, IAsyncEnumerable<TSource> second)
             {
                 Debug.Assert(first != null);
                 Debug.Assert(second != null);
 
-                this.first = first;
-                this.second = second;
+                _first = first;
+                _second = second;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new AmbAsyncIterator<TSource>(first, second);
+                return new AmbAsyncIterator<TSource>(_first, _second);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -74,8 +74,8 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        var firstEnumerator = first.GetAsyncEnumerator(cancellationToken);
-                        var secondEnumerator = second.GetAsyncEnumerator(cancellationToken);
+                        var firstEnumerator = _first.GetAsyncEnumerator(cancellationToken);
+                        var secondEnumerator = _second.GetAsyncEnumerator(cancellationToken);
 
                         var firstMoveNext = firstEnumerator.MoveNextAsync().AsTask();
                         var secondMoveNext = secondEnumerator.MoveNextAsync().AsTask();
@@ -93,7 +93,7 @@ namespace System.Linq
 
                         if (winner == firstMoveNext)
                         {
-                            enumerator = firstEnumerator;
+                            _enumerator = firstEnumerator;
 
                             var ignored = secondMoveNext.ContinueWith(_ =>
                             {
@@ -102,7 +102,7 @@ namespace System.Linq
                         }
                         else
                         {
-                            enumerator = secondEnumerator;
+                            _enumerator = secondEnumerator;
 
                             var ignored = firstMoveNext.ContinueWith(_ =>
                             {
@@ -114,16 +114,16 @@ namespace System.Linq
 
                         if (await winner.ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 
                         break;
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 
@@ -137,28 +137,28 @@ namespace System.Linq
 
         private sealed class AmbAsyncIteratorN<TSource> : AsyncIterator<TSource>
         {
-            private readonly IAsyncEnumerable<TSource>[] sources;
+            private readonly IAsyncEnumerable<TSource>[] _sources;
 
-            private IAsyncEnumerator<TSource> enumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public AmbAsyncIteratorN(IAsyncEnumerable<TSource>[] sources)
             {
                 Debug.Assert(sources != null);
 
-                this.sources = sources;
+                _sources = sources;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new AmbAsyncIteratorN<TSource>(sources);
+                return new AmbAsyncIteratorN<TSource>(_sources);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -169,14 +169,14 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        var n = sources.Length;
+                        var n = _sources.Length;
 
                         var enumerators = new IAsyncEnumerator<TSource>[n];
                         var moveNexts = new ValueTask<bool>[n];
 
                         for (var i = 0; i < n; i++)
                         {
-                            var enumerator = sources[i].GetAsyncEnumerator(cancellationToken);
+                            var enumerator = _sources[i].GetAsyncEnumerator(cancellationToken);
 
                             enumerators[i] = enumerator;
                             moveNexts[i] = enumerator.MoveNextAsync();
@@ -195,7 +195,7 @@ namespace System.Linq
 
                         var winnerIndex = Array.IndexOf(moveNexts, winner);
 
-                        enumerator = enumerators[winnerIndex];
+                        _enumerator = enumerators[winnerIndex];
 
                         for (var i = 0; i < n; i++)
                         {
@@ -212,16 +212,16 @@ namespace System.Linq
 
                         if (await winner.ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 
                         break;
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Buffer.cs

@@ -48,38 +48,38 @@ namespace System.Linq
 
         private sealed class BufferAsyncIterator<TSource> : AsyncIterator<IList<TSource>>
         {
-            private readonly int count;
-            private readonly int skip;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly int _count;
+            private readonly int _skip;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private Queue<IList<TSource>> buffers;
-            private IAsyncEnumerator<TSource> enumerator;
-            private int index;
-            private bool stopped;
+            private Queue<IList<TSource>> _buffers;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private int _index;
+            private bool _stopped;
 
             public BufferAsyncIterator(IAsyncEnumerable<TSource> source, int count, int skip)
             {
                 Debug.Assert(source != null);
 
-                this.source = source;
-                this.count = count;
-                this.skip = skip;
+                _source = source;
+                _count = count;
+                _skip = skip;
             }
 
             public override AsyncIterator<IList<TSource>> Clone()
             {
-                return new BufferAsyncIterator<TSource>(source, count, skip);
+                return new BufferAsyncIterator<TSource>(_source, _count, _skip);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
-                buffers = null;
+                _buffers = null;
 
                 await base.DisposeAsync().ConfigureAwait(false);
             }
@@ -89,10 +89,10 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        buffers = new Queue<IList<TSource>>();
-                        index = 0;
-                        stopped = false;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _buffers = new Queue<IList<TSource>>();
+                        _index = 0;
+                        _stopped = false;
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
@@ -100,40 +100,40 @@ namespace System.Linq
                     case AsyncIteratorState.Iterating:
                         while (true)
                         {
-                            if (!stopped)
+                            if (!_stopped)
                             {
-                                if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                                if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                                 {
-                                    var item = enumerator.Current;
-                                    if (index++ % skip == 0)
+                                    var item = _enumerator.Current;
+                                    if (_index++ % _skip == 0)
                                     {
-                                        buffers.Enqueue(new List<TSource>(count));
+                                        _buffers.Enqueue(new List<TSource>(_count));
                                     }
 
-                                    foreach (var buffer in buffers)
+                                    foreach (var buffer in _buffers)
                                     {
                                         buffer.Add(item);
                                     }
 
-                                    if (buffers.Count > 0 && buffers.Peek().Count == count)
+                                    if (_buffers.Count > 0 && _buffers.Peek().Count == _count)
                                     {
-                                        current = buffers.Dequeue();
+                                        current = _buffers.Dequeue();
                                         return true;
                                     }
 
                                     continue; // loop
                                 }
 
-                                stopped = true;
-                                await enumerator.DisposeAsync().ConfigureAwait(false);
-                                enumerator = null;
+                                _stopped = true;
+                                await _enumerator.DisposeAsync().ConfigureAwait(false);
+                                _enumerator = null;
 
                                 continue; // loop
                             }
 
-                            if (buffers.Count > 0)
+                            if (_buffers.Count > 0)
                             {
-                                current = buffers.Dequeue();
+                                current = _buffers.Dequeue();
                                 return true;
                             }
 

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Catch.cs

@@ -67,32 +67,32 @@ namespace System.Linq
 
         private sealed class CatchAsyncIterator<TSource, TException> : AsyncIterator<TSource> where TException : Exception
         {
-            private readonly Func<TException, IAsyncEnumerable<TSource>> handler;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TException, IAsyncEnumerable<TSource>> _handler;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
-            private bool isDone;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private bool _isDone;
 
             public CatchAsyncIterator(IAsyncEnumerable<TSource> source, Func<TException, IAsyncEnumerable<TSource>> handler)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(handler != null);
 
-                this.source = source;
-                this.handler = handler;
+                _source = source;
+                _handler = handler;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new CatchAsyncIterator<TSource, TException>(source, handler);
+                return new CatchAsyncIterator<TSource, TException>(_source, _handler);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -103,8 +103,8 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        isDone = false;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _isDone = false;
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
@@ -112,13 +112,13 @@ namespace System.Linq
                     case AsyncIteratorState.Iterating:
                         while (true)
                         {
-                            if (!isDone)
+                            if (!_isDone)
                             {
                                 try
                                 {
-                                    if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                                    if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                                     {
-                                        current = enumerator.Current;
+                                        current = _enumerator.Current;
                                         return true;
                                     }
                                 }
@@ -127,23 +127,23 @@ namespace System.Linq
                                     // Note: Ideally we'd dipose of the previous enumerator before
                                     // invoking the handler, but we use this order to preserve
                                     // current behavior
-                                    var inner = handler(ex);
+                                    var inner = _handler(ex);
                                     var err = inner.GetAsyncEnumerator(cancellationToken);
 
-                                    if (enumerator != null)
+                                    if (_enumerator != null)
                                     {
-                                        await enumerator.DisposeAsync().ConfigureAwait(false);
+                                        await _enumerator.DisposeAsync().ConfigureAwait(false);
                                     }
 
-                                    enumerator = err;
-                                    isDone = true;
+                                    _enumerator = err;
+                                    _isDone = true;
                                     continue; // loop so we hit the catch state
                                 }
                             }
 
-                            if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                            if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                             {
-                                current = enumerator.Current;
+                                current = _enumerator.Current;
                                 return true;
                             }
 
@@ -160,32 +160,32 @@ namespace System.Linq
 
         private sealed class CatchAsyncIteratorWithTask<TSource, TException> : AsyncIterator<TSource> where TException : Exception
         {
-            private readonly Func<TException, Task<IAsyncEnumerable<TSource>>> handler;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TException, Task<IAsyncEnumerable<TSource>>> _handler;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
-            private bool isDone;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private bool _isDone;
 
             public CatchAsyncIteratorWithTask(IAsyncEnumerable<TSource> source, Func<TException, Task<IAsyncEnumerable<TSource>>> handler)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(handler != null);
 
-                this.source = source;
-                this.handler = handler;
+                _source = source;
+                _handler = handler;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new CatchAsyncIteratorWithTask<TSource, TException>(source, handler);
+                return new CatchAsyncIteratorWithTask<TSource, TException>(_source, _handler);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -196,8 +196,8 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        isDone = false;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _isDone = false;
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
@@ -205,13 +205,13 @@ namespace System.Linq
                     case AsyncIteratorState.Iterating:
                         while (true)
                         {
-                            if (!isDone)
+                            if (!_isDone)
                             {
                                 try
                                 {
-                                    if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                                    if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                                     {
-                                        current = enumerator.Current;
+                                        current = _enumerator.Current;
                                         return true;
                                     }
                                 }
@@ -220,23 +220,23 @@ namespace System.Linq
                                     // Note: Ideally we'd dipose of the previous enumerator before
                                     // invoking the handler, but we use this order to preserve
                                     // current behavior
-                                    var inner = await handler(ex).ConfigureAwait(false);
+                                    var inner = await _handler(ex).ConfigureAwait(false);
                                     var err = inner.GetAsyncEnumerator(cancellationToken);
 
-                                    if (enumerator != null)
+                                    if (_enumerator != null)
                                     {
-                                        await enumerator.DisposeAsync().ConfigureAwait(false);
+                                        await _enumerator.DisposeAsync().ConfigureAwait(false);
                                     }
 
-                                    enumerator = err;
-                                    isDone = true;
+                                    _enumerator = err;
+                                    _isDone = true;
                                     continue; // loop so we hit the catch state
                                 }
                             }
 
-                            if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                            if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                             {
-                                current = enumerator.Current;
+                                current = _enumerator.Current;
                                 return true;
                             }
 
@@ -253,40 +253,40 @@ namespace System.Linq
 
         private sealed class CatchAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly IEnumerable<IAsyncEnumerable<TSource>> sources;
+            private readonly IEnumerable<IAsyncEnumerable<TSource>> _sources;
 
-            private IAsyncEnumerator<TSource> enumerator;
-            private ExceptionDispatchInfo error;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private ExceptionDispatchInfo _error;
 
-            private IEnumerator<IAsyncEnumerable<TSource>> sourcesEnumerator;
+            private IEnumerator<IAsyncEnumerable<TSource>> _sourcesEnumerator;
 
             public CatchAsyncIterator(IEnumerable<IAsyncEnumerable<TSource>> sources)
             {
                 Debug.Assert(sources != null);
 
-                this.sources = sources;
+                _sources = sources;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new CatchAsyncIterator<TSource>(sources);
+                return new CatchAsyncIterator<TSource>(_sources);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (sourcesEnumerator != null)
+                if (_sourcesEnumerator != null)
                 {
-                    sourcesEnumerator.Dispose();
-                    sourcesEnumerator = null;
+                    _sourcesEnumerator.Dispose();
+                    _sourcesEnumerator = null;
                 }
 
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
-                error = null;
+                _error = null;
 
                 await base.DisposeAsync().ConfigureAwait(false);
             }
@@ -296,7 +296,7 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        sourcesEnumerator = sources.GetEnumerator();
+                        _sourcesEnumerator = _sources.GetEnumerator();
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
@@ -304,33 +304,33 @@ namespace System.Linq
                     case AsyncIteratorState.Iterating:
                         while (true)
                         {
-                            if (enumerator == null)
+                            if (_enumerator == null)
                             {
-                                if (!sourcesEnumerator.MoveNext())
+                                if (!_sourcesEnumerator.MoveNext())
                                 {
                                     // only throw if we have an error on the last one
-                                    error?.Throw();
+                                    _error?.Throw();
                                     break; // done, nothing else to do
                                 }
 
-                                error = null;
-                                enumerator = sourcesEnumerator.Current.GetAsyncEnumerator(cancellationToken);
+                                _error = null;
+                                _enumerator = _sourcesEnumerator.Current.GetAsyncEnumerator(cancellationToken);
                             }
 
                             try
                             {
-                                if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                                if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                                 {
-                                    current = enumerator.Current;
+                                    current = _enumerator.Current;
                                     return true;
                                 }
                             }
                             catch (Exception ex)
                             {
                                 // Done with the current one, go to the next
-                                await enumerator.DisposeAsync().ConfigureAwait(false);
-                                enumerator = null;
-                                error = ExceptionDispatchInfo.Capture(ex);
+                                await _enumerator.DisposeAsync().ConfigureAwait(false);
+                                _enumerator = null;
+                                _error = ExceptionDispatchInfo.Capture(ex);
                                 continue;
                             }
 

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Concat.cs

@@ -42,79 +42,78 @@ namespace System.Linq
 
         private sealed class ConcatEnumerableAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly IEnumerable<IAsyncEnumerable<TSource>> source;
+            private readonly IEnumerable<IAsyncEnumerable<TSource>> _source;
 
             public ConcatEnumerableAsyncIterator(IEnumerable<IAsyncEnumerable<TSource>> source)
             {
                 Debug.Assert(source != null);
 
-                this.source = source;
+                _source = source;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new ConcatEnumerableAsyncIterator<TSource>(source);
+                return new ConcatEnumerableAsyncIterator<TSource>(_source);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (outerEnumerator != null)
+                if (_outerEnumerator != null)
                 {
-                    outerEnumerator.Dispose();
-                    outerEnumerator = null;
+                    _outerEnumerator.Dispose();
+                    _outerEnumerator = null;
                 }
 
-                if (currentEnumerator != null)
+                if (_currentEnumerator != null)
                 {
-                    await currentEnumerator.DisposeAsync().ConfigureAwait(false);
-                    currentEnumerator = null;
+                    await _currentEnumerator.DisposeAsync().ConfigureAwait(false);
+                    _currentEnumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
             }
 
             // State machine vars
-            private IEnumerator<IAsyncEnumerable<TSource>> outerEnumerator;
-            private IAsyncEnumerator<TSource> currentEnumerator;
-            private int mode;
+            private IEnumerator<IAsyncEnumerable<TSource>> _outerEnumerator;
+            private IAsyncEnumerator<TSource> _currentEnumerator;
+            private int _mode;
 
             private const int State_OuterNext = 1;
             private const int State_While = 4;
 
             protected override async ValueTask<bool> MoveNextCore(CancellationToken cancellationToken)
             {
-
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        outerEnumerator = source.GetEnumerator();
-                        mode = State_OuterNext;
+                        _outerEnumerator = _source.GetEnumerator();
+                        _mode = State_OuterNext;
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        switch (mode)
+                        switch (_mode)
                         {
                             case State_OuterNext:
-                                if (outerEnumerator.MoveNext())
+                                if (_outerEnumerator.MoveNext())
                                 {
                                     // make sure we dispose the previous one if we're about to replace it
-                                    if (currentEnumerator != null)
+                                    if (_currentEnumerator != null)
                                     {
-                                        await currentEnumerator.DisposeAsync().ConfigureAwait(false);
+                                        await _currentEnumerator.DisposeAsync().ConfigureAwait(false);
                                     }
 
-                                    currentEnumerator = outerEnumerator.Current.GetAsyncEnumerator(cancellationToken);
+                                    _currentEnumerator = _outerEnumerator.Current.GetAsyncEnumerator(cancellationToken);
 
-                                    mode = State_While;
+                                    _mode = State_While;
                                     goto case State_While;
                                 }
 
                                 break;
                             case State_While:
-                                if (await currentEnumerator.MoveNextAsync().ConfigureAwait(false))
+                                if (await _currentEnumerator.MoveNextAsync().ConfigureAwait(false))
                                 {
-                                    current = currentEnumerator.Current;
+                                    current = _currentEnumerator.Current;
                                     return true;
                                 }
 
@@ -132,79 +131,78 @@ namespace System.Linq
 
         private sealed class ConcatAsyncEnumerableAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly IAsyncEnumerable<IAsyncEnumerable<TSource>> source;
+            private readonly IAsyncEnumerable<IAsyncEnumerable<TSource>> _source;
 
             public ConcatAsyncEnumerableAsyncIterator(IAsyncEnumerable<IAsyncEnumerable<TSource>> source)
             {
                 Debug.Assert(source != null);
 
-                this.source = source;
+                _source = source;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new ConcatAsyncEnumerableAsyncIterator<TSource>(source);
+                return new ConcatAsyncEnumerableAsyncIterator<TSource>(_source);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (outerEnumerator != null)
+                if (_outerEnumerator != null)
                 {
-                    await outerEnumerator.DisposeAsync().ConfigureAwait(false);
-                    outerEnumerator = null;
+                    await _outerEnumerator.DisposeAsync().ConfigureAwait(false);
+                    _outerEnumerator = null;
                 }
 
-                if (currentEnumerator != null)
+                if (_currentEnumerator != null)
                 {
-                    await currentEnumerator.DisposeAsync().ConfigureAwait(false);
-                    currentEnumerator = null;
+                    await _currentEnumerator.DisposeAsync().ConfigureAwait(false);
+                    _currentEnumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
             }
 
             // State machine vars
-            private IAsyncEnumerator<IAsyncEnumerable<TSource>> outerEnumerator;
-            private IAsyncEnumerator<TSource> currentEnumerator;
-            private int mode;
+            private IAsyncEnumerator<IAsyncEnumerable<TSource>> _outerEnumerator;
+            private IAsyncEnumerator<TSource> _currentEnumerator;
+            private int _mode;
 
             private const int State_OuterNext = 1;
             private const int State_While = 4;
 
             protected override async ValueTask<bool> MoveNextCore(CancellationToken cancellationToken)
             {
-
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        outerEnumerator = source.GetAsyncEnumerator(cancellationToken);
-                        mode = State_OuterNext;
+                        _outerEnumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _mode = State_OuterNext;
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        switch (mode)
+                        switch (_mode)
                         {
                             case State_OuterNext:
-                                if (await outerEnumerator.MoveNextAsync().ConfigureAwait(false))
+                                if (await _outerEnumerator.MoveNextAsync().ConfigureAwait(false))
                                 {
                                     // make sure we dispose the previous one if we're about to replace it
-                                    if (currentEnumerator != null)
+                                    if (_currentEnumerator != null)
                                     {
-                                        await currentEnumerator.DisposeAsync().ConfigureAwait(false);
+                                        await _currentEnumerator.DisposeAsync().ConfigureAwait(false);
                                     }
 
-                                    currentEnumerator = outerEnumerator.Current.GetAsyncEnumerator(cancellationToken);
+                                    _currentEnumerator = _outerEnumerator.Current.GetAsyncEnumerator(cancellationToken);
 
-                                    mode = State_While;
+                                    _mode = State_While;
                                     goto case State_While;
                                 }
 
                                 break;
                             case State_While:
-                                if (await currentEnumerator.MoveNextAsync().ConfigureAwait(false))
+                                if (await _currentEnumerator.MoveNextAsync().ConfigureAwait(false))
                                 {
-                                    current = currentEnumerator.Current;
+                                    current = _currentEnumerator.Current;
                                     return true;
                                 }
 

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Distinct.cs

@@ -67,12 +67,12 @@ namespace System.Linq
 
         private sealed class DistinctAsyncIterator<TSource, TKey> : AsyncIterator<TSource>, IAsyncIListProvider<TSource>
         {
-            private readonly IEqualityComparer<TKey> comparer;
-            private readonly Func<TSource, TKey> keySelector;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly IEqualityComparer<TKey> _comparer;
+            private readonly Func<TSource, TKey> _keySelector;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
-            private Set<TKey> set;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private Set<TKey> _set;
 
             public DistinctAsyncIterator(IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
             {
@@ -80,9 +80,9 @@ namespace System.Linq
                 Debug.Assert(keySelector != null);
                 Debug.Assert(comparer != null);
 
-                this.source = source;
-                this.keySelector = keySelector;
-                this.comparer = comparer;
+                _source = source;
+                _keySelector = keySelector;
+                _comparer = comparer;
             }
 
             public async Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
@@ -105,16 +105,16 @@ namespace System.Linq
                 }
 
                 var count = 0;
-                var s = new Set<TKey>(comparer);
+                var s = new Set<TKey>(_comparer);
 
-                var enu = source.GetAsyncEnumerator(cancellationToken);
+                var enu = _source.GetAsyncEnumerator(cancellationToken);
 
                 try
                 {
                     while (await enu.MoveNextAsync().ConfigureAwait(false))
                     {
                         var item = enu.Current;
-                        if (s.Add(keySelector(item)))
+                        if (s.Add(_keySelector(item)))
                         {
                             count++;
                         }
@@ -130,16 +130,16 @@ namespace System.Linq
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new DistinctAsyncIterator<TSource, TKey>(source, keySelector, comparer);
+                return new DistinctAsyncIterator<TSource, TKey>(_source, _keySelector, _comparer);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
-                    set = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
+                    _set = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -150,27 +150,27 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
 
-                        if (!await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (!await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
                             await DisposeAsync().ConfigureAwait(false);
                             return false;
                         }
 
-                        var element = enumerator.Current;
-                        set = new Set<TKey>(comparer);
-                        set.Add(keySelector(element));
+                        var element = _enumerator.Current;
+                        _set = new Set<TKey>(_comparer);
+                        _set.Add(_keySelector(element));
                         current = element;
 
                         state = AsyncIteratorState.Iterating;
                         return true;
 
                     case AsyncIteratorState.Iterating:
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            element = enumerator.Current;
-                            if (set.Add(keySelector(element)))
+                            element = _enumerator.Current;
+                            if (_set.Add(_keySelector(element)))
                             {
                                 current = element;
                                 return true;
@@ -186,17 +186,17 @@ namespace System.Linq
 
             private async Task<List<TSource>> FillSetAsync(CancellationToken cancellationToken)
             {
-                var s = new Set<TKey>(comparer);
+                var s = new Set<TKey>(_comparer);
                 var r = new List<TSource>();
 
-                var enu = source.GetAsyncEnumerator(cancellationToken);
+                var enu = _source.GetAsyncEnumerator(cancellationToken);
 
                 try
                 {
                     while (await enu.MoveNextAsync(cancellationToken).ConfigureAwait(false))
                     {
                         var item = enu.Current;
-                        if (s.Add(keySelector(item)))
+                        if (s.Add(_keySelector(item)))
                         {
                             r.Add(item);
                         }
@@ -213,12 +213,12 @@ namespace System.Linq
 
         private sealed class DistinctAsyncIteratorWithTask<TSource, TKey> : AsyncIterator<TSource>, IAsyncIListProvider<TSource>
         {
-            private readonly IEqualityComparer<TKey> comparer;
-            private readonly Func<TSource, Task<TKey>> keySelector;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly IEqualityComparer<TKey> _comparer;
+            private readonly Func<TSource, Task<TKey>> _keySelector;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
-            private Set<TKey> set;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private Set<TKey> _set;
 
             public DistinctAsyncIteratorWithTask(IAsyncEnumerable<TSource> source, Func<TSource, Task<TKey>> keySelector, IEqualityComparer<TKey> comparer)
             {
@@ -226,9 +226,9 @@ namespace System.Linq
                 Debug.Assert(keySelector != null);
                 Debug.Assert(comparer != null);
 
-                this.source = source;
-                this.keySelector = keySelector;
-                this.comparer = comparer;
+                _source = source;
+                _keySelector = keySelector;
+                _comparer = comparer;
             }
 
             public async Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
@@ -251,16 +251,16 @@ namespace System.Linq
                 }
 
                 var count = 0;
-                var s = new Set<TKey>(comparer);
+                var s = new Set<TKey>(_comparer);
 
-                var enu = source.GetAsyncEnumerator(cancellationToken);
+                var enu = _source.GetAsyncEnumerator(cancellationToken);
 
                 try
                 {
                     while (await enu.MoveNextAsync().ConfigureAwait(false))
                     {
                         var item = enu.Current;
-                        if (s.Add(await keySelector(item).ConfigureAwait(false)))
+                        if (s.Add(await _keySelector(item).ConfigureAwait(false)))
                         {
                             count++;
                         }
@@ -276,16 +276,16 @@ namespace System.Linq
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new DistinctAsyncIteratorWithTask<TSource, TKey>(source, keySelector, comparer);
+                return new DistinctAsyncIteratorWithTask<TSource, TKey>(_source, _keySelector, _comparer);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
-                    set = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
+                    _set = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -296,27 +296,27 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
 
-                        if (!await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (!await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
                             await DisposeAsync().ConfigureAwait(false);
                             return false;
                         }
 
-                        var element = enumerator.Current;
-                        set = new Set<TKey>(comparer);
-                        set.Add(await keySelector(element).ConfigureAwait(false));
+                        var element = _enumerator.Current;
+                        _set = new Set<TKey>(_comparer);
+                        _set.Add(await _keySelector(element).ConfigureAwait(false));
                         current = element;
 
                         state = AsyncIteratorState.Iterating;
                         return true;
 
                     case AsyncIteratorState.Iterating:
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            element = enumerator.Current;
-                            if (set.Add(await keySelector(element).ConfigureAwait(false)))
+                            element = _enumerator.Current;
+                            if (_set.Add(await _keySelector(element).ConfigureAwait(false)))
                             {
                                 current = element;
                                 return true;
@@ -332,17 +332,17 @@ namespace System.Linq
 
             private async Task<List<TSource>> FillSetAsync(CancellationToken cancellationToken)
             {
-                var s = new Set<TKey>(comparer);
+                var s = new Set<TKey>(_comparer);
                 var r = new List<TSource>();
 
-                var enu = source.GetAsyncEnumerator(cancellationToken);
+                var enu = _source.GetAsyncEnumerator(cancellationToken);
 
                 try
                 {
                     while (await enu.MoveNextAsync(cancellationToken).ConfigureAwait(false))
                     {
                         var item = enu.Current;
-                        if (s.Add(await keySelector(item).ConfigureAwait(false)))
+                        if (s.Add(await _keySelector(item).ConfigureAwait(false)))
                         {
                             r.Add(item);
                         }

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/DistinctUntilChanged.cs

@@ -90,34 +90,34 @@ namespace System.Linq
 
         private sealed class DistinctUntilChangedAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly IEqualityComparer<TSource> comparer;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly IEqualityComparer<TSource> _comparer;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private TSource currentValue;
-            private IAsyncEnumerator<TSource> enumerator;
-            private bool hasCurrentValue;
+            private TSource _currentValue;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private bool _hasCurrentValue;
 
             public DistinctUntilChangedAsyncIterator(IAsyncEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
             {
                 Debug.Assert(comparer != null);
                 Debug.Assert(source != null);
 
-                this.source = source;
-                this.comparer = comparer;
+                _source = source;
+                _comparer = comparer;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new DistinctUntilChangedAsyncIterator<TSource>(source, comparer);
+                return new DistinctUntilChangedAsyncIterator<TSource>(_source, _comparer);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
-                    currentValue = default;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
+                    _currentValue = default;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -128,25 +128,25 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var item = enumerator.Current;
+                            var item = _enumerator.Current;
                             var comparerEquals = false;
 
-                            if (hasCurrentValue)
+                            if (_hasCurrentValue)
                             {
-                                comparerEquals = comparer.Equals(currentValue, item);
+                                comparerEquals = _comparer.Equals(_currentValue, item);
                             }
 
-                            if (!hasCurrentValue || !comparerEquals)
+                            if (!_hasCurrentValue || !comparerEquals)
                             {
-                                hasCurrentValue = true;
-                                currentValue = item;
+                                _hasCurrentValue = true;
+                                _currentValue = item;
                                 current = item;
                                 return true;
                             }
@@ -162,33 +162,33 @@ namespace System.Linq
 
         private sealed class DistinctUntilChangedAsyncIterator<TSource, TKey> : AsyncIterator<TSource>
         {
-            private readonly IEqualityComparer<TKey> comparer;
-            private readonly Func<TSource, TKey> keySelector;
-            private readonly IAsyncEnumerable<TSource> source;
-            private TKey currentKeyValue;
+            private readonly IEqualityComparer<TKey> _comparer;
+            private readonly Func<TSource, TKey> _keySelector;
+            private readonly IAsyncEnumerable<TSource> _source;
+            private TKey _currentKeyValue;
 
-            private IAsyncEnumerator<TSource> enumerator;
-            private bool hasCurrentKey;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private bool _hasCurrentKey;
 
             public DistinctUntilChangedAsyncIterator(IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
             {
-                this.source = source;
-                this.keySelector = keySelector;
-                this.comparer = comparer;
+                _source = source;
+                _keySelector = keySelector;
+                _comparer = comparer;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new DistinctUntilChangedAsyncIterator<TSource, TKey>(source, keySelector, comparer);
+                return new DistinctUntilChangedAsyncIterator<TSource, TKey>(_source, _keySelector, _comparer);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
-                    currentKeyValue = default;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
+                    _currentKeyValue = default;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -199,25 +199,25 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var item = enumerator.Current;
-                            var key = keySelector(item);
+                            var item = _enumerator.Current;
+                            var key = _keySelector(item);
                             var comparerEquals = false;
 
-                            if (hasCurrentKey)
+                            if (_hasCurrentKey)
                             {
-                                comparerEquals = comparer.Equals(currentKeyValue, key);
+                                comparerEquals = _comparer.Equals(_currentKeyValue, key);
                             }
-                            if (!hasCurrentKey || !comparerEquals)
+                            if (!_hasCurrentKey || !comparerEquals)
                             {
-                                hasCurrentKey = true;
-                                currentKeyValue = key;
+                                _hasCurrentKey = true;
+                                _currentKeyValue = key;
                                 current = item;
                                 return true;
                             }
@@ -233,33 +233,33 @@ namespace System.Linq
 
         private sealed class DistinctUntilChangedAsyncIteratorWithTask<TSource, TKey> : AsyncIterator<TSource>
         {
-            private readonly IEqualityComparer<TKey> comparer;
-            private readonly Func<TSource, Task<TKey>> keySelector;
-            private readonly IAsyncEnumerable<TSource> source;
-            private TKey currentKeyValue;
+            private readonly IEqualityComparer<TKey> _comparer;
+            private readonly Func<TSource, Task<TKey>> _keySelector;
+            private readonly IAsyncEnumerable<TSource> _source;
+            private TKey _currentKeyValue;
 
-            private IAsyncEnumerator<TSource> enumerator;
-            private bool hasCurrentKey;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private bool _hasCurrentKey;
 
             public DistinctUntilChangedAsyncIteratorWithTask(IAsyncEnumerable<TSource> source, Func<TSource, Task<TKey>> keySelector, IEqualityComparer<TKey> comparer)
             {
-                this.source = source;
-                this.keySelector = keySelector;
-                this.comparer = comparer;
+                _source = source;
+                _keySelector = keySelector;
+                _comparer = comparer;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new DistinctUntilChangedAsyncIteratorWithTask<TSource, TKey>(source, keySelector, comparer);
+                return new DistinctUntilChangedAsyncIteratorWithTask<TSource, TKey>(_source, _keySelector, _comparer);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
-                    currentKeyValue = default;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
+                    _currentKeyValue = default;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -270,25 +270,25 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var item = enumerator.Current;
-                            var key = await keySelector(item).ConfigureAwait(false);
+                            var item = _enumerator.Current;
+                            var key = await _keySelector(item).ConfigureAwait(false);
                             var comparerEquals = false;
 
-                            if (hasCurrentKey)
+                            if (_hasCurrentKey)
                             {
-                                comparerEquals = comparer.Equals(currentKeyValue, key);
+                                comparerEquals = _comparer.Equals(_currentKeyValue, key);
                             }
-                            if (!hasCurrentKey || !comparerEquals)
+                            if (!_hasCurrentKey || !comparerEquals)
                             {
-                                hasCurrentKey = true;
-                                currentKeyValue = key;
+                                _hasCurrentKey = true;
+                                _currentKeyValue = key;
                                 current = item;
                                 return true;
                             }

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Do.cs

@@ -129,35 +129,35 @@ namespace System.Linq
 
         private sealed class DoAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly Action onCompleted;
-            private readonly Action<Exception> onError;
-            private readonly Action<TSource> onNext;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Action _onCompleted;
+            private readonly Action<Exception> _onError;
+            private readonly Action<TSource> _onNext;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public DoAsyncIterator(IAsyncEnumerable<TSource> source, Action<TSource> onNext, Action<Exception> onError, Action onCompleted)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(onNext != null);
 
-                this.source = source;
-                this.onNext = onNext;
-                this.onError = onError;
-                this.onCompleted = onCompleted;
+                _source = source;
+                _onNext = onNext;
+                _onError = onError;
+                _onCompleted = onCompleted;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new DoAsyncIterator<TSource>(source, onNext, onError, onCompleted);
+                return new DoAsyncIterator<TSource>(_source, _onNext, _onError, _onCompleted);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -168,17 +168,17 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
                         try
                         {
-                            if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                            if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                             {
-                                current = enumerator.Current;
-                                onNext(current);
+                                current = _enumerator.Current;
+                                _onNext(current);
 
                                 return true;
                             }
@@ -187,13 +187,13 @@ namespace System.Linq
                         {
                             throw;
                         }
-                        catch (Exception ex) when (onError != null)
+                        catch (Exception ex) when (_onError != null)
                         {
-                            onError(ex);
+                            _onError(ex);
                             throw;
                         }
 
-                        onCompleted?.Invoke();
+                        _onCompleted?.Invoke();
 
                         await DisposeAsync().ConfigureAwait(false);
                         break;
@@ -205,35 +205,35 @@ namespace System.Linq
 
         private sealed class DoAsyncIteratorWithTask<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<Task> onCompleted;
-            private readonly Func<Exception, Task> onError;
-            private readonly Func<TSource, Task> onNext;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<Task> _onCompleted;
+            private readonly Func<Exception, Task> _onError;
+            private readonly Func<TSource, Task> _onNext;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public DoAsyncIteratorWithTask(IAsyncEnumerable<TSource> source, Func<TSource, Task> onNext, Func<Exception, Task> onError, Func<Task> onCompleted)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(onNext != null);
 
-                this.source = source;
-                this.onNext = onNext;
-                this.onError = onError;
-                this.onCompleted = onCompleted;
+                _source = source;
+                _onNext = onNext;
+                _onError = onError;
+                _onCompleted = onCompleted;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new DoAsyncIteratorWithTask<TSource>(source, onNext, onError, onCompleted);
+                return new DoAsyncIteratorWithTask<TSource>(_source, _onNext, _onError, _onCompleted);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -244,17 +244,17 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
                         try
                         {
-                            if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                            if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                             {
-                                current = enumerator.Current;
-                                await onNext(current).ConfigureAwait(false);
+                                current = _enumerator.Current;
+                                await _onNext(current).ConfigureAwait(false);
 
                                 return true;
                             }
@@ -263,15 +263,15 @@ namespace System.Linq
                         {
                             throw;
                         }
-                        catch (Exception ex) when (onError != null)
+                        catch (Exception ex) when (_onError != null)
                         {
-                            await onError(ex).ConfigureAwait(false);
+                            await _onError(ex).ConfigureAwait(false);
                             throw;
                         }
 
-                        if (onCompleted != null)
+                        if (_onCompleted != null)
                         {
-                            await onCompleted().ConfigureAwait(false);
+                            await _onCompleted().ConfigureAwait(false);
                         }
 
                         await DisposeAsync().ConfigureAwait(false);

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Expand.cs

@@ -33,36 +33,36 @@ namespace System.Linq
 
         private sealed class ExpandAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, IAsyncEnumerable<TSource>> selector;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, IAsyncEnumerable<TSource>> _selector;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
 
-            private Queue<IAsyncEnumerable<TSource>> queue;
+            private Queue<IAsyncEnumerable<TSource>> _queue;
 
             public ExpandAsyncIterator(IAsyncEnumerable<TSource> source, Func<TSource, IAsyncEnumerable<TSource>> selector)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(selector != null);
 
-                this.source = source;
-                this.selector = selector;
+                _source = source;
+                _selector = selector;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new ExpandAsyncIterator<TSource>(source, selector);
+                return new ExpandAsyncIterator<TSource>(_source, _selector);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
-                queue = null;
+                _queue = null;
 
                 await base.DisposeAsync().ConfigureAwait(false);
             }
@@ -72,8 +72,8 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        queue = new Queue<IAsyncEnumerable<TSource>>();
-                        queue.Enqueue(source);
+                        _queue = new Queue<IAsyncEnumerable<TSource>>();
+                        _queue.Enqueue(_source);
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
@@ -81,18 +81,18 @@ namespace System.Linq
                     case AsyncIteratorState.Iterating:
                         while (true)
                         {
-                            if (enumerator == null)
+                            if (_enumerator == null)
                             {
-                                if (queue.Count > 0)
+                                if (_queue.Count > 0)
                                 {
-                                    var src = queue.Dequeue();
+                                    var src = _queue.Dequeue();
 
-                                    if (enumerator != null)
+                                    if (_enumerator != null)
                                     {
-                                        await enumerator.DisposeAsync().ConfigureAwait(false);
+                                        await _enumerator.DisposeAsync().ConfigureAwait(false);
                                     }
 
-                                    enumerator = src.GetAsyncEnumerator(cancellationToken);
+                                    _enumerator = src.GetAsyncEnumerator(cancellationToken);
 
                                     continue; // loop
                                 }
@@ -100,17 +100,17 @@ namespace System.Linq
                                 break; // while
                             }
 
-                            if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                            if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                             {
-                                var item = enumerator.Current;
-                                var next = selector(item);
-                                queue.Enqueue(next);
+                                var item = _enumerator.Current;
+                                var next = _selector(item);
+                                _queue.Enqueue(next);
                                 current = item;
                                 return true;
                             }
 
-                            await enumerator.DisposeAsync().ConfigureAwait(false);
-                            enumerator = null;
+                            await _enumerator.DisposeAsync().ConfigureAwait(false);
+                            _enumerator = null;
                         }
 
                         break; // case
@@ -123,36 +123,36 @@ namespace System.Linq
 
         private sealed class ExpandAsyncIteratorWithTask<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, Task<IAsyncEnumerable<TSource>>> selector;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, Task<IAsyncEnumerable<TSource>>> _selector;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
 
-            private Queue<IAsyncEnumerable<TSource>> queue;
+            private Queue<IAsyncEnumerable<TSource>> _queue;
 
             public ExpandAsyncIteratorWithTask(IAsyncEnumerable<TSource> source, Func<TSource, Task<IAsyncEnumerable<TSource>>> selector)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(selector != null);
 
-                this.source = source;
-                this.selector = selector;
+                _source = source;
+                _selector = selector;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new ExpandAsyncIteratorWithTask<TSource>(source, selector);
+                return new ExpandAsyncIteratorWithTask<TSource>(_source, _selector);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
-                queue = null;
+                _queue = null;
 
                 await base.DisposeAsync().ConfigureAwait(false);
             }
@@ -162,8 +162,8 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        queue = new Queue<IAsyncEnumerable<TSource>>();
-                        queue.Enqueue(source);
+                        _queue = new Queue<IAsyncEnumerable<TSource>>();
+                        _queue.Enqueue(_source);
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
@@ -171,18 +171,18 @@ namespace System.Linq
                     case AsyncIteratorState.Iterating:
                         while (true)
                         {
-                            if (enumerator == null)
+                            if (_enumerator == null)
                             {
-                                if (queue.Count > 0)
+                                if (_queue.Count > 0)
                                 {
-                                    var src = queue.Dequeue();
+                                    var src = _queue.Dequeue();
 
-                                    if (enumerator != null)
+                                    if (_enumerator != null)
                                     {
-                                        await enumerator.DisposeAsync().ConfigureAwait(false);
+                                        await _enumerator.DisposeAsync().ConfigureAwait(false);
                                     }
 
-                                    enumerator = src.GetAsyncEnumerator(cancellationToken);
+                                    _enumerator = src.GetAsyncEnumerator(cancellationToken);
 
                                     continue; // loop
                                 }
@@ -190,17 +190,17 @@ namespace System.Linq
                                 break; // while
                             }
 
-                            if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                            if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                             {
-                                var item = enumerator.Current;
-                                var next = await selector(item).ConfigureAwait(false);
-                                queue.Enqueue(next);
+                                var item = _enumerator.Current;
+                                var next = await _selector(item).ConfigureAwait(false);
+                                _queue.Enqueue(next);
                                 current = item;
                                 return true;
                             }
 
-                            await enumerator.DisposeAsync().ConfigureAwait(false);
-                            enumerator = null;
+                            await _enumerator.DisposeAsync().ConfigureAwait(false);
+                            _enumerator = null;
                         }
 
                         break; // case

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Finally.cs

@@ -33,33 +33,33 @@ namespace System.Linq
 
         private sealed class FinallyAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly Action finallyAction;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Action _finallyAction;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public FinallyAsyncIterator(IAsyncEnumerable<TSource> source, Action finallyAction)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(finallyAction != null);
 
-                this.source = source;
-                this.finallyAction = finallyAction;
+                _source = source;
+                _finallyAction = finallyAction;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new FinallyAsyncIterator<TSource>(source, finallyAction);
+                return new FinallyAsyncIterator<TSource>(_source, _finallyAction);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
 
-                    finallyAction();
+                    _finallyAction();
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -70,14 +70,14 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 
@@ -91,33 +91,33 @@ namespace System.Linq
 
         private sealed class FinallyAsyncIteratorWithTask<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<Task> finallyAction;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<Task> _finallyAction;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public FinallyAsyncIteratorWithTask(IAsyncEnumerable<TSource> source, Func<Task> finallyAction)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(finallyAction != null);
 
-                this.source = source;
-                this.finallyAction = finallyAction;
+                _source = source;
+                _finallyAction = finallyAction;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new FinallyAsyncIteratorWithTask<TSource>(source, finallyAction);
+                return new FinallyAsyncIteratorWithTask<TSource>(_source, _finallyAction);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
 
-                    await finallyAction().ConfigureAwait(false);
+                    await _finallyAction().ConfigureAwait(false);
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -128,14 +128,14 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Generate.cs

@@ -33,14 +33,14 @@ namespace System.Linq
 
         private sealed class GenerateAsyncIterator<TState, TResult> : AsyncIterator<TResult>
         {
-            private readonly Func<TState, bool> condition;
-            private readonly TState initialState;
-            private readonly Func<TState, TState> iterate;
-            private readonly Func<TState, TResult> resultSelector;
+            private readonly Func<TState, bool> _condition;
+            private readonly TState _initialState;
+            private readonly Func<TState, TState> _iterate;
+            private readonly Func<TState, TResult> _resultSelector;
 
-            private TState currentState;
+            private TState _currentState;
 
-            private bool started;
+            private bool _started;
 
             public GenerateAsyncIterator(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector)
             {
@@ -48,20 +48,20 @@ namespace System.Linq
                 Debug.Assert(iterate != null);
                 Debug.Assert(resultSelector != null);
 
-                this.initialState = initialState;
-                this.condition = condition;
-                this.iterate = iterate;
-                this.resultSelector = resultSelector;
+                _initialState = initialState;
+                _condition = condition;
+                _iterate = iterate;
+                _resultSelector = resultSelector;
             }
 
             public override AsyncIterator<TResult> Clone()
             {
-                return new GenerateAsyncIterator<TState, TResult>(initialState, condition, iterate, resultSelector);
+                return new GenerateAsyncIterator<TState, TResult>(_initialState, _condition, _iterate, _resultSelector);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                currentState = default;
+                _currentState = default;
 
                 await base.DisposeAsync().ConfigureAwait(false);
             }
@@ -71,23 +71,23 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        started = false;
-                        currentState = initialState;
+                        _started = false;
+                        _currentState = _initialState;
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (started)
+                        if (_started)
                         {
-                            currentState = iterate(currentState);
+                            _currentState = _iterate(_currentState);
                         }
 
-                        started = true;
+                        _started = true;
 
-                        if (condition(currentState))
+                        if (_condition(_currentState))
                         {
-                            current = resultSelector(currentState);
+                            current = _resultSelector(_currentState);
                             return true;
                         }
                         break;

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/IgnoreElements.cs

@@ -23,27 +23,27 @@ namespace System.Linq
 
         private sealed class IgnoreElementsAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly IAsyncEnumerable<TSource> source;
-            private IAsyncEnumerator<TSource> enumerator;
+            private readonly IAsyncEnumerable<TSource> _source;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public IgnoreElementsAsyncIterator(IAsyncEnumerable<TSource> source)
             {
                 Debug.Assert(source != null);
 
-                this.source = source;
+                _source = source;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new IgnoreElementsAsyncIterator<TSource>(source);
+                return new IgnoreElementsAsyncIterator<TSource>(_source);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -54,12 +54,12 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
                         }
 

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Merge.cs

@@ -37,40 +37,40 @@ namespace System.Linq
 
         private sealed class MergeAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly IAsyncEnumerable<TSource>[] sources;
+            private readonly IAsyncEnumerable<TSource>[] _sources;
 
-            private IAsyncEnumerator<TSource>[] enumerators;
-            private ValueTask<bool>[] moveNexts;
-            private int active;
+            private IAsyncEnumerator<TSource>[] _enumerators;
+            private ValueTask<bool>[] _moveNexts;
+            private int _active;
 
             public MergeAsyncIterator(IAsyncEnumerable<TSource>[] sources)
             {
                 Debug.Assert(sources != null);
 
-                this.sources = sources;
+                _sources = sources;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new MergeAsyncIterator<TSource>(sources);
+                return new MergeAsyncIterator<TSource>(_sources);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerators != null)
+                if (_enumerators != null)
                 {
-                    var n = enumerators.Length;
+                    var n = _enumerators.Length;
 
                     var disposes = new ValueTask[n];
 
                     for (var i = 0; i < n; i++)
                     {
-                        var dispose = enumerators[i].DisposeAsync();
+                        var dispose = _enumerators[i].DisposeAsync();
                         disposes[i] = dispose;
                     }
 
                     await Task.WhenAll(disposes.Select(t => t.AsTask())).ConfigureAwait(false);
-                    enumerators = null;
+                    _enumerators = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -81,24 +81,24 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        var n = sources.Length;
+                        var n = _sources.Length;
 
-                        enumerators = new IAsyncEnumerator<TSource>[n];
-                        moveNexts = new ValueTask<bool>[n];
-                        active = n;
+                        _enumerators = new IAsyncEnumerator<TSource>[n];
+                        _moveNexts = new ValueTask<bool>[n];
+                        _active = n;
 
                         for (var i = 0; i < n; i++)
                         {
-                            var enumerator = sources[i].GetAsyncEnumerator(cancellationToken);
-                            enumerators[i] = enumerator;
-                            moveNexts[i] = enumerator.MoveNextAsync();
+                            var enumerator = _sources[i].GetAsyncEnumerator(cancellationToken);
+                            _enumerators[i] = enumerator;
+                            _moveNexts[i] = enumerator.MoveNextAsync();
                         }
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        while (active > 0)
+                        while (_active > 0)
                         {
                             //
                             // REVIEW: This approach does have a bias towards giving sources on the left
@@ -106,20 +106,20 @@ namespace System.Linq
                             //         want to consider a "prefer fairness" option.
                             //
 
-                            var moveNext = await Task.WhenAny(moveNexts.Select(t => t.AsTask())).ConfigureAwait(false);
+                            var moveNext = await Task.WhenAny(_moveNexts.Select(t => t.AsTask())).ConfigureAwait(false);
 
-                            var index = Array.IndexOf(moveNexts, moveNext);
+                            var index = Array.IndexOf(_moveNexts, moveNext);
 
                             if (!await moveNext.ConfigureAwait(false))
                             {
-                                moveNexts[index] = TaskExt.Never;
-                                active--;
+                                _moveNexts[index] = TaskExt.Never;
+                                _active--;
                             }
                             else
                             {
-                                var enumerator = enumerators[index];
+                                var enumerator = _enumerators[index];
                                 current = enumerator.Current;
-                                moveNexts[index] = enumerator.MoveNextAsync();
+                                _moveNexts[index] = enumerator.MoveNextAsync();
                                 return true;
                             }
                         }

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/OnErrorResumeNext.cs

@@ -44,35 +44,35 @@ namespace System.Linq
 
         private sealed class OnErrorResumeNextAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly IEnumerable<IAsyncEnumerable<TSource>> sources;
+            private readonly IEnumerable<IAsyncEnumerable<TSource>> _sources;
 
-            private IAsyncEnumerator<TSource> enumerator;
-            private IEnumerator<IAsyncEnumerable<TSource>> sourcesEnumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private IEnumerator<IAsyncEnumerable<TSource>> _sourcesEnumerator;
 
             public OnErrorResumeNextAsyncIterator(IEnumerable<IAsyncEnumerable<TSource>> sources)
             {
                 Debug.Assert(sources != null);
 
-                this.sources = sources;
+                _sources = sources;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new OnErrorResumeNextAsyncIterator<TSource>(sources);
+                return new OnErrorResumeNextAsyncIterator<TSource>(_sources);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (sourcesEnumerator != null)
+                if (_sourcesEnumerator != null)
                 {
-                    sourcesEnumerator.Dispose();
-                    sourcesEnumerator = null;
+                    _sourcesEnumerator.Dispose();
+                    _sourcesEnumerator = null;
                 }
 
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -83,7 +83,7 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        sourcesEnumerator = sources.GetEnumerator();
+                        _sourcesEnumerator = _sources.GetEnumerator();
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
@@ -91,21 +91,21 @@ namespace System.Linq
                     case AsyncIteratorState.Iterating:
                         while (true)
                         {
-                            if (enumerator == null)
+                            if (_enumerator == null)
                             {
-                                if (!sourcesEnumerator.MoveNext())
+                                if (!_sourcesEnumerator.MoveNext())
                                 {
                                     break; // while -- done, nothing else to do
                                 }
 
-                                enumerator = sourcesEnumerator.Current.GetAsyncEnumerator(cancellationToken);
+                                _enumerator = _sourcesEnumerator.Current.GetAsyncEnumerator(cancellationToken);
                             }
 
                             try
                             {
-                                if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                                if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                                 {
-                                    current = enumerator.Current;
+                                    current = _enumerator.Current;
                                     return true;
                                 }
                             }
@@ -115,8 +115,8 @@ namespace System.Linq
                             }
 
                             // Done with the current one, go to the next
-                            await enumerator.DisposeAsync().ConfigureAwait(false);
-                            enumerator = null;
+                            await _enumerator.DisposeAsync().ConfigureAwait(false);
+                            _enumerator = null;
                         }
 
                         break; // case

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Scan.cs

@@ -53,35 +53,35 @@ namespace System.Linq
 
         private sealed class ScanAsyncEnumerable<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, TSource, TSource> accumulator;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, TSource, TSource> _accumulator;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private TSource accumulated;
-            private IAsyncEnumerator<TSource> enumerator;
+            private TSource _accumulated;
+            private IAsyncEnumerator<TSource> _enumerator;
 
-            private bool hasSeed;
+            private bool _hasSeed;
 
             public ScanAsyncEnumerable(IAsyncEnumerable<TSource> source, Func<TSource, TSource, TSource> accumulator)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(accumulator != null);
 
-                this.source = source;
-                this.accumulator = accumulator;
+                _source = source;
+                _accumulator = accumulator;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new ScanAsyncEnumerable<TSource>(source, accumulator);
+                return new ScanAsyncEnumerable<TSource>(_source, _accumulator);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
-                    accumulated = default;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
+                    _accumulated = default;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -92,27 +92,27 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        hasSeed = false;
-                        accumulated = default;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _hasSeed = false;
+                        _accumulated = default;
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
 
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var item = enumerator.Current;
-                            if (!hasSeed)
+                            var item = _enumerator.Current;
+                            if (!_hasSeed)
                             {
-                                hasSeed = true;
-                                accumulated = item;
+                                _hasSeed = true;
+                                _accumulated = item;
                                 continue; // loop
                             }
 
-                            accumulated = accumulator(accumulated, item);
-                            current = accumulated;
+                            _accumulated = _accumulator(_accumulated, item);
+                            current = _accumulated;
                             return true;
                         }
 
@@ -127,35 +127,35 @@ namespace System.Linq
 
         private sealed class ScanAsyncEnumerable<TSource, TAccumulate> : AsyncIterator<TAccumulate>
         {
-            private readonly Func<TAccumulate, TSource, TAccumulate> accumulator;
-            private readonly TAccumulate seed;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TAccumulate, TSource, TAccumulate> _accumulator;
+            private readonly TAccumulate _seed;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private TAccumulate accumulated;
-            private IAsyncEnumerator<TSource> enumerator;
+            private TAccumulate _accumulated;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public ScanAsyncEnumerable(IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(accumulator != null);
 
-                this.source = source;
-                this.seed = seed;
-                this.accumulator = accumulator;
+                _source = source;
+                _seed = seed;
+                _accumulator = accumulator;
             }
 
             public override AsyncIterator<TAccumulate> Clone()
             {
-                return new ScanAsyncEnumerable<TSource, TAccumulate>(source, seed, accumulator);
+                return new ScanAsyncEnumerable<TSource, TAccumulate>(_source, _seed, _accumulator);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
-                    accumulated = default;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
+                    _accumulated = default;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -166,18 +166,18 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        accumulated = seed;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _accumulated = _seed;
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var item = enumerator.Current;
-                            accumulated = accumulator(accumulated, item);
-                            current = accumulated;
+                            var item = _enumerator.Current;
+                            _accumulated = _accumulator(_accumulated, item);
+                            current = _accumulated;
                             return true;
                         }
 
@@ -191,35 +191,35 @@ namespace System.Linq
 
         private sealed class ScanAsyncEnumerableWithTask<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, TSource, Task<TSource>> accumulator;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, TSource, Task<TSource>> _accumulator;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private TSource accumulated;
-            private IAsyncEnumerator<TSource> enumerator;
+            private TSource _accumulated;
+            private IAsyncEnumerator<TSource> _enumerator;
 
-            private bool hasSeed;
+            private bool _hasSeed;
 
             public ScanAsyncEnumerableWithTask(IAsyncEnumerable<TSource> source, Func<TSource, TSource, Task<TSource>> accumulator)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(accumulator != null);
 
-                this.source = source;
-                this.accumulator = accumulator;
+                _source = source;
+                _accumulator = accumulator;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new ScanAsyncEnumerableWithTask<TSource>(source, accumulator);
+                return new ScanAsyncEnumerableWithTask<TSource>(_source, _accumulator);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
-                    accumulated = default;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
+                    _accumulated = default;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -230,27 +230,27 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        hasSeed = false;
-                        accumulated = default;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _hasSeed = false;
+                        _accumulated = default;
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
 
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var item = enumerator.Current;
-                            if (!hasSeed)
+                            var item = _enumerator.Current;
+                            if (!_hasSeed)
                             {
-                                hasSeed = true;
-                                accumulated = item;
+                                _hasSeed = true;
+                                _accumulated = item;
                                 continue; // loop
                             }
 
-                            accumulated = await accumulator(accumulated, item).ConfigureAwait(false);
-                            current = accumulated;
+                            _accumulated = await _accumulator(_accumulated, item).ConfigureAwait(false);
+                            current = _accumulated;
                             return true;
                         }
 
@@ -265,35 +265,35 @@ namespace System.Linq
 
         private sealed class ScanAsyncEnumerableWithTask<TSource, TAccumulate> : AsyncIterator<TAccumulate>
         {
-            private readonly Func<TAccumulate, TSource, Task<TAccumulate>> accumulator;
-            private readonly TAccumulate seed;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TAccumulate, TSource, Task<TAccumulate>> _accumulator;
+            private readonly TAccumulate _seed;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private TAccumulate accumulated;
-            private IAsyncEnumerator<TSource> enumerator;
+            private TAccumulate _accumulated;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public ScanAsyncEnumerableWithTask(IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, Task<TAccumulate>> accumulator)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(accumulator != null);
 
-                this.source = source;
-                this.seed = seed;
-                this.accumulator = accumulator;
+                _source = source;
+                _seed = seed;
+                _accumulator = accumulator;
             }
 
             public override AsyncIterator<TAccumulate> Clone()
             {
-                return new ScanAsyncEnumerableWithTask<TSource, TAccumulate>(source, seed, accumulator);
+                return new ScanAsyncEnumerableWithTask<TSource, TAccumulate>(_source, _seed, _accumulator);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
-                    accumulated = default;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
+                    _accumulated = default;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -304,18 +304,18 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        accumulated = seed;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _accumulated = _seed;
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var item = enumerator.Current;
-                            accumulated = await accumulator(accumulated, item).ConfigureAwait(false);
-                            current = accumulated;
+                            var item = _enumerator.Current;
+                            _accumulated = await _accumulator(_accumulated, item).ConfigureAwait(false);
+                            current = _accumulated;
                             return true;
                         }
 

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Timeout.cs

@@ -25,30 +25,30 @@ namespace System.Linq
 
         private sealed class TimeoutAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly IAsyncEnumerable<TSource> source;
-            private readonly TimeSpan timeout;
+            private readonly IAsyncEnumerable<TSource> _source;
+            private readonly TimeSpan _timeout;
 
-            private IAsyncEnumerator<TSource> enumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public TimeoutAsyncIterator(IAsyncEnumerable<TSource> source, TimeSpan timeout)
             {
                 Debug.Assert(source != null);
 
-                this.source = source;
-                this.timeout = timeout;
+                _source = source;
+                _timeout = timeout;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new TimeoutAsyncIterator<TSource>(source, timeout);
+                return new TimeoutAsyncIterator<TSource>(_source, _timeout);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -59,19 +59,19 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        var moveNext = enumerator.MoveNextAsync();
+                        var moveNext = _enumerator.MoveNextAsync();
 
                         if (!moveNext.IsCompleted)
                         {
                             using (var delayCts = new CancellationTokenSource())
                             {
-                                var delay = Task.Delay(timeout, delayCts.Token);
+                                var delay = Task.Delay(_timeout, delayCts.Token);
 
                                 var winner = await Task.WhenAny(moveNext.AsTask(), delay).ConfigureAwait(false);
 
@@ -86,7 +86,7 @@ namespace System.Linq
 
                         if (await moveNext.ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Using.cs

@@ -33,39 +33,39 @@ namespace System.Linq
 
         private sealed class UsingAsyncIterator<TSource, TResource> : AsyncIterator<TSource> where TResource : IDisposable
         {
-            private readonly Func<TResource, IAsyncEnumerable<TSource>> enumerableFactory;
-            private readonly Func<TResource> resourceFactory;
+            private readonly Func<TResource, IAsyncEnumerable<TSource>> _enumerableFactory;
+            private readonly Func<TResource> _resourceFactory;
 
-            private IAsyncEnumerable<TSource> enumerable;
-            private IAsyncEnumerator<TSource> enumerator;
-            private TResource resource;
+            private IAsyncEnumerable<TSource> _enumerable;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private TResource _resource;
 
             public UsingAsyncIterator(Func<TResource> resourceFactory, Func<TResource, IAsyncEnumerable<TSource>> enumerableFactory)
             {
                 Debug.Assert(resourceFactory != null);
                 Debug.Assert(enumerableFactory != null);
 
-                this.resourceFactory = resourceFactory;
-                this.enumerableFactory = enumerableFactory;
+                _resourceFactory = resourceFactory;
+                _enumerableFactory = enumerableFactory;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new UsingAsyncIterator<TSource, TResource>(resourceFactory, enumerableFactory);
+                return new UsingAsyncIterator<TSource, TResource>(_resourceFactory, _enumerableFactory);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
-                if (resource != null)
+                if (_resource != null)
                 {
-                    resource.Dispose();
-                    resource = default;
+                    _resource.Dispose();
+                    _resource = default;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -76,14 +76,14 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = enumerable.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _enumerable.GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 
@@ -98,8 +98,8 @@ namespace System.Linq
             {
                 // REVIEW: Wire cancellation to the functions.
 
-                resource = resourceFactory();
-                enumerable = enumerableFactory(resource);
+                _resource = _resourceFactory();
+                _enumerable = _enumerableFactory(_resource);
 
                 base.OnGetEnumerator(cancellationToken);
             }
@@ -107,39 +107,39 @@ namespace System.Linq
 
         private sealed class UsingAsyncIteratorWithTask<TSource, TResource> : AsyncIterator<TSource> where TResource : IDisposable
         {
-            private readonly Func<TResource, Task<IAsyncEnumerable<TSource>>> enumerableFactory;
-            private readonly Func<Task<TResource>> resourceFactory;
+            private readonly Func<TResource, Task<IAsyncEnumerable<TSource>>> _enumerableFactory;
+            private readonly Func<Task<TResource>> _resourceFactory;
 
-            private IAsyncEnumerable<TSource> enumerable;
-            private IAsyncEnumerator<TSource> enumerator;
-            private TResource resource;
+            private IAsyncEnumerable<TSource> _enumerable;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private TResource _resource;
 
             public UsingAsyncIteratorWithTask(Func<Task<TResource>> resourceFactory, Func<TResource, Task<IAsyncEnumerable<TSource>>> enumerableFactory)
             {
                 Debug.Assert(resourceFactory != null);
                 Debug.Assert(enumerableFactory != null);
 
-                this.resourceFactory = resourceFactory;
-                this.enumerableFactory = enumerableFactory;
+                _resourceFactory = resourceFactory;
+                _enumerableFactory = enumerableFactory;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new UsingAsyncIteratorWithTask<TSource, TResource>(resourceFactory, enumerableFactory);
+                return new UsingAsyncIteratorWithTask<TSource, TResource>(_resourceFactory, _enumerableFactory);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
-                if (resource != null)
+                if (_resource != null)
                 {
-                    resource.Dispose();
-                    resource = default;
+                    _resource.Dispose();
+                    _resource = default;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -150,17 +150,17 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        resource = await resourceFactory().ConfigureAwait(false);
-                        enumerable = await enumerableFactory(resource).ConfigureAwait(false);
+                        _resource = await _resourceFactory().ConfigureAwait(false);
+                        _enumerable = await _enumerableFactory(_resource).ConfigureAwait(false);
 
-                        enumerator = enumerable.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _enumerable.GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 

Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerableHelpers.cs

@@ -14,8 +14,8 @@ namespace System.Collections.Generic
         internal static async Task<T[]> ToArray<T>(IAsyncEnumerable<T> source, CancellationToken cancellationToken)
         {
             var result = await ToArrayWithLength(source, cancellationToken).ConfigureAwait(false);
-            Array.Resize(ref result.array, result.length);
-            return result.array;
+            Array.Resize(ref result.Array, result.Length);
+            return result.Array;
         }
 
         internal static async Task<ArrayWithLength<T>> ToArrayWithLength<T>(IAsyncEnumerable<T> source, CancellationToken cancellationToken)
@@ -34,9 +34,9 @@ namespace System.Collections.Generic
                     // exception from overrunning the array (if the size went up) or we could end up not filling as many 
                     // items as 'count' suggests (if the size went down).  This is only an issue for concurrent collections 
                     // that implement ICollection<T>, which as of .NET 4.6 is just ConcurrentDictionary<TKey, TValue>.
-                    result.array = new T[count];
-                    ic.CopyTo(result.array, 0);
-                    result.length = count;
+                    result.Array = new T[count];
+                    ic.CopyTo(result.Array, 0);
+                    result.Length = count;
                     return result;
                 }
             }
@@ -86,8 +86,8 @@ namespace System.Collections.Generic
                             arr[count++] = en.Current;
                         }
 
-                        result.length = count;
-                        result.array = arr;
+                        result.Length = count;
+                        result.Array = arr;
                         return result;
                     }
                 }
@@ -97,19 +97,19 @@ namespace System.Collections.Generic
                 }
             }
 
-            result.length = 0;
+            result.Length = 0;
 #if NO_ARRAY_EMPTY
-            result.array = EmptyArray<T>.Value;
+            result.Array = EmptyArray<T>.Value;
 #else
-            result.array = Array.Empty<T>();
+            result.Array = Array.Empty<T>();
 #endif
             return result;
         }
 
         internal struct ArrayWithLength<T>
         {
-            public T[] array;
-            public int length;
+            public T[] Array;
+            public int Length;
         }
     }
 }

Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerablePartition.cs

@@ -99,8 +99,8 @@ namespace System.Linq
             }
         }
 
-        private bool hasSkipped;
-        private int taken;
+        private bool _hasSkipped;
+        private int _taken;
 
         protected override async ValueTask<bool> MoveNextCore(CancellationToken cancellationToken)
         {
@@ -108,14 +108,14 @@ namespace System.Linq
             {
                 case AsyncIteratorState.Allocated:
                     _enumerator = _source.GetAsyncEnumerator(cancellationToken);
-                    hasSkipped = false;
-                    taken = 0;
+                    _hasSkipped = false;
+                    _taken = 0;
 
                     state = AsyncIteratorState.Iterating;
                     goto case AsyncIteratorState.Iterating;
 
                 case AsyncIteratorState.Iterating:
-                    if (!hasSkipped)
+                    if (!_hasSkipped)
                     {
                         if (!await SkipBeforeFirstAsync(_enumerator, CancellationToken.None).ConfigureAwait(false))
                         {
@@ -123,17 +123,17 @@ namespace System.Linq
                             break;
                         }
 
-                        hasSkipped = true;
+                        _hasSkipped = true;
                     }
 
-                    if ((!HasLimit || taken < Limit) && await _enumerator.MoveNextAsync().ConfigureAwait(false))
+                    if ((!HasLimit || _taken < Limit) && await _enumerator.MoveNextAsync().ConfigureAwait(false))
                     {
                         if (HasLimit)
                         {
                             // If we are taking an unknown number of elements, it's important not to increment _state.
                             // _state - 3 may eventually end up overflowing & we'll hit the Dispose branch even though
                             // we haven't finished enumerating.
-                            taken++;
+                            _taken++;
                         }
 
                         current = _enumerator.Current;

Ix.NET/Source/System.Linq.Async/System/Linq/Disposables.cs

@@ -8,15 +8,15 @@ namespace System.Linq
 {
     internal sealed class CancellationTokenDisposable : IDisposable
     {
-        private readonly CancellationTokenSource cts = new CancellationTokenSource();
+        private readonly CancellationTokenSource _cts = new CancellationTokenSource();
 
-        public CancellationToken Token => cts.Token;
+        public CancellationToken Token => _cts.Token;
 
         public void Dispose()
         {
-            if (!cts.IsCancellationRequested)
+            if (!_cts.IsCancellationRequested)
             {
-                cts.Cancel();
+                _cts.Cancel();
             }
         }
     }

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Concat.cs

@@ -63,8 +63,8 @@ namespace System.Linq
 
         private abstract class ConcatAsyncIterator<TSource> : AsyncIterator<TSource>, IAsyncIListProvider<TSource>
         {
-            private int counter;
-            private IAsyncEnumerator<TSource> enumerator;
+            private int _counter;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
             {
@@ -127,10 +127,10 @@ namespace System.Linq
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -140,27 +140,27 @@ namespace System.Linq
             {
                 if (state == AsyncIteratorState.Allocated)
                 {
-                    enumerator = GetAsyncEnumerable(0).GetAsyncEnumerator(cancellationToken);
+                    _enumerator = GetAsyncEnumerable(0).GetAsyncEnumerator(cancellationToken);
                     state = AsyncIteratorState.Iterating;
-                    counter = 2;
+                    _counter = 2;
                 }
 
                 if (state == AsyncIteratorState.Iterating)
                 {
                     while (true)
                     {
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
                         // note, this is simply to match the logic of 
                         // https://github.com/dotnet/corefx/blob/ec2685715b01d12f16b08d0dfa326649b12db8ec/src/system.linq/src/system/linq/concatenate.cs#L173-L173
-                        var next = GetAsyncEnumerable(counter++ - 1);
+                        var next = GetAsyncEnumerable(_counter++ - 1);
                         if (next != null)
                         {
-                            await enumerator.DisposeAsync().ConfigureAwait(false);
-                            enumerator = next.GetAsyncEnumerator(cancellationToken);
+                            await _enumerator.DisposeAsync().ConfigureAwait(false);
+                            _enumerator = next.GetAsyncEnumerator(cancellationToken);
                             continue;
                         }
 
@@ -185,9 +185,9 @@ namespace System.Linq
         // a much better memory profile and without much additional run-time cost.
         private sealed class ConcatNAsyncIterator<TSource> : ConcatAsyncIterator<TSource>
         {
-            private readonly IAsyncEnumerable<TSource> next;
-            private readonly int nextIndex;
-            private readonly ConcatAsyncIterator<TSource> previousConcat;
+            private readonly IAsyncEnumerable<TSource> _next;
+            private readonly int _nextIndex;
+            private readonly ConcatAsyncIterator<TSource> _previousConcat;
 
             internal ConcatNAsyncIterator(ConcatAsyncIterator<TSource> previousConcat, IAsyncEnumerable<TSource> next, int nextIndex)
             {
@@ -195,19 +195,19 @@ namespace System.Linq
                 Debug.Assert(next != null);
                 Debug.Assert(nextIndex >= 2);
 
-                this.previousConcat = previousConcat;
-                this.next = next;
-                this.nextIndex = nextIndex;
+                _previousConcat = previousConcat;
+                _next = next;
+                _nextIndex = nextIndex;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new ConcatNAsyncIterator<TSource>(previousConcat, next, nextIndex);
+                return new ConcatNAsyncIterator<TSource>(_previousConcat, _next, _nextIndex);
             }
 
             internal override ConcatAsyncIterator<TSource> Concat(IAsyncEnumerable<TSource> next)
             {
-                if (nextIndex == int.MaxValue - 2)
+                if (_nextIndex == int.MaxValue - 2)
                 {
                     // In the unlikely case of this many concatenations, if we produced a ConcatNIterator
                     // with int.MaxValue then state would overflow before it matched it's index.
@@ -215,12 +215,12 @@ namespace System.Linq
                     return new Concat2AsyncIterator<TSource>(this, next);
                 }
 
-                return new ConcatNAsyncIterator<TSource>(this, next, nextIndex + 1);
+                return new ConcatNAsyncIterator<TSource>(this, next, _nextIndex + 1);
             }
 
             internal override IAsyncEnumerable<TSource> GetAsyncEnumerable(int index)
             {
-                if (index > nextIndex)
+                if (index > _nextIndex)
                 {
                     return null;
                 }
@@ -232,20 +232,20 @@ namespace System.Linq
                 var current = this;
                 while (true)
                 {
-                    if (index == current.nextIndex)
+                    if (index == current._nextIndex)
                     {
-                        return current.next;
+                        return current._next;
                     }
 
-                    if (current.previousConcat is ConcatNAsyncIterator<TSource> prevN)
+                    if (current._previousConcat is ConcatNAsyncIterator<TSource> prevN)
                     {
                         current = prevN;
                         continue;
                     }
 
-                    Debug.Assert(current.previousConcat is Concat2AsyncIterator<TSource>);
+                    Debug.Assert(current._previousConcat is Concat2AsyncIterator<TSource>);
                     Debug.Assert(index == 0 || index == 1);
-                    return current.previousConcat.GetAsyncEnumerable(index);
+                    return current._previousConcat.GetAsyncEnumerable(index);
                 }
             }
         }

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Create.cs

@@ -55,93 +55,93 @@ namespace System.Linq
 
         private sealed class AnonymousAsyncEnumerable<T> : IAsyncEnumerable<T>
         {
-            private readonly Func<CancellationToken, IAsyncEnumerator<T>> getEnumerator;
+            private readonly Func<CancellationToken, IAsyncEnumerator<T>> _getEnumerator;
 
             public AnonymousAsyncEnumerable(Func<CancellationToken, IAsyncEnumerator<T>> getEnumerator)
             {
                 Debug.Assert(getEnumerator != null);
 
-                this.getEnumerator = getEnumerator;
+                _getEnumerator = getEnumerator;
             }
 
-            public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken) => getEnumerator(cancellationToken);
+            public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken) => _getEnumerator(cancellationToken);
         }
 
         private sealed class AnonymousAsyncEnumerableWithTask<T> : IAsyncEnumerable<T>
         {
-            private readonly Func<CancellationToken, Task<IAsyncEnumerator<T>>> getEnumerator;
+            private readonly Func<CancellationToken, Task<IAsyncEnumerator<T>>> _getEnumerator;
 
             public AnonymousAsyncEnumerableWithTask(Func<CancellationToken, Task<IAsyncEnumerator<T>>> getEnumerator)
             {
                 Debug.Assert(getEnumerator != null);
 
-                this.getEnumerator = getEnumerator;
+                _getEnumerator = getEnumerator;
             }
 
-            public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken) => new Enumerator(getEnumerator, cancellationToken);
+            public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken) => new Enumerator(_getEnumerator, cancellationToken);
 
             private sealed class Enumerator : IAsyncEnumerator<T>
             {
-                private Func<CancellationToken, Task<IAsyncEnumerator<T>>> getEnumerator;
-                private readonly CancellationToken cancellationToken;
-                private IAsyncEnumerator<T> enumerator;
+                private Func<CancellationToken, Task<IAsyncEnumerator<T>>> _getEnumerator;
+                private readonly CancellationToken _cancellationToken;
+                private IAsyncEnumerator<T> _enumerator;
 
                 public Enumerator(Func<CancellationToken, Task<IAsyncEnumerator<T>>> getEnumerator, CancellationToken cancellationToken)
                 {
                     Debug.Assert(getEnumerator != null);
 
-                    this.getEnumerator = getEnumerator;
-                    this.cancellationToken = cancellationToken;
+                    _getEnumerator = getEnumerator;
+                    _cancellationToken = cancellationToken;
                 }
 
                 public T Current
                 {
                     get
                     {
-                        if (enumerator == null)
+                        if (_enumerator == null)
                             throw new InvalidOperationException();
 
-                        return enumerator.Current;
+                        return _enumerator.Current;
                     }
                 }
 
                 public async ValueTask DisposeAsync()
                 {
-                    var old = Interlocked.Exchange(ref enumerator, DisposedEnumerator.Instance);
+                    var old = Interlocked.Exchange(ref _enumerator, DisposedEnumerator.Instance);
 
-                    if (enumerator != null)
+                    if (_enumerator != null)
                     {
-                        await enumerator.DisposeAsync().ConfigureAwait(false);
+                        await _enumerator.DisposeAsync().ConfigureAwait(false);
                     }
                 }
 
                 public ValueTask<bool> MoveNextAsync()
                 {
-                    if (enumerator == null)
+                    if (_enumerator == null)
                     {
                         return InitAndMoveNextAsync();
                     }
 
-                    return enumerator.MoveNextAsync();
+                    return _enumerator.MoveNextAsync();
                 }
 
                 private async ValueTask<bool> InitAndMoveNextAsync()
                 {
                     try
                     {
-                        enumerator = await getEnumerator(cancellationToken).ConfigureAwait(false);
+                        _enumerator = await _getEnumerator(_cancellationToken).ConfigureAwait(false);
                     }
                     catch (Exception ex)
                     {
-                        enumerator = Throw<T>(ex).GetAsyncEnumerator(cancellationToken);
+                        _enumerator = Throw<T>(ex).GetAsyncEnumerator(_cancellationToken);
                         throw;
                     }
                     finally
                     {
-                        getEnumerator = null;
+                        _getEnumerator = null;
                     }
 
-                    return await enumerator.MoveNextAsync().ConfigureAwait(false);
+                    return await _enumerator.MoveNextAsync().ConfigureAwait(false);
                 }
 
                 private sealed class DisposedEnumerator : IAsyncEnumerator<T>

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/DefaultIfEmpty.cs

@@ -34,30 +34,30 @@ namespace System.Linq
 
         private sealed class DefaultIfEmptyAsyncIterator<TSource> : AsyncIterator<TSource>, IAsyncIListProvider<TSource>
         {
-            private readonly IAsyncEnumerable<TSource> source;
-            private readonly TSource defaultValue;
+            private readonly IAsyncEnumerable<TSource> _source;
+            private readonly TSource _defaultValue;
 
-            private IAsyncEnumerator<TSource> enumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public DefaultIfEmptyAsyncIterator(IAsyncEnumerable<TSource> source, TSource defaultValue)
             {
                 Debug.Assert(source != null);
 
-                this.source = source;
-                this.defaultValue = defaultValue;
+                _source = source;
+                _defaultValue = defaultValue;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new DefaultIfEmptyAsyncIterator<TSource>(source, defaultValue);
+                return new DefaultIfEmptyAsyncIterator<TSource>(_source, _defaultValue);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -68,26 +68,26 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             state = AsyncIteratorState.Iterating;
                         }
                         else
                         {
-                            current = defaultValue;
-                            await enumerator.DisposeAsync().ConfigureAwait(false);
-                            enumerator = null;
+                            current = _defaultValue;
+                            await _enumerator.DisposeAsync().ConfigureAwait(false);
+                            _enumerator = null;
 
                             state = AsyncIteratorState.Disposed;
                         }
                         return true;
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
                         break;
@@ -99,16 +99,16 @@ namespace System.Linq
 
             public async Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
             {
-                var array = await source.ToArray(cancellationToken).ConfigureAwait(false);
-                return array.Length == 0 ? new[] { defaultValue } : array;
+                var array = await _source.ToArray(cancellationToken).ConfigureAwait(false);
+                return array.Length == 0 ? new[] { _defaultValue } : array;
             }
 
             public async Task<List<TSource>> ToListAsync(CancellationToken cancellationToken)
             {
-                var list = await source.ToList(cancellationToken).ConfigureAwait(false);
+                var list = await _source.ToList(cancellationToken).ConfigureAwait(false);
                 if (list.Count == 0)
                 {
-                    list.Add(defaultValue);
+                    list.Add(_defaultValue);
                 }
 
                 return list;
@@ -117,13 +117,13 @@ namespace System.Linq
             public async Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 int count;
-                if (!onlyIfCheap || source is ICollection<TSource> || source is ICollection)
+                if (!onlyIfCheap || _source is ICollection<TSource> || _source is ICollection)
                 {
-                    count = await source.Count(cancellationToken).ConfigureAwait(false);
+                    count = await _source.Count(cancellationToken).ConfigureAwait(false);
                 }
                 else
                 {
-                    var listProv = source as IAsyncIListProvider<TSource>;
+                    var listProv = _source as IAsyncIListProvider<TSource>;
                     count = listProv == null ? -1 : await listProv.GetCountAsync(onlyIfCheap: true, cancellationToken: cancellationToken).ConfigureAwait(false);
                 }
 

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Distinct.cs

@@ -31,18 +31,18 @@ namespace System.Linq
 
         private sealed class DistinctAsyncIterator<TSource> : AsyncIterator<TSource>, IAsyncIListProvider<TSource>
         {
-            private readonly IEqualityComparer<TSource> comparer;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly IEqualityComparer<TSource> _comparer;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
-            private Set<TSource> set;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private Set<TSource> _set;
 
             public DistinctAsyncIterator(IAsyncEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
             {
                 Debug.Assert(source != null);
 
-                this.source = source;
-                this.comparer = comparer;
+                _source = source;
+                _comparer = comparer;
             }
 
             public async Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
@@ -64,16 +64,16 @@ namespace System.Linq
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new DistinctAsyncIterator<TSource>(source, comparer);
+                return new DistinctAsyncIterator<TSource>(_source, _comparer);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
-                    set = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
+                    _set = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -84,26 +84,26 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        if (!await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        if (!await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
                             await DisposeAsync().ConfigureAwait(false);
                             return false;
                         }
 
-                        var element = enumerator.Current;
-                        set = new Set<TSource>(comparer);
-                        set.Add(element);
+                        var element = _enumerator.Current;
+                        _set = new Set<TSource>(_comparer);
+                        _set.Add(element);
                         current = element;
 
                         state = AsyncIteratorState.Iterating;
                         return true;
 
                     case AsyncIteratorState.Iterating:
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            element = enumerator.Current;
-                            if (set.Add(element))
+                            element = _enumerator.Current;
+                            if (_set.Add(element))
                             {
                                 current = element;
                                 return true;
@@ -119,9 +119,9 @@ namespace System.Linq
 
             private async Task<Set<TSource>> FillSetAsync(CancellationToken cancellationToken)
             {
-                var s = new Set<TSource>(comparer);
+                var s = new Set<TSource>(_comparer);
 
-                await s.UnionWithAsync(source, cancellationToken);
+                await s.UnionWithAsync(_source, cancellationToken);
 
                 return s;
             }

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Except.cs

@@ -35,16 +35,16 @@ namespace System.Linq
 
         private sealed class ExceptAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly IEqualityComparer<TSource> comparer;
-            private readonly IAsyncEnumerable<TSource> first;
-            private readonly IAsyncEnumerable<TSource> second;
+            private readonly IEqualityComparer<TSource> _comparer;
+            private readonly IAsyncEnumerable<TSource> _first;
+            private readonly IAsyncEnumerable<TSource> _second;
 
-            private Task fillSetTask;
+            private Task _fillSetTask;
 
-            private IAsyncEnumerator<TSource> firstEnumerator;
-            private Set<TSource> set;
+            private IAsyncEnumerator<TSource> _firstEnumerator;
+            private Set<TSource> _set;
 
-            private bool setFilled;
+            private bool _setFilled;
 
             public ExceptAsyncIterator(IAsyncEnumerable<TSource> first, IAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
             {
@@ -52,25 +52,25 @@ namespace System.Linq
                 Debug.Assert(second != null);
                 Debug.Assert(comparer != null);
 
-                this.first = first;
-                this.second = second;
-                this.comparer = comparer;
+                _first = first;
+                _second = second;
+                _comparer = comparer;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new ExceptAsyncIterator<TSource>(first, second, comparer);
+                return new ExceptAsyncIterator<TSource>(_first, _second, _comparer);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (firstEnumerator != null)
+                if (_firstEnumerator != null)
                 {
-                    await firstEnumerator.DisposeAsync().ConfigureAwait(false);
-                    firstEnumerator = null;
+                    await _firstEnumerator.DisposeAsync().ConfigureAwait(false);
+                    _firstEnumerator = null;
                 }
 
-                set = null;
+                _set = null;
 
                 await base.DisposeAsync().ConfigureAwait(false);
             }
@@ -80,10 +80,10 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        firstEnumerator = first.GetAsyncEnumerator(cancellationToken);
-                        set = new Set<TSource>(comparer);
-                        setFilled = false;
-                        fillSetTask = FillSetAsync();
+                        _firstEnumerator = _first.GetAsyncEnumerator(cancellationToken);
+                        _set = new Set<TSource>(_comparer);
+                        _setFilled = false;
+                        _fillSetTask = FillSetAsync();
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
@@ -92,24 +92,24 @@ namespace System.Linq
                         bool moveNext;
                         do
                         {
-                            if (!setFilled)
+                            if (!_setFilled)
                             {
                                 // This is here so we don't need to call Task.WhenAll each time after the set is filled
-                                var moveNextTask = firstEnumerator.MoveNextAsync();
-                                await Task.WhenAll(moveNextTask.AsTask(), fillSetTask).ConfigureAwait(false);
+                                var moveNextTask = _firstEnumerator.MoveNextAsync();
+                                await Task.WhenAll(moveNextTask.AsTask(), _fillSetTask).ConfigureAwait(false);
 
-                                setFilled = true;
+                                _setFilled = true;
                                 moveNext = moveNextTask.Result;
                             }
                             else
                             {
-                                moveNext = await firstEnumerator.MoveNextAsync().ConfigureAwait(false);
+                                moveNext = await _firstEnumerator.MoveNextAsync().ConfigureAwait(false);
                             }
 
                             if (moveNext)
                             {
-                                var item = firstEnumerator.Current;
-                                if (set.Add(item))
+                                var item = _firstEnumerator.Current;
+                                if (_set.Add(item))
                                 {
                                     current = item;
                                     return true;
@@ -126,11 +126,11 @@ namespace System.Linq
 
             private async Task FillSetAsync()
             {
-                var array = await second.ToArray().ConfigureAwait(false);
+                var array = await _second.ToArray().ConfigureAwait(false);
 
                 foreach (var t in array)
                 {
-                    set.Add(t);
+                    _set.Add(t);
                 }
             }
         }

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupBy.cs

@@ -221,13 +221,13 @@ namespace System.Linq
 
         internal sealed class GroupedResultAsyncEnumerable<TSource, TKey, TResult> : AsyncIterator<TResult>, IAsyncIListProvider<TResult>
         {
-            private readonly IAsyncEnumerable<TSource> source;
-            private readonly Func<TSource, TKey> keySelector;
-            private readonly Func<TKey, IAsyncEnumerable<TSource>, TResult> resultSelector;
-            private readonly IEqualityComparer<TKey> comparer;
+            private readonly IAsyncEnumerable<TSource> _source;
+            private readonly Func<TSource, TKey> _keySelector;
+            private readonly Func<TKey, IAsyncEnumerable<TSource>, TResult> _resultSelector;
+            private readonly IEqualityComparer<TKey> _comparer;
 
-            private Internal.Lookup<TKey, TSource> lookup;
-            private IEnumerator<TResult> enumerator;
+            private Internal.Lookup<TKey, TSource> _lookup;
+            private IEnumerator<TResult> _enumerator;
 
             public GroupedResultAsyncEnumerable(IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IAsyncEnumerable<TSource>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
             {
@@ -236,24 +236,24 @@ namespace System.Linq
                 Debug.Assert(resultSelector != null);
                 Debug.Assert(comparer != null);
 
-                this.source = source;
-                this.keySelector = keySelector;
-                this.resultSelector = resultSelector;
-                this.comparer = comparer;
+                _source = source;
+                _keySelector = keySelector;
+                _resultSelector = resultSelector;
+                _comparer = comparer;
             }
 
             public override AsyncIterator<TResult> Clone()
             {
-                return new GroupedResultAsyncEnumerable<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer);
+                return new GroupedResultAsyncEnumerable<TSource, TKey, TResult>(_source, _keySelector, _resultSelector, _comparer);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    enumerator.Dispose();
-                    enumerator = null;
-                    lookup = null;
+                    _enumerator.Dispose();
+                    _enumerator = null;
+                    _lookup = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -264,15 +264,15 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        lookup = await Internal.Lookup<TKey, TSource>.CreateAsync(source, keySelector, comparer).ConfigureAwait(false);
-                        enumerator = lookup.ApplyResultSelector(resultSelector).GetEnumerator();
+                        _lookup = await Internal.Lookup<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer).ConfigureAwait(false);
+                        _enumerator = _lookup.ApplyResultSelector(_resultSelector).GetEnumerator();
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (enumerator.MoveNext())
+                        if (_enumerator.MoveNext())
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 
@@ -285,14 +285,14 @@ namespace System.Linq
 
             public async Task<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
             {
-                var l = await Internal.Lookup<TKey, TSource>.CreateAsync(source, keySelector, comparer, cancellationToken).ConfigureAwait(false);
-                return l.ToArray(resultSelector);
+                var l = await Internal.Lookup<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
+                return l.ToArray(_resultSelector);
             }
 
             public async Task<List<TResult>> ToListAsync(CancellationToken cancellationToken)
             {
-                var l = await Internal.Lookup<TKey, TSource>.CreateAsync(source, keySelector, comparer, cancellationToken).ConfigureAwait(false);
-                return l.ToList(resultSelector);
+                var l = await Internal.Lookup<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
+                return l.ToList(_resultSelector);
             }
 
             public async Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
@@ -302,7 +302,7 @@ namespace System.Linq
                     return -1;
                 }
 
-                var l = await Internal.Lookup<TKey, TSource>.CreateAsync(source, keySelector, comparer, cancellationToken).ConfigureAwait(false);
+                var l = await Internal.Lookup<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
 
                 return l.Count;
             }
@@ -310,13 +310,13 @@ namespace System.Linq
 
         internal sealed class GroupedResultAsyncEnumerableWithTask<TSource, TKey, TResult> : AsyncIterator<TResult>, IAsyncIListProvider<TResult>
         {
-            private readonly IAsyncEnumerable<TSource> source;
-            private readonly Func<TSource, Task<TKey>> keySelector;
-            private readonly Func<TKey, IAsyncEnumerable<TSource>, Task<TResult>> resultSelector;
-            private readonly IEqualityComparer<TKey> comparer;
+            private readonly IAsyncEnumerable<TSource> _source;
+            private readonly Func<TSource, Task<TKey>> _keySelector;
+            private readonly Func<TKey, IAsyncEnumerable<TSource>, Task<TResult>> _resultSelector;
+            private readonly IEqualityComparer<TKey> _comparer;
 
-            private Internal.LookupWithTask<TKey, TSource> lookup;
-            private IAsyncEnumerator<TResult> enumerator;
+            private Internal.LookupWithTask<TKey, TSource> _lookup;
+            private IAsyncEnumerator<TResult> _enumerator;
 
             public GroupedResultAsyncEnumerableWithTask(IAsyncEnumerable<TSource> source, Func<TSource, Task<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, Task<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
             {
@@ -325,24 +325,24 @@ namespace System.Linq
                 Debug.Assert(resultSelector != null);
                 Debug.Assert(comparer != null);
 
-                this.source = source;
-                this.keySelector = keySelector;
-                this.resultSelector = resultSelector;
-                this.comparer = comparer;
+                _source = source;
+                _keySelector = keySelector;
+                _resultSelector = resultSelector;
+                _comparer = comparer;
             }
 
             public override AsyncIterator<TResult> Clone()
             {
-                return new GroupedResultAsyncEnumerableWithTask<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer);
+                return new GroupedResultAsyncEnumerableWithTask<TSource, TKey, TResult>(_source, _keySelector, _resultSelector, _comparer);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
-                    lookup = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
+                    _lookup = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -353,15 +353,15 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        lookup = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(source, keySelector, comparer).ConfigureAwait(false);
-                        enumerator = lookup.Select(async g => await resultSelector(g.Key, g).ConfigureAwait(false)).GetAsyncEnumerator(cancellationToken);
+                        _lookup = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer).ConfigureAwait(false);
+                        _enumerator = _lookup.Select(async g => await _resultSelector(g.Key, g).ConfigureAwait(false)).GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 
@@ -374,14 +374,14 @@ namespace System.Linq
 
             public async Task<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
             {
-                var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(source, keySelector, comparer, cancellationToken).ConfigureAwait(false);
-                return await l.ToArray(resultSelector).ConfigureAwait(false);
+                var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
+                return await l.ToArray(_resultSelector).ConfigureAwait(false);
             }
 
             public async Task<List<TResult>> ToListAsync(CancellationToken cancellationToken)
             {
-                var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(source, keySelector, comparer, cancellationToken).ConfigureAwait(false);
-                return await l.ToList(resultSelector).ConfigureAwait(false);
+                var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
+                return await l.ToList(_resultSelector).ConfigureAwait(false);
             }
 
             public async Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
@@ -391,7 +391,7 @@ namespace System.Linq
                     return -1;
                 }
 
-                var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(source, keySelector, comparer, cancellationToken).ConfigureAwait(false);
+                var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
 
                 return l.Count;
             }
@@ -399,13 +399,13 @@ namespace System.Linq
 
         internal sealed class GroupedAsyncEnumerable<TSource, TKey, TElement> : AsyncIterator<IAsyncGrouping<TKey, TElement>>, IAsyncIListProvider<IAsyncGrouping<TKey, TElement>>
         {
-            private readonly IAsyncEnumerable<TSource> source;
-            private readonly Func<TSource, TKey> keySelector;
-            private readonly Func<TSource, TElement> elementSelector;
-            private readonly IEqualityComparer<TKey> comparer;
+            private readonly IAsyncEnumerable<TSource> _source;
+            private readonly Func<TSource, TKey> _keySelector;
+            private readonly Func<TSource, TElement> _elementSelector;
+            private readonly IEqualityComparer<TKey> _comparer;
 
-            private Internal.Lookup<TKey, TElement> lookup;
-            private IEnumerator<IGrouping<TKey, TElement>> enumerator;
+            private Internal.Lookup<TKey, TElement> _lookup;
+            private IEnumerator<IGrouping<TKey, TElement>> _enumerator;
 
             public GroupedAsyncEnumerable(IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
             {
@@ -414,24 +414,24 @@ namespace System.Linq
                 Debug.Assert(elementSelector != null);
                 Debug.Assert(comparer != null);
 
-                this.source = source;
-                this.keySelector = keySelector;
-                this.elementSelector = elementSelector;
-                this.comparer = comparer;
+                _source = source;
+                _keySelector = keySelector;
+                _elementSelector = elementSelector;
+                _comparer = comparer;
             }
 
             public override AsyncIterator<IAsyncGrouping<TKey, TElement>> Clone()
             {
-                return new GroupedAsyncEnumerable<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
+                return new GroupedAsyncEnumerable<TSource, TKey, TElement>(_source, _keySelector, _elementSelector, _comparer);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    enumerator.Dispose();
-                    enumerator = null;
-                    lookup = null;
+                    _enumerator.Dispose();
+                    _enumerator = null;
+                    _lookup = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -442,15 +442,15 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        lookup = await Internal.Lookup<TKey, TElement>.CreateAsync(source, keySelector, elementSelector, comparer).ConfigureAwait(false);
-                        enumerator = lookup.GetEnumerator();
+                        _lookup = await Internal.Lookup<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer).ConfigureAwait(false);
+                        _enumerator = _lookup.GetEnumerator();
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (enumerator.MoveNext())
+                        if (_enumerator.MoveNext())
                         {
-                            current = (IAsyncGrouping<TKey, TElement>)enumerator.Current;
+                            current = (IAsyncGrouping<TKey, TElement>)_enumerator.Current;
                             return true;
                         }
 
@@ -463,13 +463,13 @@ namespace System.Linq
             
             public async Task<IAsyncGrouping<TKey, TElement>[]> ToArrayAsync(CancellationToken cancellationToken)
             {
-                IAsyncIListProvider<IAsyncGrouping<TKey, TElement>> l = await Internal.Lookup<TKey, TElement>.CreateAsync(source, keySelector, elementSelector, comparer, cancellationToken).ConfigureAwait(false);
+                IAsyncIListProvider<IAsyncGrouping<TKey, TElement>> l = await Internal.Lookup<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToArrayAsync(cancellationToken).ConfigureAwait(false);
             }
 
             public async Task<List<IAsyncGrouping<TKey, TElement>>> ToListAsync(CancellationToken cancellationToken)
             {
-                IAsyncIListProvider<IAsyncGrouping<TKey, TElement>> l = await Internal.Lookup<TKey, TElement>.CreateAsync(source, keySelector, elementSelector, comparer, cancellationToken).ConfigureAwait(false);
+                IAsyncIListProvider<IAsyncGrouping<TKey, TElement>> l = await Internal.Lookup<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToListAsync(cancellationToken).ConfigureAwait(false);
             }
 
@@ -480,7 +480,7 @@ namespace System.Linq
                     return -1;
                 }
 
-                var l = await Internal.Lookup<TKey, TElement>.CreateAsync(source, keySelector, elementSelector, comparer, cancellationToken).ConfigureAwait(false);
+                var l = await Internal.Lookup<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
 
                 return l.Count;
             }
@@ -488,13 +488,13 @@ namespace System.Linq
 
         internal sealed class GroupedAsyncEnumerableWithTask<TSource, TKey, TElement> : AsyncIterator<IAsyncGrouping<TKey, TElement>>, IAsyncIListProvider<IAsyncGrouping<TKey, TElement>>
         {
-            private readonly IAsyncEnumerable<TSource> source;
-            private readonly Func<TSource, Task<TKey>> keySelector;
-            private readonly Func<TSource, Task<TElement>> elementSelector;
-            private readonly IEqualityComparer<TKey> comparer;
+            private readonly IAsyncEnumerable<TSource> _source;
+            private readonly Func<TSource, Task<TKey>> _keySelector;
+            private readonly Func<TSource, Task<TElement>> _elementSelector;
+            private readonly IEqualityComparer<TKey> _comparer;
 
-            private Internal.LookupWithTask<TKey, TElement> lookup;
-            private IEnumerator<IGrouping<TKey, TElement>> enumerator;
+            private Internal.LookupWithTask<TKey, TElement> _lookup;
+            private IEnumerator<IGrouping<TKey, TElement>> _enumerator;
 
             public GroupedAsyncEnumerableWithTask(IAsyncEnumerable<TSource> source, Func<TSource, Task<TKey>> keySelector, Func<TSource, Task<TElement>> elementSelector, IEqualityComparer<TKey> comparer)
             {
@@ -503,24 +503,24 @@ namespace System.Linq
                 Debug.Assert(elementSelector != null);
                 Debug.Assert(comparer != null);
 
-                this.source = source;
-                this.keySelector = keySelector;
-                this.elementSelector = elementSelector;
-                this.comparer = comparer;
+                _source = source;
+                _keySelector = keySelector;
+                _elementSelector = elementSelector;
+                _comparer = comparer;
             }
 
             public override AsyncIterator<IAsyncGrouping<TKey, TElement>> Clone()
             {
-                return new GroupedAsyncEnumerableWithTask<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
+                return new GroupedAsyncEnumerableWithTask<TSource, TKey, TElement>(_source, _keySelector, _elementSelector, _comparer);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    enumerator.Dispose();
-                    enumerator = null;
-                    lookup = null;
+                    _enumerator.Dispose();
+                    _enumerator = null;
+                    _lookup = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -531,15 +531,15 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        lookup = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(source, keySelector, elementSelector, comparer).ConfigureAwait(false);
-                        enumerator = lookup.GetEnumerator();
+                        _lookup = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer).ConfigureAwait(false);
+                        _enumerator = _lookup.GetEnumerator();
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (enumerator.MoveNext())
+                        if (_enumerator.MoveNext())
                         {
-                            current = (IAsyncGrouping<TKey, TElement>)enumerator.Current;
+                            current = (IAsyncGrouping<TKey, TElement>)_enumerator.Current;
                             return true;
                         }
 
@@ -552,13 +552,13 @@ namespace System.Linq
 
             public async Task<IAsyncGrouping<TKey, TElement>[]> ToArrayAsync(CancellationToken cancellationToken)
             {
-                IAsyncIListProvider<IAsyncGrouping<TKey, TElement>> l = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(source, keySelector, elementSelector, comparer, cancellationToken).ConfigureAwait(false);
+                IAsyncIListProvider<IAsyncGrouping<TKey, TElement>> l = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToArrayAsync(cancellationToken).ConfigureAwait(false);
             }
 
             public async Task<List<IAsyncGrouping<TKey, TElement>>> ToListAsync(CancellationToken cancellationToken)
             {
-                IAsyncIListProvider<IAsyncGrouping<TKey, TElement>> l = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(source, keySelector, elementSelector, comparer, cancellationToken).ConfigureAwait(false);
+                IAsyncIListProvider<IAsyncGrouping<TKey, TElement>> l = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToListAsync(cancellationToken).ConfigureAwait(false);
             }
 
@@ -569,7 +569,7 @@ namespace System.Linq
                     return -1;
                 }
 
-                var l = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(source, keySelector, elementSelector, comparer, cancellationToken).ConfigureAwait(false);
+                var l = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
 
                 return l.Count;
             }
@@ -577,12 +577,12 @@ namespace System.Linq
 
         internal sealed class GroupedAsyncEnumerable<TSource, TKey> : AsyncIterator<IAsyncGrouping<TKey, TSource>>, IAsyncIListProvider<IAsyncGrouping<TKey, TSource>>
         {
-            private readonly IAsyncEnumerable<TSource> source;
-            private readonly Func<TSource, TKey> keySelector;
-            private readonly IEqualityComparer<TKey> comparer;
+            private readonly IAsyncEnumerable<TSource> _source;
+            private readonly Func<TSource, TKey> _keySelector;
+            private readonly IEqualityComparer<TKey> _comparer;
 
-            private Internal.Lookup<TKey, TSource> lookup;
-            private IEnumerator<IGrouping<TKey, TSource>> enumerator;
+            private Internal.Lookup<TKey, TSource> _lookup;
+            private IEnumerator<IGrouping<TKey, TSource>> _enumerator;
 
             public GroupedAsyncEnumerable(IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
             {
@@ -590,22 +590,22 @@ namespace System.Linq
                 Debug.Assert(keySelector != null);
                 Debug.Assert(comparer != null);
 
-                this.source = source;
-                this.keySelector = keySelector;
-                this.comparer = comparer;
+                _source = source;
+                _keySelector = keySelector;
+                _comparer = comparer;
             }
 
             public override AsyncIterator<IAsyncGrouping<TKey, TSource>> Clone()
             {
-                return new GroupedAsyncEnumerable<TSource, TKey>(source, keySelector, comparer);
+                return new GroupedAsyncEnumerable<TSource, TKey>(_source, _keySelector, _comparer);
             }
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    enumerator.Dispose();
-                    enumerator = null;
-                    lookup = null;
+                    _enumerator.Dispose();
+                    _enumerator = null;
+                    _lookup = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -616,15 +616,15 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        lookup = await Internal.Lookup<TKey, TSource>.CreateAsync(source, keySelector, comparer).ConfigureAwait(false);
-                        enumerator = lookup.GetEnumerator();
+                        _lookup = await Internal.Lookup<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer).ConfigureAwait(false);
+                        _enumerator = _lookup.GetEnumerator();
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (enumerator.MoveNext())
+                        if (_enumerator.MoveNext())
                         {
-                            current = (IAsyncGrouping<TKey, TSource>)enumerator.Current;
+                            current = (IAsyncGrouping<TKey, TSource>)_enumerator.Current;
                             return true;
                         }
 
@@ -637,13 +637,13 @@ namespace System.Linq
 
             public async Task<IAsyncGrouping<TKey, TSource>[]> ToArrayAsync(CancellationToken cancellationToken)
             {
-                IAsyncIListProvider<IAsyncGrouping<TKey, TSource>> l = await Internal.Lookup<TKey, TSource>.CreateAsync(source, keySelector, comparer, cancellationToken).ConfigureAwait(false);
+                IAsyncIListProvider<IAsyncGrouping<TKey, TSource>> l = await Internal.Lookup<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToArrayAsync(cancellationToken).ConfigureAwait(false);
             }
 
             public async Task<List<IAsyncGrouping<TKey, TSource>>> ToListAsync(CancellationToken cancellationToken)
             {
-                IAsyncIListProvider<IAsyncGrouping<TKey, TSource>> l = await Internal.Lookup<TKey, TSource>.CreateAsync(source, keySelector, comparer, cancellationToken).ConfigureAwait(false);
+                IAsyncIListProvider<IAsyncGrouping<TKey, TSource>> l = await Internal.Lookup<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToListAsync(cancellationToken).ConfigureAwait(false);
             }
 
@@ -654,7 +654,7 @@ namespace System.Linq
                     return -1;
                 }
 
-                var l = await Internal.Lookup<TKey, TSource>.CreateAsync(source, keySelector, comparer).ConfigureAwait(false);
+                var l = await Internal.Lookup<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer).ConfigureAwait(false);
 
                 return l.Count;
             }
@@ -662,12 +662,12 @@ namespace System.Linq
 
         internal sealed class GroupedAsyncEnumerableWithTask<TSource, TKey> : AsyncIterator<IAsyncGrouping<TKey, TSource>>, IAsyncIListProvider<IAsyncGrouping<TKey, TSource>>
         {
-            private readonly IAsyncEnumerable<TSource> source;
-            private readonly Func<TSource, Task<TKey>> keySelector;
-            private readonly IEqualityComparer<TKey> comparer;
+            private readonly IAsyncEnumerable<TSource> _source;
+            private readonly Func<TSource, Task<TKey>> _keySelector;
+            private readonly IEqualityComparer<TKey> _comparer;
 
-            private Internal.LookupWithTask<TKey, TSource> lookup;
-            private IEnumerator<IGrouping<TKey, TSource>> enumerator;
+            private Internal.LookupWithTask<TKey, TSource> _lookup;
+            private IEnumerator<IGrouping<TKey, TSource>> _enumerator;
 
             public GroupedAsyncEnumerableWithTask(IAsyncEnumerable<TSource> source, Func<TSource, Task<TKey>> keySelector, IEqualityComparer<TKey> comparer)
             {
@@ -675,22 +675,22 @@ namespace System.Linq
                 Debug.Assert(keySelector != null);
                 Debug.Assert(comparer != null);
 
-                this.source = source;
-                this.keySelector = keySelector;
-                this.comparer = comparer;
+                _source = source;
+                _keySelector = keySelector;
+                _comparer = comparer;
             }
 
             public override AsyncIterator<IAsyncGrouping<TKey, TSource>> Clone()
             {
-                return new GroupedAsyncEnumerableWithTask<TSource, TKey>(source, keySelector, comparer);
+                return new GroupedAsyncEnumerableWithTask<TSource, TKey>(_source, _keySelector, _comparer);
             }
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    enumerator.Dispose();
-                    enumerator = null;
-                    lookup = null;
+                    _enumerator.Dispose();
+                    _enumerator = null;
+                    _lookup = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -701,15 +701,15 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        lookup = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(source, keySelector, comparer).ConfigureAwait(false);
-                        enumerator = lookup.GetEnumerator();
+                        _lookup = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer).ConfigureAwait(false);
+                        _enumerator = _lookup.GetEnumerator();
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (enumerator.MoveNext())
+                        if (_enumerator.MoveNext())
                         {
-                            current = (IAsyncGrouping<TKey, TSource>)enumerator.Current;
+                            current = (IAsyncGrouping<TKey, TSource>)_enumerator.Current;
                             return true;
                         }
 
@@ -722,13 +722,13 @@ namespace System.Linq
 
             public async Task<IAsyncGrouping<TKey, TSource>[]> ToArrayAsync(CancellationToken cancellationToken)
             {
-                IAsyncIListProvider<IAsyncGrouping<TKey, TSource>> l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(source, keySelector, comparer, cancellationToken).ConfigureAwait(false);
+                IAsyncIListProvider<IAsyncGrouping<TKey, TSource>> l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToArrayAsync(cancellationToken).ConfigureAwait(false);
             }
 
             public async Task<List<IAsyncGrouping<TKey, TSource>>> ToListAsync(CancellationToken cancellationToken)
             {
-                IAsyncIListProvider<IAsyncGrouping<TKey, TSource>> l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(source, keySelector, comparer, cancellationToken).ConfigureAwait(false);
+                IAsyncIListProvider<IAsyncGrouping<TKey, TSource>> l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToListAsync(cancellationToken).ConfigureAwait(false);
             }
 
@@ -739,7 +739,7 @@ namespace System.Linq
                     return -1;
                 }
 
-                var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(source, keySelector, comparer).ConfigureAwait(false);
+                var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer).ConfigureAwait(false);
 
                 return l.Count;
             }

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Intersect.cs

@@ -35,16 +35,16 @@ namespace System.Linq
 
         private sealed class IntersectAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly IEqualityComparer<TSource> comparer;
-            private readonly IAsyncEnumerable<TSource> first;
-            private readonly IAsyncEnumerable<TSource> second;
+            private readonly IEqualityComparer<TSource> _comparer;
+            private readonly IAsyncEnumerable<TSource> _first;
+            private readonly IAsyncEnumerable<TSource> _second;
 
-            private Task fillSetTask;
+            private Task _fillSetTask;
 
-            private IAsyncEnumerator<TSource> firstEnumerator;
-            private Set<TSource> set;
+            private IAsyncEnumerator<TSource> _firstEnumerator;
+            private Set<TSource> _set;
 
-            private bool setFilled;
+            private bool _setFilled;
 
             public IntersectAsyncIterator(IAsyncEnumerable<TSource> first, IAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
             {
@@ -52,25 +52,25 @@ namespace System.Linq
                 Debug.Assert(second != null);
                 Debug.Assert(comparer != null);
 
-                this.first = first;
-                this.second = second;
-                this.comparer = comparer;
+                _first = first;
+                _second = second;
+                _comparer = comparer;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new IntersectAsyncIterator<TSource>(first, second, comparer);
+                return new IntersectAsyncIterator<TSource>(_first, _second, _comparer);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (firstEnumerator != null)
+                if (_firstEnumerator != null)
                 {
-                    await firstEnumerator.DisposeAsync().ConfigureAwait(false);
-                    firstEnumerator = null;
+                    await _firstEnumerator.DisposeAsync().ConfigureAwait(false);
+                    _firstEnumerator = null;
                 }
 
-                set = null;
+                _set = null;
 
                 await base.DisposeAsync().ConfigureAwait(false);
             }
@@ -80,10 +80,10 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        firstEnumerator = first.GetAsyncEnumerator(cancellationToken);
-                        set = new Set<TSource>(comparer);
-                        setFilled = false;
-                        fillSetTask = FillSet();
+                        _firstEnumerator = _first.GetAsyncEnumerator(cancellationToken);
+                        _set = new Set<TSource>(_comparer);
+                        _setFilled = false;
+                        _fillSetTask = FillSet();
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
@@ -93,23 +93,23 @@ namespace System.Linq
                         bool moveNext;
                         do
                         {
-                            if (!setFilled)
+                            if (!_setFilled)
                             {
                                 // This is here so we don't need to call Task.WhenAll each time after the set is filled
-                                var moveNextTask = firstEnumerator.MoveNextAsync();
-                                await Task.WhenAll(moveNextTask.AsTask(), fillSetTask).ConfigureAwait(false);
-                                setFilled = true;
+                                var moveNextTask = _firstEnumerator.MoveNextAsync();
+                                await Task.WhenAll(moveNextTask.AsTask(), _fillSetTask).ConfigureAwait(false);
+                                _setFilled = true;
                                 moveNext = moveNextTask.Result;
                             }
                             else
                             {
-                                moveNext = await firstEnumerator.MoveNextAsync().ConfigureAwait(false);
+                                moveNext = await _firstEnumerator.MoveNextAsync().ConfigureAwait(false);
                             }
 
                             if (moveNext)
                             {
-                                var item = firstEnumerator.Current;
-                                if (set.Remove(item))
+                                var item = _firstEnumerator.Current;
+                                if (_set.Remove(item))
                                 {
                                     current = item;
                                     return true;
@@ -126,10 +126,10 @@ namespace System.Linq
 
             private async Task FillSet()
             {
-                var array = await second.ToArray().ConfigureAwait(false);
+                var array = await _second.ToArray().ConfigureAwait(false);
                 for (var i = 0; i < array.Length; i++)
                 {
-                    set.Add(array[i]);
+                    _set.Add(array[i]);
                 }
             }
         }

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Repeat.cs

@@ -20,27 +20,27 @@ namespace System.Linq
 
         private sealed class RepeatAsyncIterator<TResult> : AsyncIterator<TResult>, IAsyncIListProvider<TResult>
         {
-            private readonly TResult element;
-            private readonly int count;
-            private int remaining;
+            private readonly TResult _element;
+            private readonly int _count;
+            private int _remaining;
 
             public RepeatAsyncIterator(TResult element, int count)
             {
-                this.element = element;
-                this.count = count;
+                _element = element;
+                _count = count;
             }
 
-            public override AsyncIterator<TResult> Clone() => new RepeatAsyncIterator<TResult>(element, count);
+            public override AsyncIterator<TResult> Clone() => new RepeatAsyncIterator<TResult>(_element, _count);
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => Task.FromResult(count);
+            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => Task.FromResult(_count);
 
             public Task<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
             {
-                var res = new TResult[count];
+                var res = new TResult[_count];
 
-                for (var i = 0; i < count; i++)
+                for (var i = 0; i < _count; i++)
                 {
-                    res[i] = element;
+                    res[i] = _element;
                 }
 
                 return Task.FromResult(res);
@@ -48,11 +48,11 @@ namespace System.Linq
 
             public Task<List<TResult>> ToListAsync(CancellationToken cancellationToken)
             {
-                var res = new List<TResult>(count);
+                var res = new List<TResult>(_count);
 
-                for (var i = 0; i < count; i++)
+                for (var i = 0; i < _count; i++)
                 {
-                    res.Add(element);
+                    res.Add(_element);
                 }
 
                 return Task.FromResult(res);
@@ -63,11 +63,11 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        remaining = count;
+                        _remaining = _count;
 
-                        if (remaining > 0)
+                        if (_remaining > 0)
                         {
-                            current = element;
+                            current = _element;
                         }
 
                         state = AsyncIteratorState.Iterating;
@@ -75,7 +75,7 @@ namespace System.Linq
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (remaining-- != 0)
+                        if (_remaining-- != 0)
                         {
                             return true;
                         }

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Reverse.cs

@@ -24,21 +24,21 @@ namespace System.Linq
 
         private sealed class ReverseAsyncIterator<TSource> : AsyncIterator<TSource>, IAsyncIListProvider<TSource>
         {
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private int index;
-            private TSource[] items;
+            private int _index;
+            private TSource[] _items;
 
             public ReverseAsyncIterator(IAsyncEnumerable<TSource> source)
             {
                 Debug.Assert(source != null);
 
-                this.source = source;
+                _source = source;
             }
 
             public async Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
             {
-                var array = await source.ToArray(cancellationToken).ConfigureAwait(false);
+                var array = await _source.ToArray(cancellationToken).ConfigureAwait(false);
 
                 // Array.Reverse() involves boxing for non-primitive value types, but
                 // checking that has its own cost, so just use this approach for all types.
@@ -54,7 +54,7 @@ namespace System.Linq
 
             public async Task<List<TSource>> ToListAsync(CancellationToken cancellationToken)
             {
-                var list = await source.ToList(cancellationToken).ConfigureAwait(false);
+                var list = await _source.ToList(cancellationToken).ConfigureAwait(false);
 
                 list.Reverse();
                 return list;
@@ -64,28 +64,28 @@ namespace System.Linq
             {
                 if (onlyIfCheap)
                 {
-                    if (source is IAsyncIListProvider<TSource> listProv)
+                    if (_source is IAsyncIListProvider<TSource> listProv)
                     {
                         return listProv.GetCountAsync(true, cancellationToken);
                     }
 
-                    if (!(source is ICollection<TSource>) && !(source is ICollection))
+                    if (!(_source is ICollection<TSource>) && !(_source is ICollection))
                     {
                         return Task.FromResult(-1);
                     }
                 }
 
-                return source.Count(cancellationToken);
+                return _source.Count(cancellationToken);
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new ReverseAsyncIterator<TSource>(source);
+                return new ReverseAsyncIterator<TSource>(_source);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                items = null; // Just in case this ends up being long-lived, allow the memory to be reclaimed.
+                _items = null; // Just in case this ends up being long-lived, allow the memory to be reclaimed.
                 await base.DisposeAsync().ConfigureAwait(false);
             }
 
@@ -94,17 +94,17 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        items = await source.ToArray().ConfigureAwait(false);
-                        index = items.Length - 1;
+                        _items = await _source.ToArray().ConfigureAwait(false);
+                        _index = _items.Length - 1;
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (index != -1)
+                        if (_index != -1)
                         {
-                            current = items[index];
-                            --index;
+                            current = _items[_index];
+                            --_index;
                             return true;
                         }
 

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Select.cs

@@ -83,31 +83,31 @@ namespace System.Linq
 
         internal sealed class SelectEnumerableAsyncIterator<TSource, TResult> : AsyncIterator<TResult>
         {
-            private readonly Func<TSource, TResult> selector;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, TResult> _selector;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public SelectEnumerableAsyncIterator(IAsyncEnumerable<TSource> source, Func<TSource, TResult> selector)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(selector != null);
 
-                this.source = source;
-                this.selector = selector;
+                _source = source;
+                _selector = selector;
             }
 
             public override AsyncIterator<TResult> Clone()
             {
-                return new SelectEnumerableAsyncIterator<TSource, TResult>(source, selector);
+                return new SelectEnumerableAsyncIterator<TSource, TResult>(_source, _selector);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -115,7 +115,7 @@ namespace System.Linq
 
             public override IAsyncEnumerable<TResult1> Select<TResult1>(Func<TResult, TResult1> selector)
             {
-                return new SelectEnumerableAsyncIterator<TSource, TResult1>(source, CombineSelectors(this.selector, selector));
+                return new SelectEnumerableAsyncIterator<TSource, TResult1>(_source, CombineSelectors(_selector, selector));
             }
 
             protected override async ValueTask<bool> MoveNextCore(CancellationToken cancellationToken)
@@ -123,14 +123,14 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = selector(enumerator.Current);
+                            current = _selector(_enumerator.Current);
                             return true;
                         }
 
@@ -144,31 +144,31 @@ namespace System.Linq
 
         internal sealed class SelectEnumerableWithIndexAsyncIterator<TSource, TResult> : AsyncIterator<TResult>
         {
-            private readonly Func<TSource, int, TResult> selector;
-            private readonly IAsyncEnumerable<TSource> source;
-            private IAsyncEnumerator<TSource> enumerator;
-            private int index;
+            private readonly Func<TSource, int, TResult> _selector;
+            private readonly IAsyncEnumerable<TSource> _source;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private int _index;
 
             public SelectEnumerableWithIndexAsyncIterator(IAsyncEnumerable<TSource> source, Func<TSource, int, TResult> selector)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(selector != null);
 
-                this.source = source;
-                this.selector = selector;
+                _source = source;
+                _selector = selector;
             }
 
             public override AsyncIterator<TResult> Clone()
             {
-                return new SelectEnumerableWithIndexAsyncIterator<TSource, TResult>(source, selector);
+                return new SelectEnumerableWithIndexAsyncIterator<TSource, TResult>(_source, _selector);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -179,19 +179,19 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        index = -1;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _index = -1;
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
                             checked
                             {
-                                index++;
+                                _index++;
                             }
-                            current = selector(enumerator.Current, index);
+                            current = _selector(_enumerator.Current, _index);
                             return true;
                         }
 
@@ -205,30 +205,30 @@ namespace System.Linq
 
         internal sealed class SelectIListIterator<TSource, TResult> : AsyncIterator<TResult>, IAsyncIListProvider<TResult>
         {
-            private readonly Func<TSource, TResult> selector;
-            private readonly IList<TSource> source;
-            private IEnumerator<TSource> enumerator;
+            private readonly Func<TSource, TResult> _selector;
+            private readonly IList<TSource> _source;
+            private IEnumerator<TSource> _enumerator;
 
             public SelectIListIterator(IList<TSource> source, Func<TSource, TResult> selector)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(selector != null);
 
-                this.source = source;
-                this.selector = selector;
+                _source = source;
+                _selector = selector;
             }
 
             public override AsyncIterator<TResult> Clone()
             {
-                return new SelectIListIterator<TSource, TResult>(source, selector);
+                return new SelectIListIterator<TSource, TResult>(_source, _selector);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    enumerator.Dispose();
-                    enumerator = null;
+                    _enumerator.Dispose();
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -243,9 +243,9 @@ namespace System.Linq
 
                 var count = 0;
 
-                foreach (var item in source)
+                foreach (var item in _source)
                 {
-                    selector(item);
+                    _selector(item);
 
                     checked
                     {
@@ -258,18 +258,18 @@ namespace System.Linq
 
             public override IAsyncEnumerable<TResult1> Select<TResult1>(Func<TResult, TResult1> selector)
             {
-                return new SelectIListIterator<TSource, TResult1>(source, CombineSelectors(this.selector, selector));
+                return new SelectIListIterator<TSource, TResult1>(_source, CombineSelectors(_selector, selector));
             }
 
             public Task<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
             {
-                var n = source.Count;
+                var n = _source.Count;
 
                 var res = new TResult[n];
 
                 for (var i = 0; i < n; i++)
                 {
-                    res[i] = selector(source[i]);
+                    res[i] = _selector(_source[i]);
                 }
 
                 return Task.FromResult(res);
@@ -277,13 +277,13 @@ namespace System.Linq
 
             public Task<List<TResult>> ToListAsync(CancellationToken cancellationToken)
             {
-                var n = source.Count;
+                var n = _source.Count;
 
                 var res = new List<TResult>(n);
 
                 for (var i = 0; i < n; i++)
                 {
-                    res.Add(selector(source[i]));
+                    res.Add(_selector(_source[i]));
                 }
 
                 return Task.FromResult(res);
@@ -294,14 +294,14 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetEnumerator();
+                        _enumerator = _source.GetEnumerator();
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (enumerator.MoveNext())
+                        if (_enumerator.MoveNext())
                         {
-                            current = selector(enumerator.Current);
+                            current = _selector(_enumerator.Current);
                             return true;
                         }
 
@@ -315,31 +315,31 @@ namespace System.Linq
 
         internal sealed class SelectEnumerableAsyncIteratorWithTask<TSource, TResult> : AsyncIterator<TResult>
         {
-            private readonly Func<TSource, Task<TResult>> selector;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, Task<TResult>> _selector;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public SelectEnumerableAsyncIteratorWithTask(IAsyncEnumerable<TSource> source, Func<TSource, Task<TResult>> selector)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(selector != null);
 
-                this.source = source;
-                this.selector = selector;
+                _source = source;
+                _selector = selector;
             }
 
             public override AsyncIterator<TResult> Clone()
             {
-                return new SelectEnumerableAsyncIteratorWithTask<TSource, TResult>(source, selector);
+                return new SelectEnumerableAsyncIteratorWithTask<TSource, TResult>(_source, _selector);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -347,7 +347,7 @@ namespace System.Linq
 
             public override IAsyncEnumerable<TResult1> Select<TResult1>(Func<TResult, Task<TResult1>> selector)
             {
-                return new SelectEnumerableAsyncIteratorWithTask<TSource, TResult1>(source, CombineSelectors(this.selector, selector));
+                return new SelectEnumerableAsyncIteratorWithTask<TSource, TResult1>(_source, CombineSelectors(_selector, selector));
             }
 
             protected override async ValueTask<bool> MoveNextCore(CancellationToken cancellationToken)
@@ -355,14 +355,14 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = await selector(enumerator.Current).ConfigureAwait(false);
+                            current = await _selector(_enumerator.Current).ConfigureAwait(false);
                             return true;
                         }
 
@@ -376,31 +376,31 @@ namespace System.Linq
 
         internal sealed class SelectEnumerableWithIndexAsyncIteratorWithTask<TSource, TResult> : AsyncIterator<TResult>
         {
-            private readonly Func<TSource, int, Task<TResult>> selector;
-            private readonly IAsyncEnumerable<TSource> source;
-            private IAsyncEnumerator<TSource> enumerator;
-            private int index;
+            private readonly Func<TSource, int, Task<TResult>> _selector;
+            private readonly IAsyncEnumerable<TSource> _source;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private int _index;
 
             public SelectEnumerableWithIndexAsyncIteratorWithTask(IAsyncEnumerable<TSource> source, Func<TSource, int, Task<TResult>> selector)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(selector != null);
 
-                this.source = source;
-                this.selector = selector;
+                _source = source;
+                _selector = selector;
             }
 
             public override AsyncIterator<TResult> Clone()
             {
-                return new SelectEnumerableWithIndexAsyncIteratorWithTask<TSource, TResult>(source, selector);
+                return new SelectEnumerableWithIndexAsyncIteratorWithTask<TSource, TResult>(_source, _selector);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -411,19 +411,19 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        index = -1;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _index = -1;
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
                             checked
                             {
-                                index++;
+                                _index++;
                             }
-                            current = await selector(enumerator.Current, index).ConfigureAwait(false);
+                            current = await _selector(_enumerator.Current, _index).ConfigureAwait(false);
                             return true;
                         }
 
@@ -442,30 +442,30 @@ namespace System.Linq
 
         internal sealed class SelectIListIteratorWithTask<TSource, TResult> : AsyncIterator<TResult>, IAsyncIListProvider<TResult>
         {
-            private readonly Func<TSource, Task<TResult>> selector;
-            private readonly IList<TSource> source;
-            private IEnumerator<TSource> enumerator;
+            private readonly Func<TSource, Task<TResult>> _selector;
+            private readonly IList<TSource> _source;
+            private IEnumerator<TSource> _enumerator;
 
             public SelectIListIteratorWithTask(IList<TSource> source, Func<TSource, Task<TResult>> selector)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(selector != null);
 
-                this.source = source;
-                this.selector = selector;
+                _source = source;
+                _selector = selector;
             }
 
             public override AsyncIterator<TResult> Clone()
             {
-                return new SelectIListIteratorWithTask<TSource, TResult>(source, selector);
+                return new SelectIListIteratorWithTask<TSource, TResult>(_source, _selector);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    enumerator.Dispose();
-                    enumerator = null;
+                    _enumerator.Dispose();
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -480,9 +480,9 @@ namespace System.Linq
 
                 var count = 0;
 
-                foreach (var item in source)
+                foreach (var item in _source)
                 {
-                    await selector(item).ConfigureAwait(false);
+                    await _selector(item).ConfigureAwait(false);
 
                     checked
                     {
@@ -495,18 +495,18 @@ namespace System.Linq
 
             public override IAsyncEnumerable<TResult1> Select<TResult1>(Func<TResult, Task<TResult1>> selector)
             {
-                return new SelectIListIteratorWithTask<TSource, TResult1>(source, CombineSelectors(this.selector, selector));
+                return new SelectIListIteratorWithTask<TSource, TResult1>(_source, CombineSelectors(_selector, selector));
             }
 
             public async Task<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
             {
-                var n = source.Count;
+                var n = _source.Count;
 
                 var res = new TResult[n];
 
                 for (var i = 0; i < n; i++)
                 {
-                    res[i] = await selector(source[i]).ConfigureAwait(false);
+                    res[i] = await _selector(_source[i]).ConfigureAwait(false);
                 }
 
                 return res;
@@ -514,13 +514,13 @@ namespace System.Linq
 
             public async Task<List<TResult>> ToListAsync(CancellationToken cancellationToken)
             {
-                var n = source.Count;
+                var n = _source.Count;
 
                 var res = new List<TResult>(n);
 
                 for (var i = 0; i < n; i++)
                 {
-                    res.Add(await selector(source[i]).ConfigureAwait(false));
+                    res.Add(await _selector(_source[i]).ConfigureAwait(false));
                 }
 
                 return res;
@@ -531,14 +531,14 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetEnumerator();
+                        _enumerator = _source.GetEnumerator();
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (enumerator.MoveNext())
+                        if (_enumerator.MoveNext())
                         {
-                            current = await selector(enumerator.Current).ConfigureAwait(false);
+                            current = await _selector(_enumerator.Current).ConfigureAwait(false);
                             return true;
                         }
 

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SingleLinkedNode.cs

@@ -57,8 +57,8 @@ namespace System.Linq
         /// </summary>
         public int GetCount()
         {
-            int count = 0;
-            for (SingleLinkedNode<TSource> node = this; node != null; node = node.Linked)
+            var count = 0;
+            for (var node = this; node != null; node = node.Linked)
             {
                 count++;
             }
@@ -86,7 +86,7 @@ namespace System.Linq
         {
             Debug.Assert(index >= 0 && index < GetCount());
 
-            SingleLinkedNode<TSource> node = this;
+            var node = this;
             for (; index > 0; index--)
             {
                 node = node.Linked;
@@ -104,9 +104,9 @@ namespace System.Linq
         {
             Debug.Assert(count == GetCount());
 
-            TSource[] array = new TSource[count];
-            int index = count;
-            for (SingleLinkedNode<TSource> node = this; node != null; node = node.Linked)
+            var array = new TSource[count];
+            var index = count;
+            for (var node = this; node != null; node = node.Linked)
             {
                 --index;
                 array[index] = node.Item;

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SkipLast.cs

@@ -33,34 +33,34 @@ namespace System.Linq
 
         private sealed class SkipLastAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly int count;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly int _count;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
-            private Queue<TSource> queue;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private Queue<TSource> _queue;
 
             public SkipLastAsyncIterator(IAsyncEnumerable<TSource> source, int count)
             {
                 Debug.Assert(source != null);
 
-                this.source = source;
-                this.count = count;
+                _source = source;
+                _count = count;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new SkipLastAsyncIterator<TSource>(source, count);
+                return new SkipLastAsyncIterator<TSource>(_source, _count);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
-                queue = null; // release the memory
+                _queue = null; // release the memory
 
                 await base.DisposeAsync().ConfigureAwait(false);
             }
@@ -71,22 +71,22 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        queue = new Queue<TSource>();
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _queue = new Queue<TSource>();
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
 
                     case AsyncIteratorState.Iterating:
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var item = enumerator.Current;
-                            queue.Enqueue(item);
+                            var item = _enumerator.Current;
+                            _queue.Enqueue(item);
 
-                            if (queue.Count > count)
+                            if (_queue.Count > _count)
                             {
-                                current = queue.Dequeue();
+                                current = _queue.Dequeue();
                                 return true;
                             }
                         }

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SkipWhile.cs

@@ -53,32 +53,32 @@ namespace System.Linq
 
         private sealed class SkipWhileAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, bool> predicate;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, bool> _predicate;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private bool doMoveNext;
-            private IAsyncEnumerator<TSource> enumerator;
+            private bool _doMoveNext;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public SkipWhileAsyncIterator(IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate)
             {
                 Debug.Assert(predicate != null);
                 Debug.Assert(source != null);
 
-                this.source = source;
-                this.predicate = predicate;
+                _source = source;
+                _predicate = predicate;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new SkipWhileAsyncIterator<TSource>(source, predicate);
+                return new SkipWhileAsyncIterator<TSource>(_source, _predicate);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -89,15 +89,15 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
 
                         // skip elements as requested
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var element = enumerator.Current;
-                            if (!predicate(element))
+                            var element = _enumerator.Current;
+                            if (!_predicate(element))
                             {
-                                doMoveNext = false;
+                                _doMoveNext = false;
                                 state = AsyncIteratorState.Iterating;
                                 goto case AsyncIteratorState.Iterating;
                             }
@@ -106,16 +106,16 @@ namespace System.Linq
                         break;
 
                     case AsyncIteratorState.Iterating:
-                        if (doMoveNext && await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (_doMoveNext && await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 
-                        if (!doMoveNext)
+                        if (!_doMoveNext)
                         {
-                            current = enumerator.Current;
-                            doMoveNext = true;
+                            current = _enumerator.Current;
+                            _doMoveNext = true;
                             return true;
                         }
 
@@ -129,33 +129,33 @@ namespace System.Linq
 
         private sealed class SkipWhileWithIndexAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, int, bool> predicate;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, int, bool> _predicate;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private bool doMoveNext;
-            private IAsyncEnumerator<TSource> enumerator;
-            private int index;
+            private bool _doMoveNext;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private int _index;
 
             public SkipWhileWithIndexAsyncIterator(IAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate)
             {
                 Debug.Assert(predicate != null);
                 Debug.Assert(source != null);
 
-                this.source = source;
-                this.predicate = predicate;
+                _source = source;
+                _predicate = predicate;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new SkipWhileWithIndexAsyncIterator<TSource>(source, predicate);
+                return new SkipWhileWithIndexAsyncIterator<TSource>(_source, _predicate);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -166,21 +166,21 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        index = -1;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _index = -1;
 
                         // skip elements as requested
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
                             checked
                             {
-                                index++;
+                                _index++;
                             }
 
-                            var element = enumerator.Current;
-                            if (!predicate(element, index))
+                            var element = _enumerator.Current;
+                            if (!_predicate(element, _index))
                             {
-                                doMoveNext = false;
+                                _doMoveNext = false;
                                 state = AsyncIteratorState.Iterating;
                                 goto case AsyncIteratorState.Iterating;
                             }
@@ -189,16 +189,16 @@ namespace System.Linq
                         break;
 
                     case AsyncIteratorState.Iterating:
-                        if (doMoveNext && await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (_doMoveNext && await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 
-                        if (!doMoveNext)
+                        if (!_doMoveNext)
                         {
-                            current = enumerator.Current;
-                            doMoveNext = true;
+                            current = _enumerator.Current;
+                            _doMoveNext = true;
                             return true;
                         }
 
@@ -212,32 +212,32 @@ namespace System.Linq
 
         private sealed class SkipWhileAsyncIteratorWithTask<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, Task<bool>> predicate;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, Task<bool>> _predicate;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private bool doMoveNext;
-            private IAsyncEnumerator<TSource> enumerator;
+            private bool _doMoveNext;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public SkipWhileAsyncIteratorWithTask(IAsyncEnumerable<TSource> source, Func<TSource, Task<bool>> predicate)
             {
                 Debug.Assert(predicate != null);
                 Debug.Assert(source != null);
 
-                this.source = source;
-                this.predicate = predicate;
+                _source = source;
+                _predicate = predicate;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new SkipWhileAsyncIteratorWithTask<TSource>(source, predicate);
+                return new SkipWhileAsyncIteratorWithTask<TSource>(_source, _predicate);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -248,15 +248,15 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
 
                         // skip elements as requested
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var element = enumerator.Current;
-                            if (!await predicate(element).ConfigureAwait(false))
+                            var element = _enumerator.Current;
+                            if (!await _predicate(element).ConfigureAwait(false))
                             {
-                                doMoveNext = false;
+                                _doMoveNext = false;
                                 state = AsyncIteratorState.Iterating;
                                 goto case AsyncIteratorState.Iterating;
                             }
@@ -265,16 +265,16 @@ namespace System.Linq
                         break;
 
                     case AsyncIteratorState.Iterating:
-                        if (doMoveNext && await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (_doMoveNext && await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 
-                        if (!doMoveNext)
+                        if (!_doMoveNext)
                         {
-                            current = enumerator.Current;
-                            doMoveNext = true;
+                            current = _enumerator.Current;
+                            _doMoveNext = true;
                             return true;
                         }
 
@@ -288,33 +288,33 @@ namespace System.Linq
 
         private sealed class SkipWhileWithIndexAsyncIteratorWithTask<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, int, Task<bool>> predicate;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, int, Task<bool>> _predicate;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private bool doMoveNext;
-            private IAsyncEnumerator<TSource> enumerator;
-            private int index;
+            private bool _doMoveNext;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private int _index;
 
             public SkipWhileWithIndexAsyncIteratorWithTask(IAsyncEnumerable<TSource> source, Func<TSource, int, Task<bool>> predicate)
             {
                 Debug.Assert(predicate != null);
                 Debug.Assert(source != null);
 
-                this.source = source;
-                this.predicate = predicate;
+                _source = source;
+                _predicate = predicate;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new SkipWhileWithIndexAsyncIteratorWithTask<TSource>(source, predicate);
+                return new SkipWhileWithIndexAsyncIteratorWithTask<TSource>(_source, _predicate);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -325,21 +325,21 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        index = -1;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _index = -1;
 
                         // skip elements as requested
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
                             checked
                             {
-                                index++;
+                                _index++;
                             }
 
-                            var element = enumerator.Current;
-                            if (!await predicate(element, index).ConfigureAwait(false))
+                            var element = _enumerator.Current;
+                            if (!await _predicate(element, _index).ConfigureAwait(false))
                             {
-                                doMoveNext = false;
+                                _doMoveNext = false;
                                 state = AsyncIteratorState.Iterating;
                                 goto case AsyncIteratorState.Iterating;
                             }
@@ -348,16 +348,16 @@ namespace System.Linq
                         break;
 
                     case AsyncIteratorState.Iterating:
-                        if (doMoveNext && await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (_doMoveNext && await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 
-                        if (!doMoveNext)
+                        if (!_doMoveNext)
                         {
-                            current = enumerator.Current;
-                            doMoveNext = true;
+                            current = _enumerator.Current;
+                            _doMoveNext = true;
                             return true;
                         }
 

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/TakeLast.cs

@@ -26,35 +26,35 @@ namespace System.Linq
 
         private sealed class TakeLastAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly int count;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly int _count;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
-            private bool isDone;
-            private Queue<TSource> queue;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private bool _isDone;
+            private Queue<TSource> _queue;
 
             public TakeLastAsyncIterator(IAsyncEnumerable<TSource> source, int count)
             {
                 Debug.Assert(source != null);
 
-                this.source = source;
-                this.count = count;
+                _source = source;
+                _count = count;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new TakeLastAsyncIterator<TSource>(source, count);
+                return new TakeLastAsyncIterator<TSource>(_source, _count);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
-                queue = null; // release the memory
+                _queue = null; // release the memory
 
                 await base.DisposeAsync().ConfigureAwait(false);
             }
@@ -64,9 +64,9 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        queue = new Queue<TSource>();
-                        isDone = false;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _queue = new Queue<TSource>();
+                        _isDone = false;
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
@@ -75,34 +75,34 @@ namespace System.Linq
                     case AsyncIteratorState.Iterating:
                         while (true)
                         {
-                            if (!isDone)
+                            if (!_isDone)
                             {
-                                if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                                if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                                 {
-                                    if (count > 0)
+                                    if (_count > 0)
                                     {
-                                        var item = enumerator.Current;
-                                        if (queue.Count >= count)
+                                        var item = _enumerator.Current;
+                                        if (_queue.Count >= _count)
                                         {
-                                            queue.Dequeue();
+                                            _queue.Dequeue();
                                         }
-                                        queue.Enqueue(item);
+                                        _queue.Enqueue(item);
                                     }
                                 }
                                 else
                                 {
-                                    isDone = true;
+                                    _isDone = true;
                                     // Dispose early here as we can
-                                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                                    enumerator = null;
+                                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                                    _enumerator = null;
                                 }
 
                                 continue; // loop until queue is drained
                             }
 
-                            if (queue.Count > 0)
+                            if (_queue.Count > 0)
                             {
-                                current = queue.Dequeue();
+                                current = _queue.Dequeue();
                                 return true;
                             }
 

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/TakeWhile.cs

@@ -53,31 +53,31 @@ namespace System.Linq
 
         private sealed class TakeWhileAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, bool> predicate;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, bool> _predicate;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public TakeWhileAsyncIterator(IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate)
             {
                 Debug.Assert(predicate != null);
                 Debug.Assert(source != null);
 
-                this.source = source;
-                this.predicate = predicate;
+                _source = source;
+                _predicate = predicate;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new TakeWhileAsyncIterator<TSource>(source, predicate);
+                return new TakeWhileAsyncIterator<TSource>(_source, _predicate);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -88,17 +88,17 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var item = enumerator.Current;
-                            if (!predicate(item))
+                            var item = _enumerator.Current;
+                            if (!_predicate(item))
                             {
                                 break;
                             }
@@ -117,32 +117,32 @@ namespace System.Linq
 
         private sealed class TakeWhileWithIndexAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, int, bool> predicate;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, int, bool> _predicate;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
-            private int index;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private int _index;
 
             public TakeWhileWithIndexAsyncIterator(IAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate)
             {
                 Debug.Assert(predicate != null);
                 Debug.Assert(source != null);
 
-                this.source = source;
-                this.predicate = predicate;
+                _source = source;
+                _predicate = predicate;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new TakeWhileWithIndexAsyncIterator<TSource>(source, predicate);
+                return new TakeWhileWithIndexAsyncIterator<TSource>(_source, _predicate);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -153,22 +153,22 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        index = -1;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _index = -1;
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var item = enumerator.Current;
+                            var item = _enumerator.Current;
                             checked
                             {
-                                index++;
+                                _index++;
                             }
 
-                            if (!predicate(item, index))
+                            if (!_predicate(item, _index))
                             {
                                 break;
                             }
@@ -187,31 +187,31 @@ namespace System.Linq
 
         private sealed class TakeWhileAsyncIteratorWithTask<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, Task<bool>> predicate;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, Task<bool>> _predicate;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public TakeWhileAsyncIteratorWithTask(IAsyncEnumerable<TSource> source, Func<TSource, Task<bool>> predicate)
             {
                 Debug.Assert(predicate != null);
                 Debug.Assert(source != null);
 
-                this.source = source;
-                this.predicate = predicate;
+                _source = source;
+                _predicate = predicate;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new TakeWhileAsyncIteratorWithTask<TSource>(source, predicate);
+                return new TakeWhileAsyncIteratorWithTask<TSource>(_source, _predicate);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -222,17 +222,17 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var item = enumerator.Current;
-                            if (!await predicate(item).ConfigureAwait(false))
+                            var item = _enumerator.Current;
+                            if (!await _predicate(item).ConfigureAwait(false))
                             {
                                 break;
                             }
@@ -251,32 +251,32 @@ namespace System.Linq
 
         private sealed class TakeWhileWithIndexAsyncIteratorWithTask<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, int, Task<bool>> predicate;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, int, Task<bool>> _predicate;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
-            private int index;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private int _index;
 
             public TakeWhileWithIndexAsyncIteratorWithTask(IAsyncEnumerable<TSource> source, Func<TSource, int, Task<bool>> predicate)
             {
                 Debug.Assert(predicate != null);
                 Debug.Assert(source != null);
 
-                this.source = source;
-                this.predicate = predicate;
+                _source = source;
+                _predicate = predicate;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new TakeWhileWithIndexAsyncIteratorWithTask<TSource>(source, predicate);
+                return new TakeWhileWithIndexAsyncIteratorWithTask<TSource>(_source, _predicate);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -287,22 +287,22 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        index = -1;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _index = -1;
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        if (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var item = enumerator.Current;
+                            var item = _enumerator.Current;
                             checked
                             {
-                                index++;
+                                _index++;
                             }
 
-                            if (!await predicate(item, index).ConfigureAwait(false))
+                            if (!await _predicate(item, _index).ConfigureAwait(false))
                             {
                                 break;
                             }

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.cs

@@ -120,28 +120,28 @@ namespace System.Linq
 
         internal sealed class AsyncEnumerableAdapter<T> : AsyncIterator<T>, IAsyncIListProvider<T>
         {
-            private readonly IEnumerable<T> source;
+            private readonly IEnumerable<T> _source;
 
-            private IEnumerator<T> enumerator;
+            private IEnumerator<T> _enumerator;
  
             public AsyncEnumerableAdapter(IEnumerable<T> source)
             {
                 Debug.Assert(source != null);
 
-                this.source = source;
+                _source = source;
             }
 
             public override AsyncIterator<T> Clone()
             {
-                return new AsyncEnumerableAdapter<T>(source);
+                return new AsyncEnumerableAdapter<T>(_source);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    enumerator.Dispose();
-                    enumerator = null;
+                    _enumerator.Dispose();
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -152,14 +152,14 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetEnumerator();
+                        _enumerator = _source.GetEnumerator();
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (enumerator.MoveNext())
+                        if (_enumerator.MoveNext())
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 
@@ -174,43 +174,43 @@ namespace System.Linq
             // and short circuit as appropriate
             public Task<T[]> ToArrayAsync(CancellationToken cancellationToken)
             {
-                return Task.FromResult(source.ToArray());
+                return Task.FromResult(_source.ToArray());
             }
 
             public Task<List<T>> ToListAsync(CancellationToken cancellationToken)
             {
-                return Task.FromResult(source.ToList());
+                return Task.FromResult(_source.ToList());
             }
 
             public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
-                return Task.FromResult(source.Count());
+                return Task.FromResult(_source.Count());
             }
         }
 
         internal sealed class AsyncIListEnumerableAdapter<T> : AsyncIterator<T>, IAsyncIListProvider<T>, IList<T>
         {
-            private readonly IList<T> source;
-            private IEnumerator<T> enumerator;
+            private readonly IList<T> _source;
+            private IEnumerator<T> _enumerator;
 
             public AsyncIListEnumerableAdapter(IList<T> source)
             {
                 Debug.Assert(source != null);
 
-                this.source = source;
+                _source = source;
             }
 
             public override AsyncIterator<T> Clone()
             {
-                return new AsyncIListEnumerableAdapter<T>(source);
+                return new AsyncIListEnumerableAdapter<T>(_source);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    enumerator.Dispose();
-                    enumerator = null;
+                    _enumerator.Dispose();
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -221,14 +221,14 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetEnumerator();
+                        _enumerator = _source.GetEnumerator();
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (enumerator.MoveNext())
+                        if (_enumerator.MoveNext())
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 
@@ -241,79 +241,80 @@ namespace System.Linq
 
             public override IAsyncEnumerable<TResult> Select<TResult>(Func<T, TResult> selector)
             {
-                return new SelectIListIterator<T, TResult>(source, selector);
+                return new SelectIListIterator<T, TResult>(_source, selector);
             }
 
             // These optimizations rely on the Sys.Linq impls from IEnumerable to optimize
             // and short circuit as appropriate
             public Task<T[]> ToArrayAsync(CancellationToken cancellationToken)
             {
-                return Task.FromResult(source.ToArray());
+                return Task.FromResult(_source.ToArray());
             }
 
             public Task<List<T>> ToListAsync(CancellationToken cancellationToken)
             {
-                return Task.FromResult(source.ToList());
+                return Task.FromResult(_source.ToList());
             }
 
             public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
-                return Task.FromResult(source.Count);
+                return Task.FromResult(_source.Count);
             }
 
-            IEnumerator<T> IEnumerable<T>.GetEnumerator() => source.GetEnumerator();
+            IEnumerator<T> IEnumerable<T>.GetEnumerator() => _source.GetEnumerator();
 
-            IEnumerator IEnumerable.GetEnumerator() => source.GetEnumerator();
+            IEnumerator IEnumerable.GetEnumerator() => _source.GetEnumerator();
 
-            void ICollection<T>.Add(T item) => source.Add(item);
+            void ICollection<T>.Add(T item) => _source.Add(item);
 
-            void ICollection<T>.Clear() => source.Clear();
+            void ICollection<T>.Clear() => _source.Clear();
 
-            bool ICollection<T>.Contains(T item) => source.Contains(item);
+            bool ICollection<T>.Contains(T item) => _source.Contains(item);
 
-            void ICollection<T>.CopyTo(T[] array, int arrayIndex) => source.CopyTo(array, arrayIndex);
+            void ICollection<T>.CopyTo(T[] array, int arrayIndex) => _source.CopyTo(array, arrayIndex);
 
-            bool ICollection<T>.Remove(T item) => source.Remove(item);
+            bool ICollection<T>.Remove(T item) => _source.Remove(item);
 
-            int ICollection<T>.Count => source.Count;
+            int ICollection<T>.Count => _source.Count;
 
-            bool ICollection<T>.IsReadOnly => source.IsReadOnly;
+            bool ICollection<T>.IsReadOnly => _source.IsReadOnly;
 
-            int IList<T>.IndexOf(T item) => source.IndexOf(item);
+            int IList<T>.IndexOf(T item) => _source.IndexOf(item);
 
-            void IList<T>.Insert(int index, T item) => source.Insert(index, item);
+            void IList<T>.Insert(int index, T item) => _source.Insert(index, item);
 
-            void IList<T>.RemoveAt(int index) => source.RemoveAt(index);
+            void IList<T>.RemoveAt(int index) => _source.RemoveAt(index);
 
             T IList<T>.this[int index]
             {
-                get { return source[index]; }
-                set { source[index] = value; }
+                get { return _source[index]; }
+                set { _source[index] = value; }
             }
         }
 
         internal sealed class AsyncICollectionEnumerableAdapter<T> : AsyncIterator<T>, IAsyncIListProvider<T>, ICollection<T>
         {
-            private readonly ICollection<T> source;
-            private IEnumerator<T> enumerator;
+            private readonly ICollection<T> _source;
+            private IEnumerator<T> _enumerator;
+
             public AsyncICollectionEnumerableAdapter(ICollection<T> source)
             {
                 Debug.Assert(source != null);
 
-                this.source = source;
+                _source = source;
             }
 
             public override AsyncIterator<T> Clone()
             {
-                return new AsyncICollectionEnumerableAdapter<T>(source);
+                return new AsyncICollectionEnumerableAdapter<T>(_source);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    enumerator.Dispose();
-                    enumerator = null;
+                    _enumerator.Dispose();
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -324,14 +325,14 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetEnumerator();
+                        _enumerator = _source.GetEnumerator();
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (enumerator.MoveNext())
+                        if (_enumerator.MoveNext())
                         {
-                            current = enumerator.Current;
+                            current = _enumerator.Current;
                             return true;
                         }
 
@@ -346,36 +347,36 @@ namespace System.Linq
             // and short circuit as appropriate
             public Task<T[]> ToArrayAsync(CancellationToken cancellationToken)
             {
-                return Task.FromResult(source.ToArray());
+                return Task.FromResult(_source.ToArray());
             }
 
             public Task<List<T>> ToListAsync(CancellationToken cancellationToken)
             {
-                return Task.FromResult(source.ToList());
+                return Task.FromResult(_source.ToList());
             }
 
             public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
-                return Task.FromResult(source.Count);
+                return Task.FromResult(_source.Count);
             }
 
-            IEnumerator<T> IEnumerable<T>.GetEnumerator() => source.GetEnumerator();
+            IEnumerator<T> IEnumerable<T>.GetEnumerator() => _source.GetEnumerator();
 
-            IEnumerator IEnumerable.GetEnumerator() => source.GetEnumerator();
+            IEnumerator IEnumerable.GetEnumerator() => _source.GetEnumerator();
 
-            void ICollection<T>.Add(T item) => source.Add(item);
+            void ICollection<T>.Add(T item) => _source.Add(item);
 
-            void ICollection<T>.Clear() => source.Clear();
+            void ICollection<T>.Clear() => _source.Clear();
 
-            bool ICollection<T>.Contains(T item) => source.Contains(item);
+            bool ICollection<T>.Contains(T item) => _source.Contains(item);
 
-            void ICollection<T>.CopyTo(T[] array, int arrayIndex) => source.CopyTo(array, arrayIndex);
+            void ICollection<T>.CopyTo(T[] array, int arrayIndex) => _source.CopyTo(array, arrayIndex);
 
-            bool ICollection<T>.Remove(T item) => source.Remove(item);
+            bool ICollection<T>.Remove(T item) => _source.Remove(item);
 
-            int ICollection<T>.Count => source.Count;
+            int ICollection<T>.Count => _source.Count;
 
-            bool ICollection<T>.IsReadOnly => source.IsReadOnly;
+            bool ICollection<T>.IsReadOnly => _source.IsReadOnly;
         }
 
         private sealed class ToAsyncEnumerableObserver<T> : IObserver<T>

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToObservable.cs

@@ -18,17 +18,17 @@ namespace System.Linq
 
         private sealed class ToObservableObservable<T> : IObservable<T>
         {
-            private readonly IAsyncEnumerable<T> source;
+            private readonly IAsyncEnumerable<T> _source;
 
             public ToObservableObservable(IAsyncEnumerable<T> source)
             {
-                this.source = source;
+                _source = source;
             }
 
             public IDisposable Subscribe(IObserver<T> observer)
             {
                 var ctd = new CancellationTokenDisposable();
-                var e = source.GetAsyncEnumerator(ctd.Token);
+                var e = _source.GetAsyncEnumerator(ctd.Token);
 
                 var f = default(Action);
                 f = () => e.MoveNextAsync().AsTask().ContinueWith(

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Where.cs

@@ -85,30 +85,30 @@ namespace System.Linq
 
         internal sealed class WhereEnumerableAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, bool> predicate;
-            private readonly IAsyncEnumerable<TSource> source;
-            private IAsyncEnumerator<TSource> enumerator;
+            private readonly Func<TSource, bool> _predicate;
+            private readonly IAsyncEnumerable<TSource> _source;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public WhereEnumerableAsyncIterator(IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(predicate != null);
 
-                this.source = source;
-                this.predicate = predicate;
+                _source = source;
+                _predicate = predicate;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new WhereEnumerableAsyncIterator<TSource>(source, predicate);
+                return new WhereEnumerableAsyncIterator<TSource>(_source, _predicate);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -116,12 +116,12 @@ namespace System.Linq
 
             public override IAsyncEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
             {
-                return new WhereSelectEnumerableAsyncIterator<TSource, TResult>(source, predicate, selector);
+                return new WhereSelectEnumerableAsyncIterator<TSource, TResult>(_source, _predicate, selector);
             }
 
             public override IAsyncEnumerable<TSource> Where(Func<TSource, bool> predicate)
             {
-                return new WhereEnumerableAsyncIterator<TSource>(source, CombinePredicates(this.predicate, predicate));
+                return new WhereEnumerableAsyncIterator<TSource>(_source, CombinePredicates(_predicate, predicate));
             }
 
             protected override async ValueTask<bool> MoveNextCore(CancellationToken cancellationToken)
@@ -129,15 +129,15 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var item = enumerator.Current;
-                            if (predicate(item))
+                            var item = _enumerator.Current;
+                            if (_predicate(item))
                             {
                                 current = item;
                                 return true;
@@ -154,32 +154,32 @@ namespace System.Linq
 
         internal sealed class WhereEnumerableWithIndexAsyncIterator<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, int, bool> predicate;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, int, bool> _predicate;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
-            private int index;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private int _index;
 
             public WhereEnumerableWithIndexAsyncIterator(IAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(predicate != null);
 
-                this.source = source;
-                this.predicate = predicate;
+                _source = source;
+                _predicate = predicate;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new WhereEnumerableWithIndexAsyncIterator<TSource>(source, predicate);
+                return new WhereEnumerableWithIndexAsyncIterator<TSource>(_source, _predicate);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -190,20 +190,20 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        index = -1;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _index = -1;
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
                             checked
                             {
-                                index++;
+                                _index++;
                             }
-                            var item = enumerator.Current;
-                            if (predicate(item, index))
+                            var item = _enumerator.Current;
+                            if (_predicate(item, _index))
                             {
                                 current = item;
                                 return true;
@@ -220,30 +220,30 @@ namespace System.Linq
 
         internal sealed class WhereEnumerableAsyncIteratorWithTask<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, Task<bool>> predicate;
-            private readonly IAsyncEnumerable<TSource> source;
-            private IAsyncEnumerator<TSource> enumerator;
+            private readonly Func<TSource, Task<bool>> _predicate;
+            private readonly IAsyncEnumerable<TSource> _source;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public WhereEnumerableAsyncIteratorWithTask(IAsyncEnumerable<TSource> source, Func<TSource, Task<bool>> predicate)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(predicate != null);
 
-                this.source = source;
-                this.predicate = predicate;
+                _source = source;
+                _predicate = predicate;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new WhereEnumerableAsyncIteratorWithTask<TSource>(source, predicate);
+                return new WhereEnumerableAsyncIteratorWithTask<TSource>(_source, _predicate);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -251,7 +251,7 @@ namespace System.Linq
 
             public override IAsyncEnumerable<TSource> Where(Func<TSource, Task<bool>> predicate)
             {
-                return new WhereEnumerableAsyncIteratorWithTask<TSource>(source, CombinePredicates(this.predicate, predicate));
+                return new WhereEnumerableAsyncIteratorWithTask<TSource>(_source, CombinePredicates(_predicate, predicate));
             }
 
             protected override async ValueTask<bool> MoveNextCore(CancellationToken cancellationToken)
@@ -259,15 +259,15 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var item = enumerator.Current;
-                            if (await predicate(item).ConfigureAwait(false))
+                            var item = _enumerator.Current;
+                            if (await _predicate(item).ConfigureAwait(false))
                             {
                                 current = item;
                                 return true;
@@ -284,32 +284,32 @@ namespace System.Linq
 
         internal sealed class WhereEnumerableWithIndexAsyncIteratorWithTask<TSource> : AsyncIterator<TSource>
         {
-            private readonly Func<TSource, int, Task<bool>> predicate;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, int, Task<bool>> _predicate;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
-            private int index;
+            private IAsyncEnumerator<TSource> _enumerator;
+            private int _index;
 
             public WhereEnumerableWithIndexAsyncIteratorWithTask(IAsyncEnumerable<TSource> source, Func<TSource, int, Task<bool>> predicate)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(predicate != null);
 
-                this.source = source;
-                this.predicate = predicate;
+                _source = source;
+                _predicate = predicate;
             }
 
             public override AsyncIterator<TSource> Clone()
             {
-                return new WhereEnumerableWithIndexAsyncIteratorWithTask<TSource>(source, predicate);
+                return new WhereEnumerableWithIndexAsyncIteratorWithTask<TSource>(_source, _predicate);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -320,20 +320,20 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
-                        index = -1;
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
+                        _index = -1;
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
                             checked
                             {
-                                index++;
+                                _index++;
                             }
-                            var item = enumerator.Current;
-                            if (await predicate(item, index).ConfigureAwait(false))
+                            var item = _enumerator.Current;
+                            if (await _predicate(item, _index).ConfigureAwait(false))
                             {
                                 current = item;
                                 return true;
@@ -350,11 +350,11 @@ namespace System.Linq
 
         internal sealed class WhereSelectEnumerableAsyncIterator<TSource, TResult> : AsyncIterator<TResult>
         {
-            private readonly Func<TSource, bool> predicate;
-            private readonly Func<TSource, TResult> selector;
-            private readonly IAsyncEnumerable<TSource> source;
+            private readonly Func<TSource, bool> _predicate;
+            private readonly Func<TSource, TResult> _selector;
+            private readonly IAsyncEnumerable<TSource> _source;
 
-            private IAsyncEnumerator<TSource> enumerator;
+            private IAsyncEnumerator<TSource> _enumerator;
 
             public WhereSelectEnumerableAsyncIterator(IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
             {
@@ -362,22 +362,22 @@ namespace System.Linq
                 Debug.Assert(predicate != null);
                 Debug.Assert(selector != null);
 
-                this.source = source;
-                this.predicate = predicate;
-                this.selector = selector;
+                _source = source;
+                _predicate = predicate;
+                _selector = selector;
             }
 
             public override AsyncIterator<TResult> Clone()
             {
-                return new WhereSelectEnumerableAsyncIterator<TSource, TResult>(source, predicate, selector);
+                return new WhereSelectEnumerableAsyncIterator<TSource, TResult>(_source, _predicate, _selector);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (enumerator != null)
+                if (_enumerator != null)
                 {
-                    await enumerator.DisposeAsync().ConfigureAwait(false);
-                    enumerator = null;
+                    await _enumerator.DisposeAsync().ConfigureAwait(false);
+                    _enumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -385,7 +385,7 @@ namespace System.Linq
 
             public override IAsyncEnumerable<TResult1> Select<TResult1>(Func<TResult, TResult1> selector)
             {
-                return new WhereSelectEnumerableAsyncIterator<TSource, TResult1>(source, predicate, CombineSelectors(this.selector, selector));
+                return new WhereSelectEnumerableAsyncIterator<TSource, TResult1>(_source, _predicate, CombineSelectors(_selector, selector));
             }
 
             protected override async ValueTask<bool> MoveNextCore(CancellationToken cancellationToken)
@@ -393,17 +393,17 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        enumerator = source.GetAsyncEnumerator(cancellationToken);
+                        _enumerator = _source.GetAsyncEnumerator(cancellationToken);
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        while (await enumerator.MoveNextAsync().ConfigureAwait(false))
+                        while (await _enumerator.MoveNextAsync().ConfigureAwait(false))
                         {
-                            var item = enumerator.Current;
-                            if (predicate(item))
+                            var item = _enumerator.Current;
+                            if (_predicate(item))
                             {
-                                current = selector(item);
+                                current = _selector(item);
                                 return true;
                             }
                         }

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Zip.cs

@@ -37,12 +37,12 @@ namespace System.Linq
 
         private sealed class ZipAsyncIterator<TFirst, TSecond, TResult> : AsyncIterator<TResult>
         {
-            private readonly IAsyncEnumerable<TFirst> first;
-            private readonly IAsyncEnumerable<TSecond> second;
-            private readonly Func<TFirst, TSecond, TResult> selector;
+            private readonly IAsyncEnumerable<TFirst> _first;
+            private readonly IAsyncEnumerable<TSecond> _second;
+            private readonly Func<TFirst, TSecond, TResult> _selector;
 
-            private IAsyncEnumerator<TFirst> firstEnumerator;
-            private IAsyncEnumerator<TSecond> secondEnumerator;
+            private IAsyncEnumerator<TFirst> _firstEnumerator;
+            private IAsyncEnumerator<TSecond> _secondEnumerator;
 
             public ZipAsyncIterator(IAsyncEnumerable<TFirst> first, IAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> selector)
             {
@@ -50,28 +50,28 @@ namespace System.Linq
                 Debug.Assert(second != null);
                 Debug.Assert(selector != null);
 
-                this.first = first;
-                this.second = second;
-                this.selector = selector;
+                _first = first;
+                _second = second;
+                _selector = selector;
             }
 
             public override AsyncIterator<TResult> Clone()
             {
-                return new ZipAsyncIterator<TFirst, TSecond, TResult>(first, second, selector);
+                return new ZipAsyncIterator<TFirst, TSecond, TResult>(_first, _second, _selector);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (firstEnumerator != null)
+                if (_firstEnumerator != null)
                 {
-                    await firstEnumerator.DisposeAsync().ConfigureAwait(false);
-                    firstEnumerator = null;
+                    await _firstEnumerator.DisposeAsync().ConfigureAwait(false);
+                    _firstEnumerator = null;
                 }
 
-                if (secondEnumerator != null)
+                if (_secondEnumerator != null)
                 {
-                    await secondEnumerator.DisposeAsync().ConfigureAwait(false);
-                    secondEnumerator = null;
+                    await _secondEnumerator.DisposeAsync().ConfigureAwait(false);
+                    _secondEnumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -82,8 +82,8 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        firstEnumerator = first.GetAsyncEnumerator(cancellationToken);
-                        secondEnumerator = second.GetAsyncEnumerator(cancellationToken);
+                        _firstEnumerator = _first.GetAsyncEnumerator(cancellationToken);
+                        _secondEnumerator = _second.GetAsyncEnumerator(cancellationToken);
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
@@ -91,14 +91,14 @@ namespace System.Linq
                     case AsyncIteratorState.Iterating:
 
                         // We kick these off and join so they can potentially run in parallel
-                        var ft = firstEnumerator.MoveNextAsync();
-                        var st = secondEnumerator.MoveNextAsync();
+                        var ft = _firstEnumerator.MoveNextAsync();
+                        var st = _secondEnumerator.MoveNextAsync();
                         
                         await Task.WhenAll(ft.AsTask(), st.AsTask()).ConfigureAwait(false);
 
                         if (ft.Result && st.Result)
                         {
-                            current = selector(firstEnumerator.Current, secondEnumerator.Current);
+                            current = _selector(_firstEnumerator.Current, _secondEnumerator.Current);
                             return true;
                         }
 
@@ -112,12 +112,12 @@ namespace System.Linq
 
         private sealed class ZipAsyncIteratorWithTask<TFirst, TSecond, TResult> : AsyncIterator<TResult>
         {
-            private readonly IAsyncEnumerable<TFirst> first;
-            private readonly IAsyncEnumerable<TSecond> second;
-            private readonly Func<TFirst, TSecond, Task<TResult>> selector;
+            private readonly IAsyncEnumerable<TFirst> _first;
+            private readonly IAsyncEnumerable<TSecond> _second;
+            private readonly Func<TFirst, TSecond, Task<TResult>> _selector;
 
-            private IAsyncEnumerator<TFirst> firstEnumerator;
-            private IAsyncEnumerator<TSecond> secondEnumerator;
+            private IAsyncEnumerator<TFirst> _firstEnumerator;
+            private IAsyncEnumerator<TSecond> _secondEnumerator;
 
             public ZipAsyncIteratorWithTask(IAsyncEnumerable<TFirst> first, IAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, Task<TResult>> selector)
             {
@@ -125,28 +125,28 @@ namespace System.Linq
                 Debug.Assert(second != null);
                 Debug.Assert(selector != null);
 
-                this.first = first;
-                this.second = second;
-                this.selector = selector;
+                _first = first;
+                _second = second;
+                _selector = selector;
             }
 
             public override AsyncIterator<TResult> Clone()
             {
-                return new ZipAsyncIteratorWithTask<TFirst, TSecond, TResult>(first, second, selector);
+                return new ZipAsyncIteratorWithTask<TFirst, TSecond, TResult>(_first, _second, _selector);
             }
 
             public override async ValueTask DisposeAsync()
             {
-                if (firstEnumerator != null)
+                if (_firstEnumerator != null)
                 {
-                    await firstEnumerator.DisposeAsync().ConfigureAwait(false);
-                    firstEnumerator = null;
+                    await _firstEnumerator.DisposeAsync().ConfigureAwait(false);
+                    _firstEnumerator = null;
                 }
 
-                if (secondEnumerator != null)
+                if (_secondEnumerator != null)
                 {
-                    await secondEnumerator.DisposeAsync().ConfigureAwait(false);
-                    secondEnumerator = null;
+                    await _secondEnumerator.DisposeAsync().ConfigureAwait(false);
+                    _secondEnumerator = null;
                 }
 
                 await base.DisposeAsync().ConfigureAwait(false);
@@ -157,8 +157,8 @@ namespace System.Linq
                 switch (state)
                 {
                     case AsyncIteratorState.Allocated:
-                        firstEnumerator = first.GetAsyncEnumerator(cancellationToken);
-                        secondEnumerator = second.GetAsyncEnumerator(cancellationToken);
+                        _firstEnumerator = _first.GetAsyncEnumerator(cancellationToken);
+                        _secondEnumerator = _second.GetAsyncEnumerator(cancellationToken);
 
                         state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
@@ -166,13 +166,13 @@ namespace System.Linq
                     case AsyncIteratorState.Iterating:
 
                         // We kick these off and join so they can potentially run in parallel
-                        var ft = firstEnumerator.MoveNextAsync();
-                        var st = secondEnumerator.MoveNextAsync();
+                        var ft = _firstEnumerator.MoveNextAsync();
+                        var st = _secondEnumerator.MoveNextAsync();
                         await Task.WhenAll(ft.AsTask(), st.AsTask()).ConfigureAwait(false);
 
                         if (ft.Result && st.Result)
                         {
-                            current = await selector(firstEnumerator.Current, secondEnumerator.Current).ConfigureAwait(false);
+                            current = await _selector(_firstEnumerator.Current, _secondEnumerator.Current).ConfigureAwait(false);
                             return true;
                         }