using System;

using System.Threading;

using System.Threading.Tasks;

using System.Collections.Generic;

public class Program

{

    public static async Task Main()

    {

        var cancellationTokenSource = new CancellationTokenSource();

        await foreach(var item in GetValues3(5, 3).WithCancellation(cancellationTokenSource.Token).ConfigureAwait(false))

            Console.WriteLine(item);

    }

    /////////////////////////////////

​

    static async IAsyncEnumerable<int> GetValues1()

    {

        await Task.Delay(500).ConfigureAwait(false);

        yield return 0;

        await Task.Delay(500).ConfigureAwait(false);

        yield return 1;

        await Task.Delay(500).ConfigureAwait(false);

        yield return 2;

    }

    static async IAsyncEnumerable<int> GetValues2(int start, int count)

    {

        for(var counter = start; counter < start + count; counter++)

        {

            await Task.Delay(500).ConfigureAwait(false);

            yield return counter;

        }

    }

    static MyAsyncEnumerable GetValues3(int start, int count)

        => new(start, count);

    /////////////////////////////////

    class MyAsyncEnumerable 

        : IAsyncEnumerable<int>

    {

        readonly int start;

        readonly int count;

        public MyAsyncEnumerable(int start, int count)

            => (this.start, this.count) = (start, count);

        public Enumerator GetAsyncEnumerator(CancellationToken cancellationToken = default)

            => new(start, count, cancellationToken);

        IAsyncEnumerator<int> IAsyncEnumerable<int>.GetAsyncEnumerator(CancellationToken cancellationToken)

            => new Enumerator(start, count, cancellationToken);

        public class Enumerator

            : IAsyncEnumerator<int>

        {

            readonly int end;

            readonly CancellationToken cancellationToken;

            int current;

            public Enumerator(int start, int count, CancellationToken cancellationToken)

                => (end, this.cancellationToken, current) = (start + count, cancellationToken, start - 1);

            public int Current

                => current;

            public async ValueTask<bool> MoveNextAsync()

            {

                cancellationToken.ThrowIfCancellationRequested();

                await Task.Delay(500, cancellationToken).ConfigureAwait(false);

                return ++current < end;

            }

            public ValueTask DisposeAsync() 

                => default;

        }

    }

}