同步请求资源

请求msdn上的一个页面计算页面大小

static void Main(string[] args)

{

    string url = "https://docs.microsoft.com/zh-cn/dotnet/core/api/system";

    try

    {

        WebRequest request = WebRequest.Create(url);

        WebResponse response = request.GetResponse();

        using (var reader = new StreamReader(response.GetResponseStream()))

        {

            string text = reader.ReadToEnd();

            Console.WriteLine(FormatBytes(text.Length));

        }

    }

    catch (WebException e)

    {

    }

    catch (IOException e)

    {

    }

    catch (NotSupportedException e)

    {

    }

}

static string FormatBytes(long bytes)

{

    string[] magnitudes = new string[] { "GB", "MB", "KB", "Bytes" };

    long max = (long)Math.Pow(, magnitudes.Length);

    var t1 = magnitudes.FirstOrDefault(magnitude => bytes > (max /= )) ?? "0 Bytes";

    var t2 = ((decimal)bytes / (decimal)max);

    return string.Format("{1:##.##} {0}", t1, t2).Trim();

}

Ctrl+F5输出

同步 VS 异步

闪烁两下后

同步 VS 异步

这里对资源的请求都是同步的,通俗易懂点就是一个步骤一个步骤的执行,任何一个步骤耗时较长都会阻塞上下文线程(这里就是主线程)

使用C#5.0异步请求资源

static void Main(string[] args)

{

    string url = "https://docs.microsoft.com/zh-cn/dotnet/core/api/system";

    Task task = WriteWebRequestSizeAsync(url);

    while (!task.Wait())

    {

        Console.Write(".");

    }

}

static async Task WriteWebRequestSizeAsync(string url)

{

    try

    {

        WebRequest request = WebRequest.Create(url);

        WebResponse response = await request.GetResponseAsync();

        using (var reader = new StreamReader(response.GetResponseStream()))

        {

            string text = await reader.ReadToEndAsync();

            Console.WriteLine(FormatBytes(text.Length));

        }

    }

    catch (WebException)

    {

    }

    //省略了一些catch块

}

这种写法在MVC中早就熟悉了,但是原理确不是很清楚,只知道这样不会阻塞UI,async方法会创建一个新的线程执行,await会阻塞上下文线程,一知半解隐藏着很可怕定时炸弹!

TPL异步调用

static void Main(string[] args)

{

    string url = "https://docs.microsoft.com/zh-cn/dotnet/core/api/system";

    Task task = WriteWebRequestSizeAsync(url);

    try

    {

        while (!task.Wait())

        {

            Console.Write(".");

        }

    }

    catch (AggregateException excetion)

    {

        excetion = excetion.Flatten();

        try

        {

            excetion.Handle(innerExcetion =>

            {

                ExceptionDispatchInfo.Capture(excetion.InnerException).Throw();

                return true;

            });

        }

        catch (WebException ex)

        {

        }

        //省略了一些catch块

    }

}

static Task WriteWebRequestSizeAsync(string url)

{

    StreamReader reader = null;

    WebRequest request = WebRequest.Create(url);

    Task task = request.GetResponseAsync()

        .ContinueWith(antecedent =>

        {

            WebResponse response = antecedent.Result;

            reader = new StreamReader(response.GetResponseStream());

            return reader.ReadToEndAsync();

        })

        .Unwrap()

        .ContinueWith(antecedent =>

        {

            if (null != reader)

                reader.Dispose();

            string text = antecedent.Result;

            Console.WriteLine(FormatBytes(text.Length));

        });

    return task;

}

这个写法是在没有C#5.0之前,异步请求资源就是这么完成的,乍一看非常复杂,但是比较一下上面一种写法,它似乎是思路清晰的

1.request.GetResponseAsync创建一个任务等待msdn服务器的响应

2.拿到这个响应后,获得响应流,将流转为字符串

3.接下来是Unwrap,这个应该是最难理解的了,实际上只有加上这句话以ContinueWith的思路写下去,下一步就是直接拿string了

4.最后流已经转为字符串了,我们做个简单的计算就行了

Unwrap的奥义

public static Task<TResult> Unwrap<TResult>(this Task<Task<TResult>> task);

从签名上来看,它是一个Task<Task<TResult>>类型的拓展方法,任务,带返回值的任务...晕了,别急,等下慢慢来

回到刚刚代码看看有什么端倪

1.GetResponseAsync()创建(意思和返回值一样,为了区分任务返回值)一个任务,具体类型Task<WebResponse>,这个任务结束返回一个WebResponse

同步 VS 异步

2.第一个ContinueWith调用者是一个Task<WebResponse>,形参是一个委托接受一个Task<WebReponse>,返回一个Task<string>(通过reader.ReadToEndAsync可以理解),返回值是一个Task没有问题,问题在它的泛型参数是什么,首先此处ContinueWith中的代码是在一个新的工作线程中运行的,我们把它想象成主线程(只是相对的一个环境),'主线程'要完成什么任务呢?,他要拿Task<WebResponse>的执行结果WebResponse(虽然这里可以肯定这个任务已经执行完成了,但是微软没有这么做),然后根据这个WebResponse在创建一个Task<string>,作为当前工作线程的返回值

同步 VS 异步

3.现在问题来了,我们得到的是一个Task<Task<string>>,我们可以通过调用两次Result获取这个string,但是在这个ContinueWith块中,只能保证外层的Task是执行完成的,所以第二个Result或阻塞上下文线程

Task task = request.GetResponseAsync()

    .ContinueWith(antecedent =>

    {

        WebResponse response = antecedent.Result;

        reader = new StreamReader(response.GetResponseStream());

        return reader.ReadToEndAsync();

    })

    .ContinueWith(antecedent =>

    {

        var resTask = antecedent.Result;

        var resString = resTask.Result;

        if (null != reader)

        {

            string text = resString;

            Console.WriteLine(FormatBytes(text.Length));

        }

    });