web api get request (httpclient call) after await keyword is executed in dotnet core

Question

I would like to do some operation which doesn't depend on API response and at the same time I want API to finish its process.
But in my case, API doesn't receive request when postasync is executed.
Instead, Web api receive request after await weatherForeCastdata.

Can anyone help me ?

public async Task<IEnumerable<WeatherForecast>> Get()  
            {  
                var rng = new Random();  
                 var weatherForeCastdata = new HttpClientCall<WeatherForecast>(_configuration).PostRequest(_configuration["Services:Payperiod"],new WeatherForecast());  
                Console.WriteLine("apiinvoked");  
                var data = await weatherForeCastdata;  
                //var data1 = await data.Content.ReadAsStringAsync();  
                return JsonConvert.DeserializeObject<IEnumerable<WeatherForecast>>(data);  
                  
            }  
      
    public class HttpClientCall<T> where T : class  
        {  
            HttpClientHandler httpClientHandler = new HttpClientHandler();  
            private readonly IConfiguration _configuration;  
            internal HttpClientCall(IConfiguration configuration)  
            {  
                httpClientHandler = new HttpClientHandler();  
                httpClientHandler.ServerCertificateCustomValidationCallback = (message, cert, chain, sslPolicyErrors) =>  
                   {  
                       if (sslPolicyErrors == SslPolicyErrors.None)  
                       {  
                           return true;   //Is valid  
                       }  
                       return true;  
                   };  
                   _configuration = configuration;  
            }  
      
             
             
            public async Task<string> PostRequest(string apiUrl, T postObject)  
            {  
                using (var client = new HttpClient(httpClientHandler))  
                {  
                    client.DefaultRequestHeaders.Add("ClientId", _configuration["header"]);  
                      Console.WriteLine(apiUrl);  
                    var response = client.PostAsync(apiUrl, postObject, new JsonMediaTypeFormatter());  
      
                     var response1=await response;  
                    return await response1.Content.ReadAsStringAsync();  
                }  
            }  
    }

Answer 1

As far as I can tell the code execution is exactly as written.

Here's a more straight forward example of an async/await pattern.

HttpClient client = new HttpClient();  
Task task = ExecuteHttpRequestAsync();  
  
Console.WriteLine($"Doing work while waiting for a response");  
  
await task;  
  
Console.WriteLine("Doing work after receiving the response");  
  
  
async Task ExecuteHttpRequestAsync()  
{  
    Console.WriteLine($"ExecuteHttpRequest Start {DateTime.Now.ToString("hh:mm:ss")}");  
    Console.WriteLine();  
    client.BaseAddress = new Uri("https://localhost:7134");  
  
    HttpResponseMessage response = await client.GetAsync("WeatherForecast");  
    string json = await response.Content.ReadAsStringAsync();  
    //Console.WriteLine(json);  
    Console.WriteLine();  
    Console.WriteLine($"ExecuteHttpRequest End {DateTime.Now.ToString("hh:mm:ss")}");  
}  

The Web API action has a 5 second delay.

        [HttpGet(Name = "GetWeatherForecast")]  
        public async Task<IEnumerable<WeatherForecast>> GetAsync()  
        {  
            await Task.Delay(1000 * 5);  
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast  
            {  
                Date = DateTime.Now.AddDays(index),  
                TemperatureC = Random.Shared.Next(-20, 55),  
                Summary = Summaries[Random.Shared.Next(Summaries.Length)]  
            })  
            .ToArray();  
        }  

Sample results

ExecuteHttpRequest Start 11:48:51  
  
Doing work while waiting for a response  
  
ExecuteHttpRequest End 11:48:56  
Doing work after receiving the response  

Reference documentation
Asynchronous programming with async and await

Answer 2

Pretty simple

var rq = PostRequest(url, data);  
  
// do some work  
  
var value = await rq;  
  

Answer 3

@agavejoe  
Is your web api received request after client.GetAsync("WeatherForecast") method?  
In my case , web api received request after await task.  
you can check by adding console.WriteLine in your web api.  
Here is my program with log  
**Caller :**  
 [HttpGet]  
        public async Task<IEnumerable<WeatherForecast>> Get()  
        {  
            var rng = new Random();                
            Console.WriteLine("api invoked"+DateTime.Now.ToString("hh:mm:ss.fff"));  
            var  weatherForeCastdata = GetData();  
             Console.WriteLine("Doing work while waiting for response"+DateTime.Now.ToString("hh:mm:ss.fff"));  
            //await Task.Delay(5000);  
            var data = await weatherForeCastdata;  
            Console.WriteLine("Doing work after response"+DateTime.Now.ToString("hh:mm:ss.fff"));             
            return JsonConvert.DeserializeObject<IEnumerable<WeatherForecast>>(data);  
              
        }  
        public Task<string> GetData()  
        {  
               return  new HttpClientCall<WeatherForecast>(_configuration).PostRequest(_configuration["Services:Payperiod"],new WeatherForecast());    
        }  
  
**Receiver :**  
  
public async Task<IEnumerable<WeatherForecast>> Post(WeatherForecast weatherforcast)  
        {  
            Console.WriteLine("API request "+DateTime.Now.ToString("hh:mm:ss.fff"));  
            await Task.Delay(5000);  
            var rng = new Random();  
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast  
            {  
                Date = DateTime.Now.AddDays(index),  
                TemperatureC = rng.Next(-20, 55),  
                Summary = Summaries[rng.Next(Summaries.Length)]  
            })  
            .ToArray();  
        }  
**logs of caller**  
  
api invoked05:46:25.286  
Doing work while waiting for response05:46:25.312  
Doing work after response05:46:30.562  
  
**logs of receiver**  
API request 05:46:25.502  
  
you can check API request time in receiver. It should be less than Doing work while waiting for response  time but in this case  it is greater.  

So API receive request after await statement not after postasync method

Answer 4

no. when you call an async routine, it is sync until it creates and returns a Task. in you api:

// still on the caller thread    
Console.WriteLine("API request "+DateTime.Now.ToString("hh:mm:ss.fff"));  
  
// create new Task and thread and return control to caller  
await Task.Delay(5000);  
  

this is why the api print happens before the print after the api call. for example:

// this is basically a sync method which will block the caller until it returns  
  
Task<bool> foo()   
{  
    for (I = 0; I < 100000; ++i)  
          ;  
    Console.WriteLine("done");  
    return Task.FromResult(true);  
}  
  
  

Answer 5

You misunderstand. Your code is functioning as expected. The problem is your code is not as resource efficient as possible.

public async Task<string> GetData()  
{  
    var client =  new HttpClientCall<WeatherForecast>(_configuration)      
    await client.PostRequest(_configuration["Services:Payperiod"],new WeatherForecast());    
}  

The async yields control to the caller which allows the caller to do other tasks while the GetData() finishes its processing. When GetData() is done it updates the Task<string> object it passed to the caller. Your code without the async causes the caller to go idle while it waits for GetData() to finish. That's what blocking means. It does not mean the API call is blocked.

Another way to say this is if you write proper async/await code your server can handle more requests.

The link in my prior post explains the mechanics.