Use loop constructs where possible

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

@@ -84,45 +84,50 @@ namespace System.Linq
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (!stopped)
+                        while (true)
                         {
-                            if (await enumerator.MoveNext(cancellationToken)
-                                                .ConfigureAwait(false))
+                            if (!stopped)
                             {
-                                var item = enumerator.Current;
-                                if (index++%skip == 0)
+                                if (await enumerator.MoveNext(cancellationToken)
+                                                    .ConfigureAwait(false))
                                 {
-                                    buffers.Enqueue(new List<TSource>(count));
+                                    var item = enumerator.Current;
+                                    if (index++ % skip == 0)
+                                    {
+                                        buffers.Enqueue(new List<TSource>(count));
+                                    }
+
+                                    foreach (var buffer in buffers)
+                                    {
+                                        buffer.Add(item);
+                                    }
+
+                                    if (buffers.Count > 0 && buffers.Peek()
+                                                                    .Count == count)
+                                    {
+                                        current = buffers.Dequeue();
+                                        return true;
+                                    }
+
+                                    continue; // loop
                                 }
+                                stopped = true;
+                                enumerator.Dispose();
+                                enumerator = null;
 
-                                foreach (var buffer in buffers)
-                                {
-                                    buffer.Add(item);
-                                }
-
-                                if (buffers.Count > 0 && buffers.Peek()
-                                                                .Count == count)
-                                {
-                                    current = buffers.Dequeue();
-                                    return true;
-                                }
-
-                                goto case AsyncIteratorState.Iterating; // loop
+                                continue; // loop
                             }
-                            stopped = true;
-                            enumerator.Dispose();
-                            enumerator = null;
 
-                            goto case AsyncIteratorState.Iterating; // loop
-                        }
+                            if (buffers.Count > 0)
+                            {
+                                current = buffers.Dequeue();
+                                return true;
+                            }
 
-                        if (buffers.Count > 0)
-                        {
-                            current = buffers.Dequeue();
-                            return true;
+                            break; // exit the while
                         }
 
-                        break;
+                        break; // case
                 }
 
                 Dispose();

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

@@ -97,39 +97,44 @@ namespace System.Linq
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (!isDone)
+                        while (true)
                         {
-                            try
+                            if (!isDone)
                             {
-                                if (await enumerator.MoveNext(cancellationToken)
-                                                    .ConfigureAwait(false))
+                                try
                                 {
-                                    current = enumerator.Current;
-                                    return true;
+                                    if (await enumerator.MoveNext(cancellationToken)
+                                                        .ConfigureAwait(false))
+                                    {
+                                        current = enumerator.Current;
+                                        return true;
+                                    }
+                                }
+                                catch (TException ex)
+                                {
+                                    // Note: Ideally we'd dipose of the previous enumerator before
+                                    // invoking the handler, but we use this order to preserve
+                                    // current behavior
+                                    var err = handler(ex)
+                                        .GetEnumerator();
+                                    enumerator?.Dispose();
+                                    enumerator = err;
+                                    isDone = true;
+                                    continue; // loop so we hit the catch state
                                 }
                             }
-                            catch (TException ex)
+
+                            if (await enumerator.MoveNext(cancellationToken)
+                                                .ConfigureAwait(false))
                             {
-                                // Note: Ideally we'd dipose of the previous enumerator before
-                                // invoking the handler, but we use this order to preserve
-                                // current behavior
-                                var err = handler(ex)
-                                    .GetEnumerator();
-                                enumerator?.Dispose();
-                                enumerator = err;
-                                isDone = true;
-                                goto case AsyncIteratorState.Iterating; // loop so we hit the catch state
+                                current = enumerator.Current;
+                                return true;
                             }
-                        }
 
-                        if (await enumerator.MoveNext(cancellationToken)
-                                            .ConfigureAwait(false))
-                        {
-                            current = enumerator.Current;
-                            return true;
+                            break; // while
                         }
 
-                        break;
+                        break; // case
                 }
 
                 Dispose();
@@ -185,38 +190,43 @@ namespace System.Linq
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (enumerator == null)
+                        while (true)
                         {
-                            if (!sourcesEnumerator.MoveNext())
+                            if (enumerator == null)
                             {
-                                // only throw if we have an error on the last one
-                                error?.Throw();
-                                break; // done, nothing else to do
-                            }
+                                if (!sourcesEnumerator.MoveNext())
+                                {
+                                    // only throw if we have an error on the last one
+                                    error?.Throw();
+                                    break; // done, nothing else to do
+                                }
 
-                            error = null;
-                            enumerator = sourcesEnumerator.Current.GetEnumerator();
-                        }
+                                error = null;
+                                enumerator = sourcesEnumerator.Current.GetEnumerator();
+                            }
 
