Ctrl+C doesn't kill the process

[natemcmaster]

Follow-up to #292

Regression in 3a86cab

Repro:

using System;
using System.Threading;
using McMaster.Extensions.CommandLineUtils;

namespace repro
{
    class Program
    {
        static int Main(string[] args)
        {
            return CommandLineApplication.Execute<Program>(args);
        }

        private void OnExecute()
        {
            Console.CancelKeyPress += (_, __) =>
            {
                Console.WriteLine("CTRL+C pressed");
            };
            Console.WriteLine("Hello World!");
            Thread.Sleep(10000);
            Console.WriteLine("Bye world!");
        }
    }
}

Result:

$ dotnet run
Hello World!
^CCTRL+C pressed
Bye world!

[thomaslevesque]

From #292:

The implementation of that gets a little tricky with the current code

That was my impression too. Currently the OnExecute[Async] method is resolved "just in time", so we can't know in advance whether it accepts a CancellationToken.

Here's how I would approach it:

• Add an internal SupportsCancellation property to CommandLineApplication
• In ExecuteMethodConvention, resolve the execute method eagerly, and set the SupportsCancellation property on the CommandLineApplication
• in CommandLineApplication.ExecuteAsync, subscribe to CancelKeyPress only if SupportsCancellation is true

@natemcmaster if you agree I can submit a PR, unless you prefer to do it yourself

[natemcmaster]

Yes, this seems like the right approach. A PR would be greatly appreciated!

[iprins]

I'm running into the same issue, when will the PR be merged?

[natemcmaster]

@thomaslevesque - I reviewed your PR and it matches what you proposed above, but I don't think I'm going to merge it yet. I've been thinking about this all week and think that Ctrl+C needs to be revisited altogether. I'm concerned users won't understand that the ctrl+c behavior changes based on which overload of OnExecute they invoke.

I'm preparing a 2.4.4 patch which simply removes the blocking on async completions behavior. 5f724a7 If blocking on async completions is something you still want, let's open a new issue and look into adding an opt-in API for this behavior.

For anyone who had come to depend on the behavior of waiting for async completions to finalize before process exit, they can restore the original behavior in 2.4.4 by adding code like this before CommandLineApplication runs.

Console.CancelKeyPress += (o, e) =>
{
   e.Cancel = true;
};

CancellationToken will still be cancelled, but default ctrl+c handling isn't going to wait.

[thomaslevesque]

Sound like a reasonable approach 👍