Remove nested type in generic class

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

@@ -9,18 +9,20 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+        internal enum AsyncIteratorState
+        {
+            New = 0,
+            Allocated = 1,
+            Iterating = 2,
+            Disposed = -1,
+        }
+
         internal abstract class AsyncIterator<TSource> : IAsyncEnumerable<TSource>, IAsyncEnumerator<TSource>
         {
-            public enum State
-            {
-                New = 0,
-                Allocated = 1,
-                Iterating = 2,
-                Disposed = -1,
-            }
+            
 
             private readonly int threadId;
-            internal State state = State.New;
+            internal AsyncIteratorState state = AsyncIteratorState.New;
             internal TSource current;
             private CancellationTokenSource cancellationTokenSource;
             private List<CancellationTokenRegistration> moveNextRegistrations;
@@ -35,9 +37,9 @@ namespace System.Linq
 
             public IAsyncEnumerator<TSource> GetEnumerator()
             {
-                var enumerator = state == State.New && threadId == Environment.CurrentManagedThreadId ? this : Clone();
+                var enumerator = state == AsyncIteratorState.New && threadId == Environment.CurrentManagedThreadId ? this : Clone();
 
-                enumerator.state = State.Allocated;
+                enumerator.state = AsyncIteratorState.Allocated;
                 enumerator.cancellationTokenSource = new CancellationTokenSource();
                 enumerator.moveNextRegistrations = new List<CancellationTokenRegistration>();
                 return enumerator;
@@ -53,7 +55,7 @@ namespace System.Linq
                 cancellationTokenSource.Dispose();
 
                 current = default(TSource);
-                state = State.Disposed;
+                state = AsyncIteratorState.Disposed;
 
                 var toClean = moveNextRegistrations?.ToList();
                 moveNextRegistrations = null;
@@ -79,7 +81,7 @@ namespace System.Linq
 
             public async Task<bool> MoveNext(CancellationToken cancellationToken)
             {
-                if (state == State.Disposed)
+                if (state == AsyncIteratorState.Disposed)
                 {
                     return false;
                 }

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

@@ -171,15 +171,15 @@ namespace System.Linq
 
             protected override async Task<bool> MoveNextCore(CancellationToken cancellationToken)
             {
-                if (state == State.Allocated)
+                if (state == AsyncIteratorState.Allocated)
                 {
                     enumerator = GetAsyncEnumerable(0)
                         .GetEnumerator();
-                    state = State.Iterating;
+                    state = AsyncIteratorState.Iterating;
                     counter = 2;
                 }
 
-                if (state == State.Iterating)
+                if (state == AsyncIteratorState.Iterating)
                 {
                     while (true)
                     {

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

@@ -113,11 +113,11 @@ namespace System.Linq
             {
                 switch (state)
                 {
-                    case State.Allocated:
-                        state = State.Iterating;
-                        goto case State.Iterating;
+                    case AsyncIteratorState.Allocated:
+                        state = AsyncIteratorState.Iterating;
+                        goto case AsyncIteratorState.Iterating;
 
-                    case State.Iterating:
+                    case AsyncIteratorState.Iterating:
                         if (await moveNext(cancellationToken).ConfigureAwait(false))
                         {
                             current = currentFunc();

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

@@ -63,22 +63,22 @@ namespace System.Linq
             {
                 switch (state)
                 {
-                    case State.Allocated:
+                    case AsyncIteratorState.Allocated:
                         enumerator = source.GetEnumerator();
                         if (await enumerator.MoveNext(cancellationToken)
                                             .ConfigureAwait(false))
                         {
                             current = enumerator.Current;
-                            state = State.Iterating;
+                            state = AsyncIteratorState.Iterating;
                         }
                         else
                         {
                             current = defaultValue;
-                            state = State.Disposed; 
+                            state = AsyncIteratorState.Disposed; 
                         }
                         return true;
 
-                    case State.Iterating:
+                    case AsyncIteratorState.Iterating:
                         if (await enumerator.MoveNext(cancellationToken)
                                             .ConfigureAwait(false))
                         {

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

@@ -57,7 +57,8 @@ namespace System.Linq
             private readonly IEqualityComparer<TKey> comparer;
 
             private IAsyncEnumerator<TOuter> outerEnumerator;
-            private Mode mode;
+ 
+
 
             public JoinAsyncIterator(IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer)
             {
@@ -91,48 +92,46 @@ namespace System.Linq
                 base.Dispose();
             }
 
-            private enum Mode
-            {
-                Begin,
-                DoLoop,
-                For,
-                While,
-            }
-
             // State machine vars
             Internal.Lookup<TKey, TInner> lookup;
             int count;
             TInner[] elements;
             int index;
             TOuter item;
+            private int mode;
+
+            const int State_Begin = 1;
+            const int State_DoLoop = 2;
+            const int State_For = 3;
+            const int State_While = 4;
 
             protected override async Task<bool> MoveNextCore(CancellationToken cancellationToken)
             {
                 switch (state)
                 {
-                    case State.Allocated:
+                    case AsyncIteratorState.Allocated:
                         outerEnumerator = outer.GetEnumerator();
-                        mode = Mode.Begin;
-                        state = State.Iterating;
-                        goto case State.Iterating;
+                        mode = State_Begin;
+                        state = AsyncIteratorState.Iterating;
+                        goto case AsyncIteratorState.Iterating;
 
-                    case State.Iterating:
+                    case AsyncIteratorState.Iterating:
                         switch (mode)
                         {
-                            case Mode.Begin:
+                            case State_Begin:
                                 if (await outerEnumerator.MoveNext(cancellationToken)
                                                          .ConfigureAwait(false))
                                 {
                                     lookup = await Internal.Lookup<TKey, TInner>.CreateForJoinAsync(inner, innerKeySelector, comparer, cancellationToken).ConfigureAwait(false);
                                     if (lookup.Count != 0)
                                     {
-                                        mode = Mode.DoLoop;
-                                        goto case Mode.DoLoop;   
+                                        mode = State_DoLoop;
+                                        goto case State_DoLoop;   
                                     }
                                 }
 
                                 break;
-                            case Mode.DoLoop:
+                            case State_DoLoop:
                                 item = outerEnumerator.Current;
                                 var g = lookup.GetGrouping(outerKeySelector(item), create: false);
                                 if (g != null)
@@ -140,26 +139,26 @@ namespace System.Linq
                                     count = g._count;
                                     elements = g._elements;
                                     index = 0;
-                                    mode = Mode.For;
-                                    goto case Mode.For;
+                                    mode = State_For;
+                                    goto case State_For;
                                 }
 
                                 break;
 
-                            case Mode.For:
+                            case State_For:
                                 current = resultSelector(item, elements[index]);
                                 index++;
                                 if (index == count)
                                 {
-                                    mode = Mode.While;
+                                    mode = State_While;
                                 }
                                 return true;
 
-                            case Mode.While:
+                            case State_While:
                                 var hasNext = await outerEnumerator.MoveNext(cancellationToken).ConfigureAwait(false);
                                 if (hasNext)
                                 {
-                                    goto case Mode.DoLoop;
+                                    goto case State_DoLoop;
                                 }
 
                              

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

@@ -110,12 +110,12 @@ namespace System.Linq
             {
                 switch (state)
                 {
-                    case State.Allocated:
+                    case AsyncIteratorState.Allocated:
                         enumerator = source.GetEnumerator();
-                        state = State.Iterating;
-                        goto case State.Iterating;
+                        state = AsyncIteratorState.Iterating;
+                        goto case AsyncIteratorState.Iterating;
 
-                    case State.Iterating:
+                    case AsyncIteratorState.Iterating:
                         if (await enumerator.MoveNext(cancellationToken)
                                             .ConfigureAwait(false))
                         {

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

@@ -101,12 +101,12 @@ namespace System.Linq
             {
                 switch (state)
                 {
-                    case State.Allocated:
+                    case AsyncIteratorState.Allocated:
                         enumerator = source.GetEnumerator();
-                        state = State.Iterating;
-                        goto case State.Iterating;
+                        state = AsyncIteratorState.Iterating;
+                        goto case AsyncIteratorState.Iterating;
 
-                    case State.Iterating:
+                    case AsyncIteratorState.Iterating:
                         if (enumerator.MoveNext())
                         {
                             current = enumerator.Current;

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

@@ -111,12 +111,12 @@ namespace System.Linq
             {
                 switch (state)
                 {
-                    case State.Allocated:
+                    case AsyncIteratorState.Allocated:
                         enumerator = source.GetEnumerator();
-                        state = State.Iterating;
-                        goto case State.Iterating;
+                        state = AsyncIteratorState.Iterating;
+                        goto case AsyncIteratorState.Iterating;
 
-                    case State.Iterating:
+                    case AsyncIteratorState.Iterating:
                         while (await enumerator.MoveNext(cancellationToken)
                                                .ConfigureAwait(false))
                         {
@@ -184,12 +184,12 @@ namespace System.Linq
             {
                 switch (state)
                 {
-                    case State.Allocated:
+                    case AsyncIteratorState.Allocated:
                         enumerator = source.GetEnumerator();
-                        state = State.Iterating;
-                        goto case State.Iterating;
+                        state = AsyncIteratorState.Iterating;
+                        goto case AsyncIteratorState.Iterating;
 
-                    case State.Iterating:
+                    case AsyncIteratorState.Iterating:
                         while (await enumerator.MoveNext(cancellationToken)
                                                .ConfigureAwait(false))
                         {