为什么在 Ctrl+C 我的进程突然停止在“任务<T> .Result”，但适用于“await Task”<T> ”？

Question

Please help to understand what's going on.

I have async method. It return Task<T> .

I need wait this method result BUT with correct stop by Ctrl+C.

The problem is:

If I wait in this way - all works fine :

      var result = **await Task<T>**

If I wait in this way - main process suddenly stoped :

      var result = **Task<T>.Result** 

To show it in code, I write small test (sorry - I can't make it smaller)

using System;
using System.Threading.Tasks;

namespace StopTest4
{
    internal static class ConsoleApp
    {
        private static readonly TaskCompletionSource<bool> GetFirstString = new TaskCompletionSource<bool>();

        private static void OnCancelKeyPressed(object sender, ConsoleCancelEventArgs args)
        {
            Console.WriteLine("Got Stop Signal (by Crt+C)");
            GetFirstString.TrySetResult(false);
            
            args.Cancel = true;
        }

        public static int Main(string[] args)
        {
            try
            {
                var appTask = RunAsync();

                Console.CancelKeyPress += OnCancelKeyPressed;

                return appTask.Result;
            }
            catch (Exception e)
            {
                Console.WriteLine($"Got exception while run main task of the App - {e}");
            }

            return -2;
        }
        
        
        private static async Task<int> RunAsync()
        {
            Console.WriteLine("RunAsync START");
            try
            {
                await LoadWorksFine().ConfigureAwait(false);
                //await LoadWithProcessSuddenlyClose().ConfigureAwait(false);
            }
            catch (Exception e)
            {
                Console.WriteLine($"Got Exception - {e}");
            }
            Console.WriteLine("Stopped!");
            return 0;
        }

        private static Task LoadWithProcessSuddenlyClose()
        {
            try
            {
                Console.WriteLine($"Befor LoadString");
                var result = LoadString().Result;
                Console.WriteLine($"After LoadString - result=\"{result}\"");
            }
            catch (Exception e)
            {
                Console.WriteLine($"LOAD: Got Exception - {e}");
            }
            return Task.CompletedTask;
        }

        private static async Task LoadWorksFine()
        {
            try
            {
                Console.WriteLine($"Befor LoadString");
                var result = await LoadString();
                Console.WriteLine($"After LoadString - result=\"{result}\"");
            }
            catch (Exception e)
            {
                Console.WriteLine($"LOAD: Got Exception - {e}");
            }
        }

        private static async Task<string> LoadString()
        {
            Console.WriteLine($"LoadString: Start");
            try
            {
                if (!await GetFirstString.Task.ConfigureAwait(false))
                {
                    Console.WriteLine($"LoadString: waited task Failed!");
                    return "false";
                }
                Console.WriteLine($"LoadString: waited task Success!");
                return "true";

            }
            catch (Exception e)
            {
                Console.WriteLine($"LoadString: Got Exception - {e}");
            }
            return null;
        }

    } 
}

How to check:

If You run the test and press Ctrl+C you will see such output:

% dotnet StopTest4.dll
RunAsync START
Befor LoadString
LoadString: Start
^CGot Stop Signal (by Crt+C)                  <---- Here press Ctrl+C
LoadString: waited task Failed!
After LoadString - result="false"
Stopped!
%

All works fine!

Now in method RunAsync comment LoadWorksFine() and uncomment LoadWithProcessSuddenlyClose() . Like this:

    private static async Task<int> RunAsync()
    {
        Console.WriteLine("RunAsync START");
        try
        {
            //await LoadWorksFine().ConfigureAwait(false);
            await LoadWithProcessSuddenlyClose().ConfigureAwait(false);
        }
        catch (Exception e)
        {
            Console.WriteLine($"Got Exception - {e}");
        }
        Console.WriteLine("Stopped!");
        return 0;
    }

Now run the test and press Ctrl+C you will see such output:

% dotnet StopTest4.dll
RunAsync START
Befor LoadString
LoadString: Start
^C                  <---- Here press Ctrl+C
%

There are no any exceptions or errors - just process stopped.

It works on MacOS, Linux and Windows.

Who knows why? As for me - both variants correct.

Thank You!

PS: I want second variant - I need to call async method in synchronous method.

Answer 1

I post the question on dotnet git.

And got the answer:

Because your example is synchronously blocking the RunAsync method waiting for the handler to be invoked, but by that point you haven't hooked up the handler. So when ctrl-C is pressed, there isn't a handler to cancel the ctrl-C, and the OS kills the process.

And yes - in this code:

public static int Main(string[] args)
{
    try
    {
        var appTask = RunAsync();

        Console.CancelKeyPress += OnCancelKeyPressed;

        return appTask.Result;
    }
    catch (Exception e)
    {
        Console.WriteLine($"Got exception while run main task of the App - {e}");
    }

    return -2;
}

line Console.CancelKeyPress += OnCancelKeyPressed; never called.

If put it BEFOR var appTask = RunAsync(); all works fine in both variants.

But now I don't understand WHY in second variant Console.CancelKeyPress += OnCancelKeyPressed; never called.

As I understand, var appTask = RunAsync(); only create Task.

Task waiting here - return appTask.Result; !

WHY var appTask = RunAsync(); synchronously blocked? It is a TASK...

UPDATE Now I understood!

You call RunAsync:

var appTask = RunAsync();

RunAsync calls LoadWithProcessSuddenlyClose:

await LoadWithProcessSuddenlyClose().ConfigureAwait(false);

Note that this is exactly the same as if you'd written:

Task t = LoadWithProcessSuddenlyClose();
await t.ConfigureAwait(false);

meaning you're calling LoadWithProcessSuddenlyClose synchronously from RunAsync, and there are no awaits that complete asynchronously prior to it, so your Main method has synchronously invoked LoadWithProcessSuddenlyClose. Then LoadWithProcessSuddenlyClose synchronously blocks:

var result = LoadString().Result;

waiting for the ctrl-C handler to be invoked. You've created a deadlock: you're blocking waiting for something that can only happen after this call returns, because it's only hooked up after this call returns, but this call will never return because it requires the hooked up thing to be invoked to do so.