Add new SetAction overload to avoid fire & forget silent error (#2565)

* add failing test

* introduce a new overload that will be selected by the compiler

hide it from intellisense, so the users are more likely to use the overload that takes CancellationToken

Author: adamsitnik

src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

@@ -54,6 +54,7 @@
     public System.Void SetAction(System.Action<ParseResult> action)
     public System.Void SetAction(System.Func<ParseResult,System.Int32> action)
     public System.Void SetAction(System.Func<ParseResult,System.Threading.CancellationToken,System.Threading.Tasks.Task> action)
+    public System.Void SetAction(System.Func<ParseResult,System.Threading.Tasks.Task> action)
     public System.Void SetAction(System.Func<ParseResult,System.Threading.CancellationToken,System.Threading.Tasks.Task<System.Int32>> action)
   public class CommandLineConfiguration
     .ctor(Command rootCommand)

src/System.CommandLine.Tests/Invocation/InvocationTests.cs

@@ -188,7 +188,27 @@ public async Task Anonymous_RootCommand_int_returning_Action_can_set_custom_resu
 
             (await rootCommand.Parse("").InvokeAsync()).Should().Be(123);
         }
-        
+
+        [Fact] // https://github.com/dotnet/command-line-api/issues/2562
+        public void Anonymous_async_action_is_not_mapped_into_sync_void_with_fire_and_forget()
+        {
+            RootCommand rootCommand = new();
+            using CancellationTokenSource cts = new();
+            Task delay = Task.Delay(TimeSpan.FromHours(1), cts.Token);
+
+            rootCommand.SetAction(async parseResult =>
+            {
+                await delay;
+            });
+
+            Task started = rootCommand.Parse("").InvokeAsync();
+
+            // The action is supposed to wait for an hour, so it should not complete immediately.
+            started.IsCompleted.Should().BeFalse();
+
+            cts.Cancel();
+        }
+
         [Fact]
         public void Terminating_option_action_short_circuits_command_action()
         {

src/System.CommandLine/Command.cs

@@ -149,6 +149,30 @@ public void SetAction(Func<ParseResult, CancellationToken, Task> action)
             });
         }
 
+        /// <summary>
+        /// Sets an asynchronous action to be run when the command is invoked.
+        /// </summary>
+        /// <remarks>
+        /// When possible, prefer using the <see cref="SetAction(Func{ParseResult, CancellationToken, Task})"/> overload
+        /// and passing the <see cref="CancellationToken"/> parameter to the async method(s) called by the action.
+        /// </remarks>
+        // Hide from intellisense, it's public to avoid the compiler choosing a sync overload
+        // for an async action (and fire and forget issue described in https://github.com/dotnet/command-line-api/issues/2562).
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public void SetAction(Func<ParseResult, Task> action)
+        {
+            if (action is null)
+            {
+                throw new ArgumentNullException(nameof(action));
+            }
+
+            Action = new AnonymousAsynchronousCommandLineAction(async (context, cancellationToken) =>
+            {
+                await action(context);
+                return 0;
+            });
+        }
+
         /// <summary>
         /// Sets an asynchronous action when the command is invoked.
         /// </summary>