add COnsoleAppContext.Cancel, Terminate. Better handling of OpCanceledEx

Author: neuecc

ReadMe.md

@@ -1039,9 +1039,14 @@ public class ConsoleAppContext
     public MethodInfo MethodInfo { get; }
     public IServiceProvider ServiceProvider { get; }
     public IDictionary<string, object> Items { get; }
+
+    public void Cancel();
+    public void Terminate();
 }
 ```
 
+`Cancel()` set `CancellationToken` to canceled. Also `Terminate()` set token to cancled and terminate process(internal throws `OperationCanceledException` immediately).
+
 ConsoleAppOptions
 ---
 You can configure framework behaviour by ConsoleAppOptions.
@@ -1110,6 +1115,27 @@ public class MyCommand
 
 You can set func to change this behaviour like `NameConverter = x => x.ToLower();`.
 
+Terminate handling in Console.Read
+---
+ConsoleAppFramework handle terminate signal(Ctrl+C) gracefully with `ConsoleAppContext.CancellationToken`. If your application waiting with Console.Read/ReadLine/ReadKey, requires additional handling.
+
+```csharp
+// case of Console.Read/ReadLine, pressed Ctrl+C, Read returns null.
+ConsoleApp.Run(args, async (ConsoleAppContext ctx) =>
+{
+    var read = Console.ReadLine();
+    if (read == null) ctx.Terminate();
+});
+```
+
+```csharp
+// case of Console.ReadKey, can not cancel itself so use with Task.Run and WaitAsync.
+ConsoleApp.Run(args, async (ConsoleAppContext ctx) =>
+{
+    var key = await Task.Run(() => Console.ReadKey()).WaitAsync(ctx.CancellationToken);
+});
+```
+
 Publish to executable file
 ---
 [dotnet run](https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-run) is useful for local development or execute in CI tool. For example in CI, git pull and execute by `dotnet run -- --options` is easy to manage and execute utilities.

sandbox/Net6Console/Program.cs

@@ -10,15 +10,6 @@
 // Console.ReadKey
 ConsoleApp.Run(args, async (ConsoleAppContext ctx) =>
 {
-    var key = await Task.Run(() => Console.ReadKey(intercept: true), ctx.CancellationToken);
+    var key = await Task.Run(() => Console.ReadKey(intercept: true)).WaitAsync(ctx.CancellationToken);
     Console.WriteLine(key.KeyChar);
-    //while (true)
-    //{
-    //    var r = Console.ReadLine();
-
-    //    Console.WriteLine(r == null);
-
-    //    Console.WriteLine("end:" + ctx.CancellationToken.IsCancellationRequested);
-    //}
-
 });

src/ConsoleAppFramework/ConsoleAppContext.cs

@@ -8,6 +8,8 @@ namespace ConsoleAppFramework
 {
     public class ConsoleAppContext
     {
+        readonly CancellationTokenSource cancellationTokenSource;
+
         public string?[] Arguments { get; }
         public DateTime Timestamp { get; }
         public CancellationToken CancellationToken { get; }
@@ -16,15 +18,27 @@ public class ConsoleAppContext
         public IServiceProvider ServiceProvider { get; }
         public IDictionary<string, object> Items { get; }
 
-        public ConsoleAppContext(string?[] arguments, DateTime timestamp, CancellationToken cancellationToken, ILogger<ConsoleApp> logger, MethodInfo methodInfo, IServiceProvider serviceProvider)
+        public ConsoleAppContext(string?[] arguments, DateTime timestamp, CancellationTokenSource cancellationTokenSource, ILogger<ConsoleApp> logger, MethodInfo methodInfo, IServiceProvider serviceProvider)
         {
+            this.cancellationTokenSource = cancellationTokenSource;
             Arguments = arguments;
             Timestamp = timestamp;
-            CancellationToken = cancellationToken;
+            CancellationToken = cancellationTokenSource.Token;
             Logger = logger;
             MethodInfo = methodInfo;
             ServiceProvider = serviceProvider;
             Items = new Dictionary<string, object>();
         }
+
+        public void Cancel()
+        {
+            cancellationTokenSource.Cancel();
+        }
+
+        public void Terminate()
+        {
+            cancellationTokenSource.Cancel();
+            cancellationTokenSource.Token.ThrowIfCancellationRequested();
+        }
     }
 }

src/ConsoleAppFramework/ConsoleAppEngine.cs

@@ -15,16 +15,16 @@ internal class ConsoleAppEngine
     {
         readonly ILogger<ConsoleApp> logger;
         readonly IServiceProvider provider;
-        readonly CancellationToken cancellationToken;
+        readonly CancellationTokenSource cancellationTokenSource;
         readonly ConsoleAppOptions options;
         readonly IServiceProviderIsService isService;
         readonly bool isStrict;
 
-        public ConsoleAppEngine(ILogger<ConsoleApp> logger, IServiceProvider provider, ConsoleAppOptions options, IServiceProviderIsService isService, CancellationToken cancellationToken)
+        public ConsoleAppEngine(ILogger<ConsoleApp> logger, IServiceProvider provider, ConsoleAppOptions options, IServiceProviderIsService isService, CancellationTokenSource cancellationTokenSource)
         {
             this.logger = logger;
             this.provider = provider;
-            this.cancellationToken = cancellationToken;
+            this.cancellationTokenSource = cancellationTokenSource;
             this.options = options;
             this.isService = isService;
             this.isStrict = options.StrictOption;
@@ -134,7 +134,7 @@ async Task RunCore(Type type, MethodInfo methodInfo, object? instance, string?[]
                 return;
             }
 
-            var ctx = new ConsoleAppContext(args, DateTime.UtcNow, cancellationToken, logger, methodInfo, provider);
+            var ctx = new ConsoleAppContext(args, DateTime.UtcNow, cancellationTokenSource, logger, methodInfo, provider);
 
             // re:create invokeArgs, merge with DI parameter.
             if (invokeArgs.Length != originalParameters.Length)
@@ -208,23 +208,20 @@ async Task RunCore(Type type, MethodInfo methodInfo, object? instance, string?[]
             }
             catch (Exception ex)
             {
-                if (ex is OperationCanceledException operationCanceledException && operationCanceledException.CancellationToken == cancellationToken)
-                {
-                    // NOTE: Do nothing if the exception has thrown by the CancellationToken of ConsoleAppEngine.
-                    // If the user code throws OperationCanceledException, ConsoleAppEngine should not handle that.
-                    return;
-                }
-
                 if (ex is TargetInvocationException tex)
                 {
-                    await SetFailAsync("Fail in application running on " + type.Name + "." + methodInfo.Name, tex.InnerException);
-                    return;
+                    ex = tex.InnerException ?? tex;
                 }
-                else
+
+                if (ex is OperationCanceledException operationCanceledException && operationCanceledException.CancellationToken == cancellationTokenSource.Token)
                 {
-                    await SetFailAsync("Fail in application running on " + type.Name + "." + methodInfo.Name, ex);
+                    // NOTE: Do nothing if the exception has thrown by the CancellationToken of ConsoleAppEngine.
+                    // If the user code throws OperationCanceledException, ConsoleAppEngine should not handle that.
                     return;
                 }
+
+                await SetFailAsync("Fail in application running on " + type.Name + "." + methodInfo.Name, ex);
+                return;
             }
 
             logger.LogTrace("ConsoleAppEngine.Run Complete Successfully");

src/ConsoleAppFramework/ConsoleAppEngineService.cs

@@ -36,8 +36,8 @@ public Task StartAsync(CancellationToken ct)
                 try
                 {
                     self.scope = self.provider.CreateScope();
-                    var token = (self.cancellationTokenSource != null) ? self.cancellationTokenSource.Token : CancellationToken.None;
-                    var engine = ActivatorUtilities.CreateInstance<ConsoleAppEngine>(self.scope.ServiceProvider, token);
+                    if (self.cancellationTokenSource == null) self.cancellationTokenSource = new CancellationTokenSource();
+                    var engine = ActivatorUtilities.CreateInstance<ConsoleAppEngine>(self.scope.ServiceProvider, self.cancellationTokenSource!);
                     self.runningTask = engine.RunAsync();
                     await self.runningTask;
                     self.runningTask = null;
@@ -63,7 +63,7 @@ public Task StartAsync(CancellationToken ct)
         }
 
         public async Task StopAsync(CancellationToken ct)
-        { 
+        {
             try
             {
                 cancellationTokenSource?.Cancel();