如何在C＃中使用异步和等待？

Question

Here I'm checking for propertie if it is Migrated or In-Progress, If In-Progress then I do not want to wait for Web Response message from supplied URL so HttpPost method should run in Background and calling method should perform its task simultaneously. To acheive this functionality I used async and await in below methods.

Below is the method to Post and Get XML Response back from URL:

public static async Task<string> HttpPost(string url, string message, bool ignoreResponse = false)
{
    string lcPostData = null;
    string _XmlResponse = string.Empty;
    try
    {            
        using (var client = new HttpClient())
        {
            var httpContent = new StringContent(message, Encoding.UTF8, "application/xml");
            var SupplierLinkUri = new Uri(url);

            if (!ignoreResponse)
            {                    
                var httpResponseMessage = await client.PostAsync(SupplierLinkUri, httpContent);

                if (httpResponseMessage.StatusCode == HttpStatusCode.OK)
                    _XmlResponse =  httpResponseMessage.Content.ReadAsStringAsync().Result;
            }
            else if (ignoreResponse && !(isReservation(message)))   //message.Contains("Reservation"))
            {       
                /* I want below lines of code to run asynchronously (i.e. Run in background) So I used Task & await but it fails*/
                Task<HttpResponseMessage> httpPostTask = client.PostAsync(SupplierLinkUri, httpContent);
                HttpResponseMessage asyncPost = await httpPostTask;                 
            }
        }       
    }
    catch (Exception e)
    {       
    }
    return _XmlResponse;
}

The above method IS running without errors but I want to know whether this is a right approach to use async and await in C#, Should I need to modify my code anywhere or it is correct as per mentioned requirements?

await in else-if part is not working. As per documentation this should run asynchronously ie in background but currently it is not.

Can anyone please check and suggest what is wrong in the code?

Is their any better way to achieve this?

Appreciate any suggestions and Ideas! Thanks for the help!

Answer 1

OK - this is not what async/await are for - when you await, the method you call is run on another thread (not the UI thread), and will return control to your main method (via a continuation in the background) when it is complete.

The method where you 'await' will not return its result until the async call is complete.

eg

async Task<int> A()
{
    return await B();
}

async Task<int> B()
{
     //Call to a long running service to get your answer, e.g.
    return  await PostToClientAsynchronously();
}

//Event handler on front end.
async void SomeButton_Click() {
    txtBox1.Text = await A();
}

In the example above, the PostToClientAsynchronously will run on another thread (not the UI thread), but control will not return to set the textbox value in the event handler until after the post has completed.

I'd like to post an example for your own code, but to be perfectly honest, I'm not sure exactly what it is you want to do. I suspect that the issue may be solved by extending the async methods to your UI, thus not blocking it and allowing other operations, but I'm not sure.

The other important thing about calling async/await methods is that all the methods (from the front end down), need to be marked as async, to permit correct awaiting.

---

It sounds like you are trying to run these as 'fire and forget' type methods, but these are only really any good when what you are doing does not return information that you subsequently need to act upon and where you are sure that any exceptions that may happen will not hurt your application. Any exceptions encountered will not bubble back up to your application.

True fire and forget use cases are rare.

---

More information on why it must be 'turtles all the way down' when async programming:

https://msdn.microsoft.com/en-us/magazine/jj991977.aspx

More information about fire and forget (making sure you read the section on 'avoid async void' in the previous article:

Fire and Forget approach