Procedura: estendere la procedura dettagliata tramite Task.WhenAll (C# e Visual Basic)

È possibile migliorare le prestazioni della soluzione async in Procedura dettagliata: accesso al Web tramite Async e Await (C# e Visual Basic) tramite il metodo Task.WhenAll.Questo metodo in modo asincrono è in attesa di più operazioni asincrone, rappresentate come raccolta di attività.

È possibile notare nella procedura dettagliata che i siti web scaricano a velocità diverse.Talvolta uno dei siti Web può essere molto lento, che ritarda tutti i download rimanenti.Quando si eseguono le soluzioni asincrone compilate nella procedura dettagliata, è possibile terminare il programma facilmente se non si desidera attendere, ma una migliore soluzione consiste nell'avviare tutti i download contemporaneamente e consentire ai download più veloci di continuare senza attendere quelli che ritardano.

Applicare il metodo Task.WhenAll a una raccolta di attività.L'applicazione WhenAll restituisce una singola attività che non viene completata fino al completamento di ogni attività nella raccolta.Le attività sembrano venire eseguite in parallelo, ma in modo implicito: non viene creato nessun thread aggiuntivo.Le attività possono essere completate in qualsiasi ordine.

Importante

Le procedure riportate di seguito vengono descritte le estensioni alle applicazioni async compilate in Procedura dettagliata: accesso al Web tramite Async e Await (C# e Visual Basic).È possibile compilare applicazioni completare la procedura dettagliata o scaricando il codice da Esempi di codice dello sviluppatore. Per eseguire l'esempio, è necessario che Visual Studio 2012 Visual Studio express 2012 per Windows Desktop, o .NET Framework 4,5 installato nel computer.

Per aggiungere Task.WhenAll alla soluzione di GetURLContentsAsync

1. Aggiungere il metodo di ProcessURLAsync la prima applicazione compilata in Procedura dettagliata: accesso al Web tramite Async e Await (C# e Visual Basic).

   • Se è stato scaricato il codice da Esempi di codice dello sviluppatore, aprire il progetto AsyncWalkthrough quindi aggiungere ProcessURLAsync al file MainWindow.xaml.cs o MainWindow.xaml.vb.

   • Se elaboraste il codice eseguendo la procedura dettagliata, aggiungere ProcessURLAsyncapplicazione che include il metodo di GetURLContentsAsync.Il file MainWindow.xaml.cs o MainWindow.xaml.vb per questa applicazione è il primo esempio "esempi di codice completo nella sezione della procedura dettagliata".

   Il metodo di ProcessURLAsync consolida azioni nel corpo del ciclo di foreach o di For Each in SumPageSizesAsync nella procedura dettagliata originale.Il metodo in modo asincrono scarica il contenuto di un sito Web specificato come una array di byte e quindi visualizza e restituisce la lunghezza dell'array di byte.

   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. Impostare come commento o eliminare il ciclo foreach o For Each in SumPageSizesAsync, come illustrato nel codice.

   '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. Creare una raccolta di eventi.Il codice seguente definisce la query che, se eseguita con il metodo ToArray<TSource>, crea una raccolta di attività che scaricano il contenuto di ogni sito Web.Le attività vengono avviate quando la query viene valutata.

   Aggiungere il codice riportato di seguito al metodo SumPageSizesAsync, dopo la dichiarazione di 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. Applicare Task.WhenAll alla libreria di attività, downloadTasks.Task.WhenAll restituisce una sola attività che completa quando tutte le attività nella libreria di attività sono state completate.

   Nell'esempio seguente, l'espressione await o Await attende il completamento di una singola attività che restituisce WhenAll .L'espressione restituisce un array di interi, in cui ogni Integer rappresenta la lunghezza di un sito Web scaricata.Aggiungere il codice a SumPageSizesAsync, solo dopo il codice aggiunto al passaggio precedente.

   ' 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. Infine, utilizzare il metodo Sum per calcolare la somma delle lunghezze di tutti i siti Web.Aggiungere la seguente riga di codice a SumPageSizesAsync.

   Dim total = lengths.Sum()
   

   int total = lengths.Sum();
   

Per aggiungere Task.WhenAll alla soluzione di HttpClient.GetByteArrayAsync

1. Aggiungere la seguente versione di ProcessURLAsync la seconda applicazione compilata in Procedura dettagliata: accesso al Web tramite Async e Await (C# e Visual Basic).

   • Se è stato scaricato il codice da Esempi di codice dello sviluppatore, aprire il progetto AsyncWalkthrough_HttpClient quindi aggiungere ProcessURLAsync al file MainWindow.xaml.cs o MainWindow.xaml.vb.

   • Se elaboraste il codice eseguendo la procedura dettagliata, aggiungere ProcessURLAsyncapplicazione che utilizza il metodo di HttpClient.GetByteArrayAsync.Il file MainWindow.xaml.cs o MainWindow.xaml.vb per questa applicazione è il secondo esempio "esempi di codice completo nella sezione della procedura dettagliata".

   Il metodo di ProcessURLAsync consolida azioni nel corpo del ciclo di foreach o di For Each in SumPageSizesAsync nella procedura dettagliata originale.Il metodo in modo asincrono scarica il contenuto di un sito Web specificato come una array di byte e quindi visualizza e restituisce la lunghezza dell'array di byte.

   L'unica differenza dal metodo ProcessURLAsync della procedura precedente è l'utilizzo dell'istanza 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. Impostare come commento o eliminare il ciclo foreach o For Each in SumPageSizesAsync, come illustrato nel codice.

   '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. Definisce la query che, se eseguita con il metodo ToArray<TSource>, crea una raccolta di attività che scaricano il contenuto di ogni sito Web.Le attività vengono avviate quando la query viene valutata.

   Aggiungere il codice al metodo SumPageSizesAsync dopo la dichiarazione di client e 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. Successivamente applicare Task.WhenAll alla libreria di attività, downloadTasks.Task.WhenAll restituisce una sola attività che completa quando tutte le attività nella libreria di attività sono state completate.

   Nell'esempio seguente, l'espressione await o Await attende il completamento di una singola attività che restituisce WhenAll .Una volta completato Await o l'espressione await restituisce una matrice di interi, in cui ogni Integer rappresenta la lunghezza di un sito Web scaricato.Aggiungere il codice a SumPageSizesAsync, solo dopo il codice aggiunto al passaggio precedente.

   ' 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. Infine, utilizzare il metodo Sum per ottenere la somma delle lunghezze di tutti i siti Web.Aggiungere la seguente riga di codice a SumPageSizesAsync.

   Dim total = lengths.Sum()
   

   int total = lengths.Sum();
   

Per testare le soluzioni di Task.WhenAll

• Per qualsiasi soluzione, scegliere il tasto F5 per eseguire il programma e quindi scegliere il pulsante Avvia.Il codice sarà analogo all'output da soluzioni async in Procedura dettagliata: accesso al Web tramite Async e Await (C# e Visual Basic).Tuttavia, si nota che i siti Web ogni volta appaiono in un ordine diverso.

Esempio

Il codice seguente mostra le estensioni al progetto utilizza il metodo di GetURLContentsAsync per scaricare il contenuto dal 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);

        }
    }
}

Il codice seguente mostra le estensioni al progetto che utilizzano il metodo HttpClient.GetByteArrayAsync per scaricare il contenuto dal 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);
        }
    }
}

Vedere anche

Attività

Procedura dettagliata: accesso al Web tramite Async e Await (C# e Visual Basic)

Riferimenti

Task.WhenAll