使用异步/等待 - C#

Question

I have the following code. What exactly does the code do? Why do we need the Stopwatch , XmlSerializer , MemoryStream . Is there are simpler way of doing it using async/await ? Also does using contentResponse.Result; lead to a deadlock situation always.

    public T GetResponse<T>()
    {
        var response = default(T);

            using (HttpClient httpClient = new HttpClient())
            {
                httpClient.DefaultRequestHeaders.Add("Authorization", authHeader);

                Stopwatch watch = Stopwatch.StartNew();

                var contentResponse = httpClient.GetAsync(uri.ToString());

                try
                {
                    contentResponse.Wait();
                }
                catch (Exception exception)
                {

                }

                var wsResponseContent = contentResponse.Result;
                wsResponseContent.Content.LoadIntoBufferAsync();
                var resultTask = wsResponseContent.Content.ReadAsStringAsync();
                resultTask.Wait();

                string wsResponseContentText = resultTask.Result;

                if (watch.IsRunning)
                    watch.Stop();

                wsResponseContent.EnsureSuccessStatusCode();
                if (wsResponseContent.IsSuccessStatusCode)
                {
                    XmlSerializer result = new XmlSerializer(typeof(T));

                    using (MemoryStream sresultStream = new MemoryStream(Encoding.UTF8.GetBytes(wsResponseContentText)))
                    {
                        response = (T)result.Deserialize(sresultStream);
                        sresultStream.Close();
                    }
                }
            }
       
        return response;
    }

Answer 1

There is no need for the StopWatch in this code. Usually used as a diagnostic tool, it can be useful. But not in this instance. From the code below it seems that it reads a string send over the web and tries to read it as an XML format. Thus the need for the MemoryStream and XMLSerializer .

As for your deadlock situation. It is always because two instances is trying to access the same instance. You can avoid this by await your functions properyly. If oyu really want a proper async implement the function as follow:

public async Task<T> GetResponse<T>()
{
    var response = default(T);

    using (HttpClient httpClient = new HttpClient())
    {
        httpClient.DefaultRequestHeaders.Add("Authorization", authHeader);

        var contentResponse = await httpClient.GetAsync(uri.ToString());

        await wsResponseContent.Content.LoadIntoBufferAsync();
        var wsResponseContentText = await wsResponseContent.Content.ReadAsStringAsync();

        wsResponseContent.EnsureSuccessStatusCode();
        
        if (wsResponseContent.IsSuccessStatusCode)
        {
            XmlSerializer result = new XmlSerializer(typeof(T));

            using (MemoryStream sresultStream = new MemoryStream(Encoding.UTF8.GetBytes(wsResponseContentText)))
            {
                response = (T)result.Deserialize(sresultStream);
                sresultStream.Close();
             }
        }
    }
   
    return response;
}

In the above code if a function has async in it. We can await the result instead of the task. For example in the code below:

public async Task<int> GetNumber5Async() {
    return 5;
}

If we are to call it like you did before:

var number5 = GetNumber5Async(); // Returns Task<int>

We will receive back a Task we will need to get the results from. However, if we immediately await the Task:

var number5 = await GetNumber5Async(); // Returns 5

We immedaitely get the result back and don't have to do number5.Wait(); number5.result; number5.Wait(); number5.result;

---

Turtles all the way Down

One thing you will need know when working with Async Methods is the concept of 'Turtes all the way Down'. Simply what it says is if you have a async method anywhere, all your methods call it and calling those methods needs to be async as well. So what is needed for a method to be async?

1. In requires to be a Task . So instead of returning a value, it will need to return a Task with a value encapsulated.

For example:

// None Async
public int GetNumber5() { return 5;} 

// Async
public async Task<int> GetNumber5Async() { return 5; }

2. Requires the async descriptor to both use and call o be able to await a function.

For example:

// None Async
void GetANumber(){
    var num5 = GetNumber5();
}

// Async
async void GetANumber(){
    var num5 = await GetNumber5Async();
}

---

Avoiding Deadlocks with Async

Usually awaiting a function is engough. But if it still creates deadlocks you can add '.ConfigureAwait(false);'

For Example:

var num5 = await GetNumber5Async().ConfigureAwait(false);