使用Result时出现死锁

Question

I have read that I should only use Result instead of await when I am absolutely sure that an operation is completed. I am not really sure what happens underneath and would like to ask experienced programmers if this is a perfectly safe usage of await / Result / async .

public static bool Success()
{
    return 0 < Execute("DELETE FROM Table WHERE Id = 12").Result;
}

public static async Task<int> Execute(string sql)
{
    using (var con = Connection)
    {
        con.Open();
        return await con.ExecuteAsync(sql);
    }
}

Answer 1

This is not safe. The operation hasn't completed yet when you use Task.Result

When you call an async method it runs synchronously until it reaches an await and then returns to the caller with a task that represents the asynchronous operation.

The task isn't completed and using Task.Result will block the calling thread.

You should await the returned task instead, or use the synchronous option.

public static Task<bool> SuccessAsync()
{
    return 0 < await ExecuteAsync("DELETE FROM Table WHERE Id = 12");
}

public static async Task<int> ExecuteAsync(string sql)
{
    using (var con = Connection)
    {
        con.Open();
        return await con.ExecuteAsync(sql);
    }
}

Answer 2

It is safe, though it ends up blocking until the Execute is complete. Accessing Task.Result is equivalent to:

 Task<int> task = Execute("...");
 task.Wait(); // blocks until done
 return 0 < task.Result;

If you wanted to further the await chain, you could have Success return a Task<bool> instead.

Note that there is a potential for a deadlock depending on the current SynchronizationContext . If your SynchronizationContext is single-threaded, then your call to Task.Result ends up blocking and waiting for Execute to finish, but Execute is waiting for you to release the thread so it can continue. If you're in a GUI app (using a single-threaded SynchronizationContext by default) or ASP.NET, then you'd want to consider adding ConfigureAwait(false) to have Execute run on a thread pool thread instead.