Como: estende o passo a passo usando Task.WhenAll (C# e Visual Basic)

Você pode melhorar o desempenho de solução de async em Passo a passo: Acessando a Web usando Async e aguardar (C# e Visual Basic) usando o método de Task.WhenAll .Este método aguarda de forma assíncrona várias operações assíncronas, que são representadas como uma coleção de tarefas.

Você talvez tenha observado na explicação passo a passo que o download de sites em taxas diferentes.Às vezes um dos sites é muito lento, que todos atrasa downloads restantes.Quando você executa as soluções assíncronas que você criar nesta explicação passo a passo, você pode finalizar o programa facilmente se você não desejar esperar, mas uma opção melhor seria iniciar ao mesmo tempo todas as transferências e deixaria as transferências mais rápidas continuar sem esperar o que é atrasada.

Você aplica o método de Task.WhenAll a uma coleção de tarefas.O aplicativo de WhenAll retorna uma única tarefa que não está completo até que cada tarefa na coleção seja concluída.As tarefas aparecem para executar paralelamente, mas nenhum segmento adicional é criado.Tarefas podem executar em qualquer ordem.

Importante

Os procedimentos a seguir descrevem extensões para aplicativos de async que são desenvolvidos em Passo a passo: Acessando a Web usando Async e aguardar (C# e Visual Basic).Você pode desenvolver aplicativos concluir a explicação ou download do Exemplos de código do desenvolvedorcódigo. Para executar o exemplo, você deve ter o Visual Studio 2012 O Visual Studio express library 2012 para a área de trabalho do Windows, ou .NET Framework 4.5 instalado no seu computador.

Para adicionar Task.WhenAll a sua solução de GetURLContentsAsync

1. Adicione o método de ProcessURLAsync para o primeiro aplicativo que é desenvolvido em Passo a passo: Acessando a Web usando Async e aguardar (C# e Visual Basic).

   • Se você baixou o código do Exemplos de código do desenvolvedor, abra o projeto de AsyncWalkthrough em seguida, adicione ProcessURLAsync para o arquivo de MainWindow.xaml.vb ou de MainWindow.xaml.cs.

   • Se você desenvolveu o código concluir a explicação passo a passo, adicione ProcessURLAsync o aplicativo que inclui o método de GetURLContentsAsync .O arquivo de MainWindow.xaml.vb ou de MainWindow.xaml.cs para este aplicativo é o primeiro exemplo “exemplos de código completo na seção da explicação passo a passo.”

   O método ProcessURLAsync consolida as ações no corpo do loop For Each ou foreach em SumPageSizesAsync na explicação original.O método de forma assíncrona baixa o conteúdo de um site especificada como uma matriz de bytes, e então exibe e retorna o tamanho da matriz de bytes.

   Private Async Function ProcessURLAsync(url As String) As Task(Of Integer)
   
       Dim byteArray = Await GetURLContentsAsync(url)
       DisplayResults(url, byteArray)
       Return byteArray.Length
   End Function
   

   private async Task<int> ProcessURLAsync(string url)
   {
       var byteArray = await GetURLContentsAsync(url);
       DisplayResults(url, byteArray);
       return byteArray.Length;
   }
   

2. Comente ou exclua o loop For Each ou foreach em SumPageSizesAsync, como o código a seguir mostra.

   'Dim total = 0
   'For Each url In urlList
   
   '    Dim urlContents As Byte() = Await GetURLContentsAsync(url)
   
   '    ' The previous line abbreviates the following two assignment statements.
   
   '    ' GetURLContentsAsync returns a task. At completion, the task
   '    ' produces a byte array.
   '    'Dim getContentsTask As Task(Of Byte()) = GetURLContentsAsync(url)
   '    'Dim urlContents As Byte() = Await getContentsTask
   
   '    DisplayResults(url, urlContents)
   
   '    ' Update the total.
   '    total += urlContents.Length
   'Next
   

   //var total = 0;
   //foreach (var url in urlList)
   //{
   //    byte[] urlContents = await GetURLContentsAsync(url);
   
   //    // The previous line abbreviates the following two assignment statements.
   //    // GetURLContentsAsync returns a Task<T>. At completion, the task
   //    // produces a byte array.
   //    //Task<byte[]> getContentsTask = GetURLContentsAsync(url);
   //    //byte[] urlContents = await getContentsTask;
   
   //    DisplayResults(url, urlContents);
   
   //    // Update the total.          
   //    total += urlContents.Length;
   //}
   

3. Crie uma coleção de tarefas.O código a seguir define consulta que, quando executado pelo método de ToArray<TSource> , cria um conjunto de tarefas que baixar o conteúdo de cada site.As tarefas são iniciadas quando a consulta é avaliada.

   Adicione o seguinte código ao método SumPageSizesAsync após a declaração de urlList.

   ' Create a query. 
   Dim downloadTasksQuery As IEnumerable(Of Task(Of Integer)) =
       From url In urlList Select ProcessURLAsync(url)
   
   ' Use ToArray to execute the query and start the download tasks.
   Dim downloadTasks As Task(Of Integer)() = downloadTasksQuery.ToArray()
   

   // Create a query. 
   IEnumerable<Task<int>> downloadTasksQuery = 
       from url in urlList select ProcessURLAsync(url);
   
   // Use ToArray to execute the query and start the download tasks.
   Task<int>[] downloadTasks = downloadTasksQuery.ToArray();
   

4. Aplicar Task.WhenAll a coleção de tarefas, downloadTasks.Task.WhenAll retorna uma única tarefa que termina quando todas as tarefas na coleção de tarefas eles concluíram.

   No exemplo, a expressão de Await ou de await espera a conclusão de única tarefa que WhenAll retorna.A expressão avaliará como uma matriz de inteiros, onde cada inteiro é o comprimento de um site baixada.Adicione o seguinte código a SumPageSizesAsync, imediatamente após o código que você adicionou na etapa anterior.

   ' Await the completion of all the running tasks.
   Dim lengths As Integer() = Await Task.WhenAll(downloadTasks)
   
   '' The previous line is equivalent to the following two statements.
   'Dim whenAllTask As Task(Of Integer()) = Task.WhenAll(downloadTasks)
   'Dim lengths As Integer() = Await whenAllTask
   

   // Await the completion of all the running tasks.
   int[] lengths = await Task.WhenAll(downloadTasks);
   
   //// The previous line is equivalent to the following two statements.
   //Task<int[]> whenAllTask = Task.WhenAll(downloadTasks);
   //int[] lengths = await whenAllTask;
   

5. Finalmente, use o método de Sum para calcular a soma dos comprimentos de todos os sites.Adicione a seguinte linha para SumPageSizesAsync.

   Dim total = lengths.Sum()
   

   int total = lengths.Sum();
   

Para adicionar Task.WhenAll à solução de HttpClient.GetByteArrayAsync

1. Adicione a seguinte versão de ProcessURLAsync o segundo aplicativo que é desenvolvido em Passo a passo: Acessando a Web usando Async e aguardar (C# e Visual Basic).

   • Se você baixou o código do Exemplos de código do desenvolvedor, abra o projeto de AsyncWalkthrough_HttpClient em seguida, adicione ProcessURLAsync para o arquivo de MainWindow.xaml.vb ou de MainWindow.xaml.cs.

   • Se você desenvolveu o código concluir a explicação passo a passo, adicione ProcessURLAsync o aplicativo que usa o método de HttpClient.GetByteArrayAsync .O arquivo de MainWindow.xaml.vb ou de MainWindow.xaml.cs para este aplicativo é o segundo exemplo “exemplos de código completo na seção da explicação passo a passo.”

   O método ProcessURLAsync consolida as ações no corpo do loop For Each ou foreach em SumPageSizesAsync na explicação original.O método de forma assíncrona baixa o conteúdo de um site especificada como uma matriz de bytes, e então exibe e retorna o tamanho da matriz de bytes.

   A única diferença do método de ProcessURLAsync no procedimento anterior é o uso de instância de HttpClient , client.

   Private Async Function ProcessURLAsync(url As String, client As HttpClient) As Task(Of Integer)
   
       Dim byteArray = Await client.GetByteArrayAsync(url)
       DisplayResults(url, byteArray)
       Return byteArray.Length
   End Function
   

   async Task<int> ProcessURL(string url, HttpClient client)
   {
       byte[] byteArray = await client.GetByteArrayAsync(url);
       DisplayResults(url, byteArray);
       return byteArray.Length;
   }
   

2. Comente ou exclua o loop For Each ou foreach em SumPageSizesAsync, como o código a seguir mostra.

   'Dim total = 0
   'For Each url In urlList
   '    ' GetByteArrayAsync returns a task. At completion, the task
   '    ' produces a byte array.
   '    Dim urlContents As Byte() = Await client.GetByteArrayAsync(url)
   
   '    ' The following two lines can replace the previous assignment statement.
   '    'Dim getContentsTask As Task(Of Byte()) = client.GetByteArrayAsync(url)
   '    'Dim urlContents As Byte() = Await getContentsTask
   
   '    DisplayResults(url, urlContents)
   
   '    ' Update the total.
   '    total += urlContents.Length
   'Next
   

   //var total = 0;
   //foreach (var url in urlList)
   //{
   //    // GetByteArrayAsync returns a Task<T>. At completion, the task
   //    // produces a byte array.
   //    byte[] urlContent = await client.GetByteArrayAsync(url);
   
   //    // The previous line abbreviates the following two assignment
   //    // statements.
   //    Task<byte[]> getContentTask = client.GetByteArrayAsync(url);
   //    byte[] urlContent = await getContentTask;
   
   //    DisplayResults(url, urlContent);
   
   //    // Update the total.
   //    total += urlContent.Length;
   //}
   

3. Defina consulta que, quando executado pelo método de ToArray<TSource> , cria um conjunto de tarefas que baixar o conteúdo de cada site.As tarefas são iniciadas quando a consulta é avaliada.

   Adicione o seguinte código ao método SumPageSizesAsync após a declaração de client e de urlList.

   ' Create a query.
   Dim downloadTasksQuery As IEnumerable(Of Task(Of Integer)) =
       From url In urlList Select ProcessURLAsync(url, client)
   
   ' Use ToArray to execute the query and start the download tasks.
   Dim downloadTasks As Task(Of Integer)() = downloadTasksQuery.ToArray()
   

   // Create a query.
   IEnumerable<Task<int>> downloadTasksQuery = 
       from url in urlList select ProcessURL(url, client);
   
   // Use ToArray to execute the query and start the download tasks.
   Task<int>[] downloadTasks = downloadTasksQuery.ToArray();
   

4. Em seguida, aplica Task.WhenAll a coleção de tarefas, downloadTasks.Task.WhenAll retorna uma única tarefa que termina quando todas as tarefas na coleção de tarefas eles concluíram.

   No exemplo, a expressão de Await ou de await espera a conclusão de única tarefa que WhenAll retorna.Quando completo, Await ou a expressão de await avaliada como uma matriz de inteiros, onde cada inteiro é o comprimento de um site baixada.Adicione o seguinte código a SumPageSizesAsync, imediatamente após o código que você adicionou na etapa anterior.

   ' Await the completion of all the running tasks.
   Dim lengths As Integer() = Await Task.WhenAll(downloadTasks)
   
   '' The previous line is equivalent to the following two statements.
   'Dim whenAllTask As Task(Of Integer()) = Task.WhenAll(downloadTasks)
   'Dim lengths As Integer() = Await whenAllTask
   

   // Await the completion of all the running tasks.
   int[] lengths = await Task.WhenAll(downloadTasks);
   
   //// The previous line is equivalent to the following two statements.
   //Task<int[]> whenAllTask = Task.WhenAll(downloadTasks);
   //int[] lengths = await whenAllTask;
   

5. Finalmente, use o método de Sum para obter a soma dos comprimentos de todos os sites.Adicione a seguinte linha para SumPageSizesAsync.

   Dim total = lengths.Sum()
   

   int total = lengths.Sum();
   

Para testar as soluções de Task.WhenAll

• Para qualquer solução, escolha a tecla F5 para executar o programa, e então escolha o botão de Iniciar .A saída deve se parecer com a saída de soluções de async em Passo a passo: Acessando a Web usando Async e aguardar (C# e Visual Basic).No entanto, observe que os sites aparecem em uma ordem diferente cada vez.

Exemplo

O código a seguir mostra as extensões para o projeto que usa o método de GetURLContentsAsync para baixar conteúdo da Web.

' Add the following Imports statements, and add a reference for System.Net.Http.
Imports System.Net.Http
Imports System.Net
Imports System.IO


Class MainWindow

    Async Sub startButton_Click(sender As Object, e As RoutedEventArgs) Handles startButton.Click

        resultsTextBox.Clear()

        ' One-step async call.
        Await SumPageSizesAsync()

        '' Two-step async call.
        'Dim sumTask As Task = SumPageSizesAsync()
        'Await sumTask

        resultsTextBox.Text &= vbCrLf & "Control returned to button1_Click."
    End Sub


    Private Async Function SumPageSizesAsync() As Task

        ' Make a list of web addresses.
        Dim urlList As List(Of String) = SetUpURLList()

        ' Create a query. 
        Dim downloadTasksQuery As IEnumerable(Of Task(Of Integer)) =
            From url In urlList Select ProcessURLAsync(url)

        ' Use ToArray to execute the query and start the download tasks.
        Dim downloadTasks As Task(Of Integer)() = downloadTasksQuery.ToArray()

        ' You can do other work here before awaiting.

        ' Await the completion of all the running tasks.
        Dim lengths As Integer() = Await Task.WhenAll(downloadTasks)

        '' The previous line is equivalent to the following two statements.
        'Dim whenAllTask As Task(Of Integer()) = Task.WhenAll(downloadTasks)
        'Dim lengths As Integer() = Await whenAllTask

        Dim total = lengths.Sum()

        'Dim total = 0
        'For Each url In urlList

        '    Dim urlContents As Byte() = Await GetURLContentsAsync(url)

        '    ' The previous line abbreviates the following two assignment statements.

        '    ' GetURLContentsAsync returns a task. At completion, the task
        '    ' produces a byte array.
        '    'Dim getContentsTask As Task(Of Byte()) = GetURLContentsAsync(url)
        '    'Dim urlContents As Byte() = Await getContentsTask

        '    DisplayResults(url, urlContents)

        '    ' Update the total.
        '    total += urlContents.Length
        'Next

        ' Display the total count for all of the web addresses.
        resultsTextBox.Text &= String.Format(vbCrLf & vbCrLf &
                                             "Total bytes returned:  {0}" & vbCrLf, total)
    End Function


    Private Function SetUpURLList() As List(Of String)

        Dim urls = New List(Of String) From
            {
                "https://msdn.microsoft.com",
                "https://msdn.microsoft.com/en-us/library/hh290136.aspx",
                "https://msdn.microsoft.com/en-us/library/ee256749.aspx",
                "https://msdn.microsoft.com/en-us/library/hh290138.aspx",
                "https://msdn.microsoft.com/en-us/library/hh290140.aspx",
                "https://msdn.microsoft.com/en-us/library/dd470362.aspx",
                "https://msdn.microsoft.com/en-us/library/aa578028.aspx",
                "https://msdn.microsoft.com/en-us/library/ms404677.aspx",
                "https://msdn.microsoft.com/en-us/library/ff730837.aspx"
            }
        Return urls
    End Function


    ' The actions from the foreach loop are moved to this async method.
    Private Async Function ProcessURLAsync(url As String) As Task(Of Integer)

        Dim byteArray = Await GetURLContentsAsync(url)
        DisplayResults(url, byteArray)
        Return byteArray.Length
    End Function


    Private Async Function GetURLContentsAsync(url As String) As Task(Of Byte())

        ' The downloaded resource ends up in the variable named content.
        Dim content = New MemoryStream()

        ' Initialize an HttpWebRequest for the current URL.
        Dim webReq = CType(WebRequest.Create(url), HttpWebRequest)

        ' Send the request to the Internet resource and wait for
        ' the response.
        Using response As WebResponse = Await webReq.GetResponseAsync()
            ' Get the data stream that is associated with the specified URL.
            Using responseStream As Stream = response.GetResponseStream()
                ' Read the bytes in responseStream and copy them to content.  
                ' CopyToAsync returns a Task, not a Task<T>.
                Await responseStream.CopyToAsync(content)
            End Using
        End Using

        ' Return the result as a byte array.
        Return content.ToArray()
    End Function



    Private Sub DisplayResults(url As String, content As Byte())

        ' Display the length of each website. The string format 
        ' is designed to be used with a monospaced font, such as
        ' Lucida Console or Global Monospace.
        Dim bytes = content.Length
        ' Strip off the "http://".
        Dim displayURL = url.Replace("http://", "")
        resultsTextBox.Text &= String.Format(vbCrLf & "{0,-58} {1,8}", displayURL, bytes)
    End Sub

End Class

// Add the following using directives, and add a reference for System.Net.Http.
using System.Net.Http;
using System.IO;
using System.Net;

namespace AsyncExampleWPF_WhenAll
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }


        private async void startButton_Click(object sender, RoutedEventArgs e)
        {
            resultsTextBox.Clear();

            // Two-step async call.
            Task sumTask = SumPageSizesAsync();
            await sumTask;

            // One-step async call.
            //await SumPageSizesAsync();

            resultsTextBox.Text += "\r\nControl returned to startButton_Click.\r\n";
        }


        private async Task SumPageSizesAsync()
        {
            // Make a list of web addresses.
            List<string> urlList = SetUpURLList();

            // Create a query. 
            IEnumerable<Task<int>> downloadTasksQuery = 
                from url in urlList select ProcessURLAsync(url);

            // Use ToArray to execute the query and start the download tasks.
            Task<int>[] downloadTasks = downloadTasksQuery.ToArray();

            // You can do other work here before awaiting.

            // Await the completion of all the running tasks.
            int[] lengths = await Task.WhenAll(downloadTasks);

            //// The previous line is equivalent to the following two statements.
            //Task<int[]> whenAllTask = Task.WhenAll(downloadTasks);
            //int[] lengths = await whenAllTask;

            int total = lengths.Sum();

            //var total = 0;
            //foreach (var url in urlList)
            //{
            //    byte[] urlContents = await GetURLContentsAsync(url);

            //    // The previous line abbreviates the following two assignment statements.
            //    // GetURLContentsAsync returns a Task<T>. At completion, the task
            //    // produces a byte array.
            //    //Task<byte[]> getContentsTask = GetURLContentsAsync(url);
            //    //byte[] urlContents = await getContentsTask;

            //    DisplayResults(url, urlContents);

            //    // Update the total.          
            //    total += urlContents.Length;
            //}

            // Display the total count for all of the websites.
            resultsTextBox.Text +=
                string.Format("\r\n\r\nTotal bytes returned:  {0}\r\n", total);
        }


        private List<string> SetUpURLList()
        {
            List<string> urls = new List<string> 
            { 
                "https://msdn.microsoft.com",
                "https://msdn.microsoft.com/library/windows/apps/br211380.aspx",
                "https://msdn.microsoft.com/en-us/library/hh290136.aspx",
                "https://msdn.microsoft.com/en-us/library/ee256749.aspx",
                "https://msdn.microsoft.com/en-us/library/hh290138.aspx",
                "https://msdn.microsoft.com/en-us/library/hh290140.aspx",
                "https://msdn.microsoft.com/en-us/library/dd470362.aspx",
                "https://msdn.microsoft.com/en-us/library/aa578028.aspx",
                "https://msdn.microsoft.com/en-us/library/ms404677.aspx",
                "https://msdn.microsoft.com/en-us/library/ff730837.aspx"
            };
            return urls;
        }



        // The actions from the foreach loop are moved to this async method.
        private async Task<int> ProcessURLAsync(string url)
        {
            var byteArray = await GetURLContentsAsync(url);
            DisplayResults(url, byteArray);
            return byteArray.Length;
        }


        private async Task<byte[]> GetURLContentsAsync(string url)
        {
            // The downloaded resource ends up in the variable named content.
            var content = new MemoryStream();

            // Initialize an HttpWebRequest for the current URL.
            var webReq = (HttpWebRequest)WebRequest.Create(url);

            // Send the request to the Internet resource and wait for
            // the response.
            using (WebResponse response = await webReq.GetResponseAsync())
            {
                // Get the data stream that is associated with the specified url.
                using (Stream responseStream = response.GetResponseStream())
                {
                    await responseStream.CopyToAsync(content);
                }
            }

            // Return the result as a byte array.
            return content.ToArray();

        }


        private void DisplayResults(string url, byte[] content)
        {
            // Display the length of each website. The string format 
            // is designed to be used with a monospaced font, such as
            // Lucida Console or Global Monospace.
            var bytes = content.Length;
            // Strip off the "http://".
            var displayURL = url.Replace("http://", "");
            resultsTextBox.Text += string.Format("\n{0,-58} {1,8}", displayURL, bytes);

        }
    }
}

O código a seguir mostra as extensões para o projeto que usa o método HttpClient.GetByteArrayAsync para baixar conteúdo da Web.

' Add the following Imports statements, and add a reference for System.Net.Http.
Imports System.Net.Http
Imports System.Net
Imports System.IO

Class MainWindow

    Async Sub startButton_Click(sender As Object, e As RoutedEventArgs) Handles startButton.Click

        resultsTextBox.Clear()

        '' One-step async call.
        Await SumPageSizesAsync()

        '' Two-step async call.
        'Dim sumTask As Task = SumPageSizesAsync()
        'Await sumTask

        resultsTextBox.Text &= vbCrLf & "Control returned to button1_Click."
    End Sub


    Private Async Function SumPageSizesAsync() As Task

        ' Declare an HttpClient object and increase the buffer size. The
        ' default buffer size is 65,536.
        Dim client As HttpClient =
            New HttpClient() With {.MaxResponseContentBufferSize = 1000000}

        ' Make a list of web addresses.
        Dim urlList As List(Of String) = SetUpURLList()

        ' Create a query.
        Dim downloadTasksQuery As IEnumerable(Of Task(Of Integer)) =
            From url In urlList Select ProcessURLAsync(url, client)

        ' Use ToArray to execute the query and start the download tasks.
        Dim downloadTasks As Task(Of Integer)() = downloadTasksQuery.ToArray()

        ' You can do other work here before awaiting.

        ' Await the completion of all the running tasks.
        Dim lengths As Integer() = Await Task.WhenAll(downloadTasks)

        '' The previous line is equivalent to the following two statements.
        'Dim whenAllTask As Task(Of Integer()) = Task.WhenAll(downloadTasks)
        'Dim lengths As Integer() = Await whenAllTask

        Dim total = lengths.Sum()

        'Dim total = 0
        'For Each url In urlList
        '    ' GetByteArrayAsync returns a task. At completion, the task
        '    ' produces a byte array.
        '    Dim urlContents As Byte() = Await client.GetByteArrayAsync(url)

        '    ' The following two lines can replace the previous assignment statement.
        '    'Dim getContentsTask As Task(Of Byte()) = client.GetByteArrayAsync(url)
        '    'Dim urlContents As Byte() = Await getContentsTask

        '    DisplayResults(url, urlContents)

        '    ' Update the total.
        '    total += urlContents.Length
        'Next

        ' Display the total count for all of the web addresses.
        resultsTextBox.Text &= String.Format(vbCrLf & vbCrLf &
                                             "Total bytes returned:  {0}" & vbCrLf, total)
    End Function


    Private Function SetUpURLList() As List(Of String)

        Dim urls = New List(Of String) From
            {
                "http://www.msdn.com",
                "https://msdn.microsoft.com/en-us/library/hh290136.aspx",
                "https://msdn.microsoft.com/en-us/library/ee256749.aspx",
                "https://msdn.microsoft.com/en-us/library/hh290138.aspx",
                "https://msdn.microsoft.com/en-us/library/hh290140.aspx",
                "https://msdn.microsoft.com/en-us/library/dd470362.aspx",
                "https://msdn.microsoft.com/en-us/library/aa578028.aspx",
                "https://msdn.microsoft.com/en-us/library/ms404677.aspx",
                "https://msdn.microsoft.com/en-us/library/ff730837.aspx"
            }
        Return urls
    End Function

    Private Async Function ProcessURLAsync(url As String, client As HttpClient) As Task(Of Integer)

        Dim byteArray = Await client.GetByteArrayAsync(url)
        DisplayResults(url, byteArray)
        Return byteArray.Length
    End Function


    Private Sub DisplayResults(url As String, content As Byte())

        ' Display the length of each website. The string format 
        ' is designed to be used with a monospaced font, such as
        ' Lucida Console or Global Monospace.
        Dim bytes = content.Length
        ' Strip off the "http://".
        Dim displayURL = url.Replace("http://", "")
        resultsTextBox.Text &= String.Format(vbCrLf & "{0,-58} {1,8}", displayURL, bytes)
    End Sub

End Class

// Add the following using directives, and add a reference for System.Net.Http.
using System.Net.Http;
using System.IO;
using System.Net;

namespace AsyncExampleWPF_HttpClient_WhenAll
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private async void startButton_Click(object sender, RoutedEventArgs e)
        {
            resultsTextBox.Clear();

            // One-step async call.
            await SumPageSizesAsync();

            // Two-step async call.
            //Task sumTask = SumPageSizesAsync();
            //await sumTask;

            resultsTextBox.Text += "\r\nControl returned to startButton_Click.\r\n";
        }


        private async Task SumPageSizesAsync()
        {
            // Make a list of web addresses.
            List<string> urlList = SetUpURLList();


            // Declare an HttpClient object and increase the buffer size. The
            // default buffer size is 65,536.
            HttpClient client = new HttpClient() { MaxResponseContentBufferSize = 1000000 };

            // Create a query.
            IEnumerable<Task<int>> downloadTasksQuery = 
                from url in urlList select ProcessURL(url, client);

            // Use ToArray to execute the query and start the download tasks.
            Task<int>[] downloadTasks = downloadTasksQuery.ToArray();

            // You can do other work here before awaiting.

            // Await the completion of all the running tasks.
            int[] lengths = await Task.WhenAll(downloadTasks);

            //// The previous line is equivalent to the following two statements.
            //Task<int[]> whenAllTask = Task.WhenAll(downloadTasks);
            //int[] lengths = await whenAllTask;

            int total = lengths.Sum();

            //var total = 0;
            //foreach (var url in urlList)
            //{
            //    // GetByteArrayAsync returns a Task<T>. At completion, the task
            //    // produces a byte array.
            //    byte[] urlContent = await client.GetByteArrayAsync(url);

            //    // The previous line abbreviates the following two assignment
            //    // statements.
            //    Task<byte[]> getContentTask = client.GetByteArrayAsync(url);
            //    byte[] urlContent = await getContentTask;

            //    DisplayResults(url, urlContent);

            //    // Update the total.
            //    total += urlContent.Length;
            //}

            // Display the total count for all of the web addresses.
            resultsTextBox.Text +=
                string.Format("\r\n\r\nTotal bytes returned:  {0}\r\n", total);
        }


        private List<string> SetUpURLList()
        {
            List<string> urls = new List<string> 
            { 
                "https://msdn.microsoft.com",
                "https://msdn.microsoft.com/en-us/library/hh290136.aspx",
                "https://msdn.microsoft.com/en-us/library/ee256749.aspx",
                "https://msdn.microsoft.com/en-us/library/hh290138.aspx",
                "https://msdn.microsoft.com/en-us/library/hh290140.aspx",
                "https://msdn.microsoft.com/en-us/library/dd470362.aspx",
                "https://msdn.microsoft.com/en-us/library/aa578028.aspx",
                "https://msdn.microsoft.com/en-us/library/ms404677.aspx",
                "https://msdn.microsoft.com/en-us/library/ff730837.aspx"
            };
            return urls;
        }


        // The actions from the foreach loop are moved to this async method.
        async Task<int> ProcessURL(string url, HttpClient client)
        {
            byte[] byteArray = await client.GetByteArrayAsync(url);
            DisplayResults(url, byteArray);
            return byteArray.Length;
        }


        private void DisplayResults(string url, byte[] content)
        {
            // Display the length of each web site. The string format 
            // is designed to be used with a monospaced font, such as
            // Lucida Console or Global Monospace.
            var bytes = content.Length;
            // Strip off the "http://".
            var displayURL = url.Replace("http://", "");
            resultsTextBox.Text += string.Format("\n{0,-58} {1,8}", displayURL, bytes);
        }
    }
}

Consulte também

Tarefas

Passo a passo: Acessando a Web usando Async e aguardar (C# e Visual Basic)

Referência

Task.WhenAll