-                        try
-                        {
-                            if (await enumerator.MoveNext(cancellationToken)
-                                                .ConfigureAwait(false))
+                            try
                             {
-                                current = enumerator.Current;
-                                return true;
+                                if (await enumerator.MoveNext(cancellationToken)
+                                                    .ConfigureAwait(false))
+                                {
+                                    current = enumerator.Current;
+                                    return true;
+                                }
                             }
-                        }
-                        catch (Exception ex)
-                        {
-                            // Done with the current one, go to the next
-                            enumerator.Dispose();
-                            enumerator = null;
-                            error = ExceptionDispatchInfo.Capture(ex);
-                            goto case AsyncIteratorState.Iterating;
+                            catch (Exception ex)
+                            {
+                                // Done with the current one, go to the next
+                                enumerator.Dispose();
+                                enumerator = null;
+                                error = ExceptionDispatchInfo.Capture(ex);
+                                continue;
+                            }
+
+                            break; // while
                         }
 
-                        break;
+                        break; // case
                 }
 
 

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

@@ -382,7 +382,7 @@ namespace System.Linq
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNext(cancellationToken)
+                        while (await enumerator.MoveNext(cancellationToken)
                                             .ConfigureAwait(false))
                         {
                             var item = enumerator.Current;
@@ -399,8 +399,6 @@ namespace System.Linq
                                 current = item;
                                 return true;
                             }
-
-                            goto case AsyncIteratorState.Iterating; // loop
                         }
 
                         break;
@@ -455,8 +453,8 @@ namespace System.Linq
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNext(cancellationToken)
-                                            .ConfigureAwait(false))
+                        while (await enumerator.MoveNext(cancellationToken)
+                                               .ConfigureAwait(false))
                         {
                             var item = enumerator.Current;
                             var key = keySelector(item);
@@ -473,11 +471,9 @@ namespace System.Linq
                                 current = item;
                                 return true;
                             }
-
-                            goto case AsyncIteratorState.Iterating; // loop
                         }
 
-                        break;
+                        break; // case
                 }
 
                 Dispose();

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

@@ -86,33 +86,36 @@ namespace System.Linq
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-
                         bool moveNext;
-                        if (!setFilled)
-                        {
-                            // This is here so we don't need to call Task.WhenAll each time after the set is filled
-                            var moveNextTask = firstEnumerator.MoveNext(cancellationToken);
-                            await Task.WhenAll(moveNextTask, fillSetTask)
-                                      .ConfigureAwait(false);
-                            setFilled = true;
-                            moveNext = moveNextTask.Result;
-                        }
-                        else
+                        do
                         {
-                            moveNext = await firstEnumerator.MoveNext(cancellationToken)
-                                                            .ConfigureAwait(false);
-                        }
+                            if (!setFilled)
+                            {
+                                // This is here so we don't need to call Task.WhenAll each time after the set is filled
+                                var moveNextTask = firstEnumerator.MoveNext(cancellationToken);
+                                await Task.WhenAll(moveNextTask, fillSetTask)
+                                          .ConfigureAwait(false);
+                                setFilled = true;
+                                moveNext = moveNextTask.Result;
+                            }
+                            else
+                            {
+                                moveNext = await firstEnumerator.MoveNext(cancellationToken)
+                                                                .ConfigureAwait(false);
+                            }
 
-                        if (moveNext)
-                        {
-                            var item = firstEnumerator.Current;
-                            if (set.Add(item))
+                            if (moveNext)
                             {
-                                current = item;
-                                return true;
+                                var item = firstEnumerator.Current;
+                                if (set.Add(item))
+                                {
+                                    current = item;
+                                    return true;
+                                }
                             }
-                            goto case AsyncIteratorState.Iterating; // loop
-                        }
+
+                        } while (moveNext);
+                        
 
                         Dispose();
                         break;

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

