如何从asp.net中进行异步Web调用

Question

Lets say im within an ASP.NET application, WCF or web API, part of this applications job to is contact a 3rd party over the way. Id like to do this asynchronously or rather non blocking so that the thread pool doesnt get starved. However i dont want to change all my code in the service only the bit that makes the web call.

Here is some code i have written:

    public string GetSomeData()
    {
        Task<string> stuff = CallApiAsync(); 

        return stuff.result; //does this block here?

    }

    private async Task<string> CallApiasync()
    {
        using (var httpClient = new HttpClient())
        {
            string response = await httpClient.GetStringAsync(Util.EndPoint).ConfigureAwait(false); 

            return response;
        }

    }

I thought the idea was as follows but please correct any misconceptions.

The caller of CallApi can call the method and when it hits await there is a Task created which represents some work to be done asynchronously but that will take some time. At this point the thread reaches an await returns to the thread pool to do something else ie handle a different request. Once the Task completes the await line wakes up and the code continues from there as if it was synchronous.

If this is the case why do i need to return a Task from my apimethod. The caller seems to have to call stuff.Result which implies that the task may not have finished and calling result could block ? Note i don't want to make the calling method async too as then the method that calls that would need to be async etc etc.

What is the order of event here in my code?

One other question is why did i need to set configureAwait to false? otherwise everything hangs.

Answer 1

Id like to do this asynchronously or rather non blocking so that the thread pool doesnt get starved. However i dont want to change all my code in the service only the bit that makes the web call.

That's not possible. In order to be truly asynchronous, you must allow async to "grow" through the code as far as it needs to. What you're trying to do is block on an asynchronous call, which won't give you any benefit (you're freeing up a thread by using async , but then you're turning around and consuming a thread by using Result ).

At this point the thread reaches an await returns to the thread pool to do something else ie handle a different request.

Not quite. When an async method hits an await , it returns an incomplete Task to its caller . If the caller, in turn, await s that task, then it returns an incomplete Task to its caller, etc. When the ASP.NET runtime receives an incomplete Task from your action/service method/whatever, then it releases the thread to the thread pool.

So, you do have to go " async all the way" to see the real benefit of async .

I have an async intro on my blog if you want a more gentle introduction, as well as an MSDN article on async best practices (one of which is: async all the way). I also have a blog post that describes the deadlock you were seeing .

Answer 2

The compiler handles a lot of the magic behind the async pattern for you, but syntactically, you have to tell it what you want it to do by providing a method prototype that says "ok, this is an asynchronous operation that can be awaited."

For this to happen, your method must return a Task or Task<T> . Any Task can be awaited.

You should be VERY careful when using .Result and .Wait(), as they can block in some very unexpected circumstances, because the runtime may decide to execute your method synchronously.

You should say: await CallApiAsync();

or, to actually take advantage of it:

Task stuff = CallApiAsync();

//More code that can happen independetly of "stuff"

await stuff;

In order to do that, your GetSomeData() function must also be marked as async, but it doesn't have to, itself, return a Task.

Finished copy of a working async version of your code:

public async string GetSomeData() { Task stuff = CallApiAsync();

    return await stuff;

}

private async Task<string> CallApiasync()
{
    using (var httpClient = new HttpClient())
    {
        string response = await httpClient.GetStringAsync(Util.EndPoint).ConfigureAwait(false); 

        return response;
    }

}

Honestly, if that's all the CallApiAsync function is ever going to do, you may as well inline it, though.