using System;

using System.Threading;

using System.Threading.Channels;

using System.Threading.Tasks;

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Case 1:");

        var someClass = new SomeClass();

        _ = someClass.ConsumeChannel();

        Console.WriteLine();

        Console.WriteLine("Case 2:");

        var someClass1 = new SomeClass1();

        _ = someClass1.ConsumeChannel();

        Console.WriteLine();

        Console.WriteLine("Case 3:");

        var someClass2 = new SomeClass2();

        _ = someClass2.ConsumeChannel();

        Console.WriteLine();

        Console.WriteLine("Case 4:");

        var someClass3 = new SomeClass3();

        _ = someClass3.ConsumeChannel();

        _ = someClass3.WaitAndThenCancelToken();

        Console.WriteLine();

        Console.WriteLine("Case 5:");

        var someClass4 = new SomeClass4();

        _ = someClass4.ConsumeChannel();

        _ = someClass4.WaitAndThenCancelToken();

        Console.WriteLine();

        Console.WriteLine("Case 6:");

        var someClass5 = new SomeClass5();

        _ = someClass5.ConsumeChannel();

        _ = someClass5.WaitAndThenCancelToken();

        Console.WriteLine();

        Console.WriteLine("Press any key to exit: ");

        Console.ReadLine();

    }

}

​

/************************************************************************************************************** CASE 1

* Summary:

*   Checking to see if once the Channel is empty that the code will exit the await foreach autmatically.

* Notes:

*   - It does not.

*/

public class SomeClass

{

    Channel<int> SomeChannel { get; set; }

    public SomeClass()

    {

        SomeChannel = Channel.CreateUnbounded<int>();

        // fill up channel with 2 items

        SomeChannel.Writer.TryWrite(1);

        SomeChannel.Writer.TryWrite(2);

        SomeChannel.Writer.TryWrite(3);

    }

    public async Task ConsumeChannel()

    {

        await foreach(var someInt in SomeChannel.Reader.ReadAllAsync())

        {

            Console.WriteLine(someInt);

        }

        Console.WriteLine("Channel empty, so it went here.");

    }

}

​

/************************************************************************************************************** CASE 2

* Summary:

*   Checking to see if the await foreach stops immediately once the writer has completed, or will it first consume

*   all of its contents.

* Notes:

*   - It exits the await foreach only after every item in the channel has been consumed.

*/

public class SomeClass1

{

    Channel<int> SomeChannel { get; set; }

    public SomeClass1()

    {

        SomeChannel = Channel.CreateUnbounded<int>();

        // fill up channel with 2 items

        SomeChannel.Writer.TryWrite(1);

        SomeChannel.Writer.TryWrite(2);

        SomeChannel.Writer.TryWrite(3);

    }

    public async Task ConsumeChannel()

    {

        await foreach(var someInt in SomeChannel.Reader.ReadAllAsync())

        {

            Console.WriteLine(someInt);

            if (someInt == 2)

            {

                SomeChannel.Writer.TryComplete();

            }

        }

        Console.WriteLine("Channel empty, so it went here.");

    }

}

​

/************************************************************************************************************** CASE 3

* Summary:

*   Checking to see if the break keyword will exit the await foreach

* Notes:

*   - It does.

*/

public class SomeClass2

{

    Channel<int> SomeChannel { get; set; }

    public SomeClass2()

    {

        SomeChannel = Channel.CreateUnbounded<int>();

        SomeChannel.Writer.TryWrite(1);

        SomeChannel.Writer.TryWrite(2);

        SomeChannel.Writer.TryWrite(3);

    }

    public async Task ConsumeChannel()

    {

        await foreach(var someInt in SomeChannel.Reader.ReadAllAsync())

        {

            Console.WriteLine(someInt);

            if (someInt == 2)

            {

                SomeChannel.Writer.TryComplete();

                break;

            }

        }

        Console.WriteLine("Break in the await foreach, so it went here.");

    }

}

​

/************************************************************************************************************** CASE 4

* Summary:

*   Checking to see what happens when a token is thrown inside the await foreach without the await foreach

*   inside of a try catch.

* Notes:

*   - If not in a try-catch, it never gets to the Console.Writeline

*/