@@ -66,33 +66,37 @@ namespace System.Linq
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (enumerator == null)
+                        while (true)
                         {
-                            if (queue.Count > 0)
+                            if (enumerator == null)
                             {
-                                var src = queue.Dequeue();
+                                if (queue.Count > 0)
+                                {
+                                    var src = queue.Dequeue();
 
-                                enumerator?.Dispose();
-                                enumerator = src.GetEnumerator();
+                                    enumerator?.Dispose();
+                                    enumerator = src.GetEnumerator();
 
-                                goto case AsyncIteratorState.Iterating; // loop
+                                    continue; // loop
+                                }
+
+                                break; // while
                             }
 
-                            break;
+                            if (await enumerator.MoveNext(cancellationToken)
+                                                .ConfigureAwait(false))
+                            {
+                                var item = enumerator.Current;
+                                var next = selector(item);
+                                queue.Enqueue(next);
+                                current = item;
+                                return true;
+                            }
+                            enumerator.Dispose();
+                            enumerator = null;
                         }
 
-                        if (await enumerator.MoveNext(cancellationToken)
-                                            .ConfigureAwait(false))
-                        {
-                            var item = enumerator.Current;
-                            var next = selector(item);
-                            queue.Enqueue(next);
-                            current = item;
-                            return true;
-                        }
-                        enumerator.Dispose();
-                        enumerator = null;
-                        goto case AsyncIteratorState.Iterating; // loop
+                        break; // case
                 }
 
                 Dispose();

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

@@ -56,13 +56,13 @@ namespace System.Linq
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (!await enumerator.MoveNext(cancellationToken)
-                                             .ConfigureAwait(false))
+                        while (await enumerator.MoveNext(cancellationToken)
+                                               .ConfigureAwait(false))
                         {
-                            break;
+                            // Do nothing, we're ignoring these elements
                         }
 
-                        goto case AsyncIteratorState.Iterating; // Loop
+                        break; // case
                 }
 
                 Dispose();

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

@@ -89,31 +89,33 @@ namespace System.Linq
                     case AsyncIteratorState.Iterating:
 
                         bool moveNext;
-                        if (!setFilled)
+                        do
                         {
-                            // This is here so we don't need to call Task.WhenAll each time after the set is filled
-                            var moveNextTask = firstEnumerator.MoveNext(cancellationToken);
-                            await Task.WhenAll(moveNextTask, fillSetTask)
-                                      .ConfigureAwait(false);
-                            setFilled = true;
-                            moveNext = moveNextTask.Result;
-                        }
-                        else
-                        {
-                            moveNext = await firstEnumerator.MoveNext(cancellationToken)
-                                                            .ConfigureAwait(false);
-                        }
+                            if (!setFilled)
+                            {
+                                // This is here so we don't need to call Task.WhenAll each time after the set is filled
+                                var moveNextTask = firstEnumerator.MoveNext(cancellationToken);
+                                await Task.WhenAll(moveNextTask, fillSetTask)
+                                          .ConfigureAwait(false);
+                                setFilled = true;
+                                moveNext = moveNextTask.Result;
+                            }
+                            else
+                            {
+                                moveNext = await firstEnumerator.MoveNext(cancellationToken)
+                                                                .ConfigureAwait(false);
+                            }
 
-                        if (moveNext)
-                        {
-                            var item = firstEnumerator.Current;
-                            if (set.Remove(item))
+                            if (moveNext)
                             {
-                                current = item;
-                                return true;
+                                var item = firstEnumerator.Current;
+                                if (set.Remove(item))
+                                {
+                                    current = item;
+                                    return true;
+                                }
                             }
-                            goto case AsyncIteratorState.Iterating; // loop
-                        }
+                        } while (moveNext);
 
                         Dispose();
                         break;

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

@@ -88,37 +88,41 @@ namespace System.Linq
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (enumerator == null)
+                        while (true)
                         {
-                            if (!sourcesEnumerator.MoveNext())
+                            if (enumerator == null)
                             {
-                                break; // done, nothing else to do
-                            }
+                                if (!sourcesEnumerator.MoveNext())
+                                {
+                                    break; // while -- done, nothing else to do
+                                }
 
-                            enumerator = sourcesEnumerator.Current.GetEnumerator();
-                        }
+                                enumerator = sourcesEnumerator.Current.GetEnumerator();
+                            }
 
-                        try
-                        {
-                            if (await enumerator.MoveNext(cancellationToken)
-                                                .ConfigureAwait(false))
+                            try
                             {
-                                current = enumerator.Current;
-                                return true;
+                                if (await enumerator.MoveNext(cancellationToken)
+                                                    .ConfigureAwait(false))
+                                {
+                                    current = enumerator.Current;
+                                    return true;
+                                }
                             }
-                        }
-                        catch
-                        {
-                            // Ignore
+                            catch
+                            {
+                                // Ignore
+                            }
+
+                            // Done with the current one, go to the next
+                            enumerator.Dispose();
+                            enumerator = null;
                         }
 
