Ctrl+C stops working after call to GetCancellationToken

[sherman89]

I have simple code for the user to retry Console.ReadLine until valid input is given, or the app is terminated, and I noticed that if I call GetCancellationToken then the user is stuck in the ReadLine loop forever until they give a valid value.

Code:

using System.CommandLine;

namespace ConsoleApp2;

internal class Program
{
    static async Task<int> Main(string[] args)
    {
        var rootCommand = new RootCommand("Test");

        rootCommand.SetHandler(async context =>
        {
            // Uncomment line below, then Ctrl+C will not work anymore.
            //var cancellationToken = context.GetCancellationToken();
            RunCommand();
            await Task.Delay(0, CancellationToken.None);
        });

        return await rootCommand.InvokeAsync(args);
    }

    private static void RunCommand()
    {
        var isValidInput = false;

        while (!isValidInput)
        {
            Console.WriteLine("INPUT: ");

            string? input = Console.ReadLine();

            if (!string.IsNullOrWhiteSpace(input))
            {
                isValidInput = true;
            }
            else
            {
                Console.WriteLine("Invalid input, please try again...");
            }

            Console.WriteLine();
        }
    }
}

If I call GetCancellationToken, after every Ctrl+C, I get:

If I comment it out, I get:

Seems like a bug to me?

PS: Why is Ctrl+C being treated as input? Shouldn't it by default not do that? I tried Console.TreatControlCAsInput = false; just in-case but I still got "Invalid input..." before it terminated. I'm on .NET 8.

Thanks!

[KalleOlaviNiemitalo]

In 2.0.0-beta4.22272.1, the first InvocationContext.GetCancellationToken() call triggers this event handler:

command-line-api/src/System.CommandLine/Builder/CommandLineBuilderExtensions.cs

Lines 55 to 79 in 209b724

	context.CancellationHandlingAdded += (CancellationTokenSource cts) =>
	{
	blockProcessExit = new ManualResetEventSlim(initialState: false);
	cancellationHandlingAdded = true;
	consoleHandler = (_, args) =>
	{
	cts.Cancel();
	// Stop the process from terminating.
	// Since the context was cancelled, the invocation should
	// finish and Main will return.
	args.Cancel = true;
	};
	processExitHandler = (_, _) =>
	{
	cts.Cancel();
	// The process exits as soon as the event handler returns.
	// We provide a return value using Environment.ExitCode
	// because Main will not finish executing.
	// Wait for the invocation to finish.
	blockProcessExit.Wait();
	ExitCode = context.ExitCode;
	};
	Console.CancelKeyPress += consoleHandler;
	AppDomain.CurrentDomain.ProcessExit += processExitHandler;
	};

which in turn adds a Console.CancelKeyPress event handler that requests cancellation of the CancellationToken and prevents the Ctrl+C from terminating the process.

In #2044, a two-second ProcessTerminationTimeout was added to force terminating the process if it does not react to the cancellation request.

[sherman89]

@KalleOlaviNiemitalo So does this mean that the only way to deal with this situation is to pass the cancellation token to the handler method and manually check if cancellation was requested?

I tried this way:

static async Task<int> Main(string[] args)
{
    var rootCommand = new RootCommand("Test");

    rootCommand.SetHandler(async context =>
    {
        // Uncomment line below, then Ctrl+C will not work anymore.
        var cancellationToken = context.GetCancellationToken();
        RunCommand(cancellationToken);
        await Task.Delay(0, cancellationToken);
    });

    return await rootCommand.InvokeAsync(args);
}

private static void RunCommand(CancellationToken cancellationToken)
{
    var isValidInput = false;

    while (!isValidInput)
    {
        cancellationToken.ThrowIfCancellationRequested();

        Console.WriteLine("INPUT: ");

        string? input = Console.ReadLine();

        if (!string.IsNullOrWhiteSpace(input))
        {
            isValidInput = true;
        }
        else
        {
            Console.WriteLine("Invalid input, please try again...");
        }

        Console.WriteLine();
    }
}

It seems to me that GetCancellationToken causing this kind of side effect is not good design (no disrespect to the developers, just my personal opinion) because the "Get" kind of fools you into thinking that there are no side effects.

Thanks for the quick reply!

[sherman89]

Gonna close this because there seems to be no bug, but I still think GetCancellationToken shouldn't have such side effects.