Calling Asynchronous API in ASP.Net Application

I am not sure what is [WebMethod] in ASP.NET. I remember it used to be SOAP web services but no one does it anymore as we have Web API with controllers where you can use async/await in action methods.

One way to test your code would be to execute async method synchronously using .Result:

[WebMethod]
public static string GetProducts()
{
    BigCommerceAPI api = getAPI();
    return api.getProducts().Result;
}

As maccettura pointed out in the comment, it's a synchronous call and it locks the thread. To make sure you don't have dead locks, follow Fran's advice and add .ConfigureAwait(false) at the end of each async call in getProducts() method.

First by convention GetProducts() should be named GetProductsAsync().

Second, async does not magically allocate a new thread for it's method invocation. async-await is mainly about taking advantage of naturally asynchronous APIs, such as a network call to a database or a remote web-service. When you use Task.Run, you explicitly use a thread-pool thread to execute your delegate.

[WebMethod]
public static string GetProductsAsync()
{
    BigCommerceAPI api = getAPI();
    return Task.Run(() => api.getProductsAsync().Result);
}

Check this link It's a project sample about how to implement Asynchronous web services call in ASP.NET

I had a very similar issue:

1. Main webapp is a ASP.NET 4.5 Web forms, but many of its functions implemented as AJAX calls from UI to a [webMethod] decorated function in the aspx.cs code-behind:
2. The webmethod makes an async call to a proxy. This call was originally implemented with Task.Run() and I tried to rewrite with just await ...

[WebMethod]
public static async Task<OperationResponse<CandidatesContainer>> GetCandidates(string currentRoleName, string customerNameFilter, string countryFilter, string currentQuarter)
{
            string htmlResult = String.Empty;
            List<CandidateEntryDTO> entries = new List<CandidateEntryDTO>();
            try
            {
                entries = await GetCandiatesFromProxy(currentUser, currentRoleName, customerNameFilter, countryFilter, currentQuarter)
                    .ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                log.Error("Error .....", ex);
            }
            CandidatesContainer payloadContainer = new CandidatesContainer { 
               CountryMappedCandiates = ..., 
               GridsHtml = htmlResult };
            return new OperationResponse<CandidatesContainer>(payloadContainer, true);
}

3) The call GetCandiatesFromProxy(...) is the top of a chain of several async methods and at the bottom there's finally a HttpClient.GetAsync(...) call:

private async Task<B2PSResponse<string>> GetResponseFromB2PService(string serviceURI)
{
            string jsonResultString = String.Empty;

            if (_httpClientHandler == null)
            {
                _httpClientHandler = new HttpClientHandler() { UseDefaultCredentials = true };
            }
            if (_client == null)
            {
                _client = new HttpClient(_httpClientHandler);
            }
            HttpResponseMessage response = await _client.GetAsync(serviceURI).ConfigureAwait(false);
            HttpContent content = response.Content;
            string json = String.Empty;
            if (response.StatusCode == HttpStatusCode.OK)
            {
                json = await content.ReadAsStringAsync().ConfigureAwait(false);
            }
            B2PSResponse<string> b2psResponse = new B2PSResponse<string>(response.StatusCode, response.ReasonPhrase, json);
            return b2psResponse;
}

3. The code was not working (was stuck on the lowest level await) until I started to add .ConfigureAwait(false) to each await call.
4. Interesting, that I had to add these .ConfigureAwait(false) to all await calls on the chain - all the way to the top call in the webMethod. Removing any of them would break the code - it would hang after the await that does not have the .ConfigureAwait(false).
5. The last point: I had to modify the Ajax call's SUCCESS path. The default Jason serialization for webmethods makes the result sent to AJAX call as

{data.d.MyObject}

• i.e. inserts the {d} field containing the actual payload. After the webmethod return value was changed from MyObject to Task - this no longer worked - my payload was not found in the {data.d}. The result now contains

{data.d.Result.MyObject} 

This is simply the result of serializing the Task object - which has the .Result field. With one small change to the AJAX call is now working.