当看起来毫无意义时，为什么作者使用ContinueWith（）和异步方法变体

Question

I've been reading Essential C# 6.0 recently. In the chapter of the book where author explains multi threading he shows this method and I don't understand two things about it which don't seem to be explained anywhere.

private static Task WriteWebRequestSizeAsync(string url)
{
    StreamReader reader = null;
    WebRequest webRequest = WebRequest.Create(url);

    Task task = webRequest.GetResponseAsync()
        .ContinueWith(antecedent =>
        {
            WebResponse response = antecedent.Result;
            reader = new StreamReader(response.GetResponseStream());
            return reader.ReadToEndAsync();
        })
        .Unwrap()
        .ContinueWith(antecedent =>
        {
            if(reader != null) reader.Dispose();
            string text = antecedent.Result;
            Console.WriteLine(text.Length);
        });
    return task;
}

1. Why does the author use ContinueWith() methods and calls them essential ? How is his way of doing it better than my approach, which does not utilize these methods?

private static Task WriteWebRequestSizeAsync(string url)
{
    return Task.Run(() =>
    {
        WebRequest webRequest = WebRequest.Create(url);
        WebResponse response = webRequest.GetResponseAsync().Result;
        using (StreamReader reader = new StreamReader(response.GetResponseStream()))
        {
            string text = reader.ReadToEndAsync().Result;
            Console.WriteLine(text.Length);
        }
    });
}

2. Why does the author use async variants of the methods and then access their result via .Result property, instead of using not async variants as it appears to have the same result at the end. Please, notice that I haven't changed it in my approach above

Answer 1

Although you are calling GetResponseAsync() in your method, however, trying to use .Result makes it a blocking call.As a result of this your task continues to wait for the result to be available wasting cpu cycles.

WebResponse response = webRequest.GetResponseAsync().Result; //blocking call

However, in the example by author, GetResponseAsync() is followed by a ContinueWith(). This means that Task on which GetResponseAsync() is called won't be blocked and can be utilized to do something else. When the result of GetResponseAsync() is available the continuation will run.

 webRequest.GetResponseAsync()
        .ContinueWith(antecedent =>
        {
            WebResponse response = antecedent.Result;
            reader = new StreamReader(response.GetResponseStream());
            return reader.ReadToEndAsync();
        })

Same example can also be written using async and await instead of continuation...This will have a similar effect of continuations . However, this will be more natural to read.

var result = await webRequest.GetResponseAsync();
//do something with result now.

Answer 2

似乎作者使用了堆叠的连续性，以便根据关注点分离原则拆分操作。

Answer 3

Main difference between yours and authors way is that author runs code in the same thread from what method WriteWebRequestSizeAsync while your code will run in some thread from ThreadPull. I don't know context so may be it's essential. About second question. If author calls not async methods he could not get tasks and attach to them ContinueWith .