public class SomeClass3

{

    Channel<int> SomeChannel { get; set; }

    CancellationTokenSource cts { get; set; }

    public SomeClass3()

    {

        cts = new CancellationTokenSource();

        SomeChannel = Channel.CreateUnbounded<int>();

        SomeChannel.Writer.TryWrite(1);

        SomeChannel.Writer.TryWrite(2);

        SomeChannel.Writer.TryWrite(3);

    }

    public async Task ConsumeChannel()

    {

        await foreach(var someInt in SomeChannel.Reader.ReadAllAsync())

        {

            Console.WriteLine(someInt);

            cts.Token.ThrowIfCancellationRequested(); // maybe everything was already consumed before the token is cancelled, thus never reaching this

        }

        Console.WriteLine("Case 4: Token cancelled and exception called and not caught, so it went here.");

    }

    public async Task WaitAndThenCancelToken()

    {

        await Task.Delay(100);

        Console.WriteLine("Case 4: Cancelling token now");

        cts.Cancel();

    }

}

​

/************************************************************************************************************** CASE 5

* Summary:

*   Checking to see what happens when a token is thrown inside the await foreach with the await foreach inside

*   of a try-catch block

* Notes:

*   - It didn't get caught for some reason...

*/

public class SomeClass4

{

    Channel<int> SomeChannel { get; set; }

    CancellationTokenSource cts { get; set; }

    public SomeClass4()

    {

        cts = new CancellationTokenSource();

        SomeChannel = Channel.CreateUnbounded<int>();

        SomeChannel.Writer.TryWrite(1);

        SomeChannel.Writer.TryWrite(2);

        SomeChannel.Writer.TryWrite(3);

        SomeChannel.Writer.TryWrite(4);

        SomeChannel.Writer.TryWrite(5);

        SomeChannel.Writer.TryWrite(6);

        SomeChannel.Writer.TryWrite(7);

        SomeChannel.Writer.TryWrite(8);

        SomeChannel.Writer.TryWrite(9);

        SomeChannel.Writer.TryWrite(10);

        SomeChannel.Writer.TryWrite(11);

        SomeChannel.Writer.TryWrite(12);

    }

    public async Task ConsumeChannel()

    {

        try

        {

            await foreach(var someInt in SomeChannel.Reader.ReadAllAsync())

            {

                Console.WriteLine(someInt);

                cts.Token.ThrowIfCancellationRequested(); // maybe everything was already consumed before the token is cancelled, thus never reaching this

            }

        }

        catch (OperationCanceledException)

        {

            Console.WriteLine("Case 5: Token cancelled and exception called and caught, so it went here.");

        }

    }

    public async Task WaitAndThenCancelToken()

    {

        await Task.Delay(1);

        Console.WriteLine("Case 5: Cancelling token now");

        cts.Cancel();

    }

}

​

/************************************************************************************************************** CASE 6

* Summary:

*   Checking to see what happens when a token is thrown inside the await foreach using WithCanellation method

*   of a try-catch block

* Notes:

*   - It didn't get caught for some reason...

*/

public class SomeClass5

{

    Channel<int> SomeChannel { get; set; }

    CancellationTokenSource cts { get; set; }

    public SomeClass5()

    {

        cts = new CancellationTokenSource();

        SomeChannel = Channel.CreateUnbounded<int>();

        SomeChannel.Writer.TryWrite(1);

        SomeChannel.Writer.TryWrite(2);

        SomeChannel.Writer.TryWrite(3);

    }

    public async Task ConsumeChannel()

    {

        try

        {

            await foreach(var someInt in SomeChannel.Reader.ReadAllAsync().WithCancellation(cts.Token))

            {

                Console.WriteLine(someInt);

                cts.Token.ThrowIfCancellationRequested();

            }

            Console.WriteLine("Case 6: Token cancelled in the chained WithCancallation method, so it went here.");

        }

        catch (OperationCanceledException)

        {

            Console.WriteLine("Case 6: Token cancelled and exception called and caught, so it went here.");

        }

    }

    public async Task WaitAndThenCancelToken()

    {

        await Task.Delay(100);

        Console.WriteLine("Case 6: Cancelling token now");

        cts.Cancel();

    }

}