同步调用不起作用，但是异步调用

Question

I have a simple method that works in an asynchronous format, but when I try to change it to a synchronous format, it acts like it deadlocks and never returns anything. I know it is more effective to use asynchronous calls but I am curious as to why this is happening. Thanks in advance.

This returns a working result:

public static async Task getCompanyAsync(){
    var client = new getRestClient();
    var response = await companiesApi.GetCompaniesAsync(client);
    var companies = response.GetResultAsync<List<Company>>();
}

This will make the program sit and spin until I kill it:

public static void getCompany(){
    var client = new getRestClient();
    var response = companiesApi.GetCompanies(client);
    var companies = response.GetResult<List<Company>>();
}

Edit:

So here is some more detailed code.

    static void Main(string[] args)
    {
        MainAsync(args).Wait();
        Console.ReadLine();
    }
    public static async Task MainAsync(string[] args)
    {
        await getCompanyAsync();
        getCompany();
    }

    private static async Task getCompanyAsync()
    {
        var client = getApiClient();
        var companiesApi = new CompaniesApi(client);
        var response = await companiesApi.GetCompaniesAsync();
        var companyies = await response.GetResultAsync<List<Company>>();
        foreach (var company in companyies)
        {
            Console.WriteLine(company.Name);
        }
    }

    private static void getCompany()
    {
        var client = getApiClient();
        var companiesApi = new CompaniesApi(client);
        var response = companiesApi.GetCompanies();
        var companyies = response.GetResult<List<Company>>();
        foreach (var company in companyies)
        {
            Console.WriteLine(company.Name);
        }

I the application ran as expected when I moved getCompany(); from the MainAsync() method into the Main() method.

Answer 1

Two points here.

First, async will often work in unexpected ways in a console application (as compared to a UI application). This is because UIs have a "built in" synchronization contexts (and, obviously, because they don't automatically exit after their "main" method equivalent has completed execution), whereas Console applications don't. See this article for directions on how to use a context in a console application to mitigate this.

Secondly, as pointed out in one of Stephen Cleary's excellent articles on the topic, it's a bad practice to block on async if avoidable as it can lead to exactly the kinds of deadlocks you describe. Basically, one way of solving this is to use async "all the way down" - ie use async/await instead of GetResult() in your second sample. This idea is echoed in the Microsoft documentation of best practices for async, which recommend against mixing synchronous and asynchronous code like you do in the second code sample.

In the article I linked to the author explains how a deadlock can occur when you mix synchronous and asynchronous code. Basically, this can occur when, for example, the async method is waiting for the same context as the GetResults() call is. (His article explains it a lot better than me though :) ).