-                        // Done with the current one, go to the next
-                        enumerator.Dispose();
-                        enumerator = null;
-                        goto case AsyncIteratorState.Iterating;
+                        break; // case
+                        
                 }
-
-
+                
                 Dispose();
                 return false;
             }

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

@@ -77,16 +77,17 @@ namespace System.Linq
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (!await enumerator.MoveNext(cancellationToken)
+                        if (await enumerator.MoveNext(cancellationToken)
                                              .ConfigureAwait(false))
                         {
-                            break;
+                            var item = enumerator.Current;
+                            accumulated = accumulator(accumulated, item);
+                            current = accumulated;
+                            return true;
                         }
 
-                        var item = enumerator.Current;
-                        accumulated = accumulator(accumulated, item);
-                        current = accumulated;
-                        return true;
+                        break;
+                        
                 }
 
                 Dispose();
@@ -139,23 +140,25 @@ namespace System.Linq
                         goto case AsyncIteratorState.Iterating;
 
                     case AsyncIteratorState.Iterating:
-                        if (!await enumerator.MoveNext(cancellationToken)
-                                             .ConfigureAwait(false))
-                        {
-                            break;
-                        }
 
-                        var item = enumerator.Current;
-                        if (!hasSeed)
+                        while (await enumerator.MoveNext(cancellationToken)
+                                               .ConfigureAwait(false))
                         {
-                            hasSeed = true;
-                            accumulated = item;
-                            goto case AsyncIteratorState.Iterating; // loop
+                            var item = enumerator.Current;
+                            if (!hasSeed)
+                            {
+                                hasSeed = true;
+                                accumulated = item;
+                                continue; // loop
+                            }
+
+                            accumulated = accumulator(accumulated, item);
+                            current = accumulated;
+                            return true;
                         }
 
-                        accumulated = accumulator(accumulated, item);
-                        current = accumulated;
-                        return true;
+                        break; // case
+
                 }
 
                 Dispose();

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

@@ -184,7 +184,7 @@ namespace System.Linq
 
 
                     case AsyncIteratorState.Iterating:
-                        if (await enumerator.MoveNext(cancellationToken)
+                        while (await enumerator.MoveNext(cancellationToken)
                                             .ConfigureAwait(false))
                         {
                             var item = enumerator.Current;
@@ -194,7 +194,6 @@ namespace System.Linq
                                 current = queue.Dequeue();
                                 return true;
                             }
-                            goto case AsyncIteratorState.Iterating; // loop until either the await is false or we return an item
                         }
 
                         break;

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

@@ -163,39 +163,44 @@ namespace System.Linq
 
 
                     case AsyncIteratorState.Iterating:
-                        if (!isDone)
+                        while (true)
                         {
-                            if (await enumerator.MoveNext(cancellationToken)
-                                                .ConfigureAwait(false))
+                            if (!isDone)
                             {
-                                if (count > 0)
+                                if (await enumerator.MoveNext(cancellationToken)
+                                                    .ConfigureAwait(false))
                                 {
-                                    var item = enumerator.Current;
-                                    if (queue.Count >= count)
+                                    if (count > 0)
                                     {
-                                        queue.Dequeue();
+                                        var item = enumerator.Current;
+                                        if (queue.Count >= count)
+                                        {
+                                            queue.Dequeue();
+                                        }
+                                        queue.Enqueue(item);
                                     }
-                                    queue.Enqueue(item);
                                 }
+                                else
+                                {
+                                    isDone = true;
+                                    // Dispose early here as we can
+                                    enumerator.Dispose();
+                                    enumerator = null;
+                                }
+
+                                continue; // loop until queue is drained
                             }
-                            else
+
+                            if (queue.Count > 0)
                             {
-                                isDone = true;
-                                // Dispose early here as we can
-                                enumerator.Dispose();
-                                enumerator = null;
+                                current = queue.Dequeue();
+                                return true;
                             }
 
-                            goto case AsyncIteratorState.Iterating; // loop until queue is drained
+                            break; // while
                         }
 
-                        if (queue.Count > 0)
-                        {
-                            current = queue.Dequeue();
-                            return true;
-                        }
-
-                        break;
+                        break; // case
                 }
 
                 Dispose();