Gewusst wie: Erweitern der exemplarischen Vorgehensweise mit Task.WhenAll (C# und Visual Basic)

Sie können die Leistung der asynchronen Projektmappe in Exemplarische Vorgehensweise: Zugreifen auf das Web mit Async und Await (C# und Visual Basic) verbessern, indem Sie die - Methode verwenden. Task.WhenAllDiese Methode erwartet asynchron mehrere asynchrone Operationen, die als Auflistung Aufgaben dargestellt werden.

Sie haben möglicherweise in der exemplarischen Vorgehensweise, die die Websites mit verschiedenen Rate herunterladen.Manchmal eines der Websites ist sehr langsam, das alle verbleibenden Downloads verzögert.Wenn Sie die asynchronen Projektmappen ausgeführt werden, die Sie in der exemplarischen Vorgehensweise erstellen, können Sie das Programm leicht beenden, wenn Sie nicht warten möchten, aber eine bessere Option würde, alle Downloads gleichzeitig zu starten sein und schnellere Downloads ließ fortfahren, ohne auf das zu warten, das verschoben wird.

Sie wenden die Task.WhenAll-Methode zu einer Auflistung Aufgaben.Die Verwendung von WhenAll gibt eine einzelne Aufgabe zurück, die nicht vollständig ist, bis alle Aufgaben in der Auflistung abgeschlossen ist.Die Aufgaben werden, parallel ausgeführt, jedoch keine weiteren Threads werden erstellt.Die Aufgaben können in beliebiger Reihenfolge abschließen.

Wichtig

Die folgenden Prozeduren beschreiben Erweiterungen der asynchronen Anwendungen, die in Exemplarische Vorgehensweise: Zugreifen auf das Web mit Async und Await (C# und Visual Basic) entwickelt werden.Sie können die Anwendungen entwickeln, indem Sie entweder die exemplarische Vorgehensweise durcharbeiten oder den Code von Entwickler-Codebeispiele herunterladen. Um das Beispiel auszuführen, müssen Sie Visual Studio 2012, Visual Studio Express 2012 für Windows Desktop oder .NET Framework 4.5 enthalten, das auf dem Computer installiert ist.

So Task.WhenAll der GetURLContentsAsync-Projektmappe hinzufügen

1. Fügen Sie die ProcessURLAsync-Methode der ersten Anwendung hinzu, die in Exemplarische Vorgehensweise: Zugreifen auf das Web mit Async und Await (C# und Visual Basic) entwickelt.

   • Wenn Sie den Code von Entwickler-Codebeispiele heruntergeladen haben, öffnen Sie das AsyncWalkthrough-Projekt, und fügen Sie dann ProcessURLAsync der MainWindow.xaml.vb- oder "MainWindow.xaml.cs" hinzu.

   • Wenn Sie den Code entwickeln, indem Sie die exemplarische Vorgehensweise vorgenommen haben, fügen Sie ProcessURLAsync der Anwendung hinzu, die die GetURLContentsAsync-Methode umfasst.Die MainWindow.xaml.vb- oder "MainWindow.xaml.cs" für diese Anwendung ist das erste Beispiel im "vollständige Codebeispiele der exemplarischen Vorgehensweise" Abschnitt.

   Die - Methode ProcessURLAsync konsolidiert die Aktionen im Text der For Each oder foreach-Schleife in SumPageSizesAsync in der ursprünglichen exemplarischen Vorgehensweise.Die - Methode asynchron lädt den Inhalt einer bestimmten Website als Bytearray und dann Anzeigen herunter und gibt die Länge des Bytearrays zurück.

   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. Kommentieren Sie out oder löschen Sie die For Each oder foreach-Schleife in SumPageSizesAsync, wie im folgenden Code veranschaulicht.

   '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. Erstellen Sie eine Auflistung Aufgaben.Der folgende Code definiert, der Abfrage, wenn er durch die ToArray<TSource>-Methode ausgeführt wird, eine Auflistung Aufgaben erstellt, die den Inhalt jeder Website herunterladen.Die Aufgaben werden gestartet, wenn die Abfrage ausgewertet wird.

   Fügen Sie den folgenden Code SumPageSizesAsync-Methode nach der Deklaration von urlList hinzu.

   ' 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. Wenden Sie Task.WhenAll zur Auflistung von Aufgaben, downloadTasks.Task.WhenAll gibt eine einzelne Aufgabe zurück, die beendet, wenn alle Aufgaben in der Auflistung von Aufgaben abgeschlossen wurden.

   Im folgenden Beispiel erwartet der Await oder await Ausdruck den Abschluss der einzelnen Aufgabe, die WhenAll zurückgibt.Der Ausdruck ergibt einen Array von ganzen Zahlen aus, wobei jede ganze Zahl die Länge einer heruntergeladenen Website ist.Fügen Sie den folgenden Code SumPageSizesAsync, direkt nach dem Code hinzu, den Sie im vorherigen Schritt hinzugefügt haben.

   ' 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. Schließlich verwenden Sie die Sum-Methode, um die Summe der Längen aller Websites zu berechnen.Fügen Sie die folgende Zeile SumPageSizesAsync hinzu.

   Dim total = lengths.Sum()
   

   int total = lengths.Sum();
   

So Task.WhenAll der HttpClient.GetByteArrayAsync-Projektmappe hinzufügen

1. Fügen Sie die folgende Version von ProcessURLAsync der zweiten Anwendung hinzu, die in Exemplarische Vorgehensweise: Zugreifen auf das Web mit Async und Await (C# und Visual Basic) entwickelt.

   • Wenn Sie den Code von Entwickler-Codebeispiele heruntergeladen haben, öffnen Sie das AsyncWalkthrough_HttpClient-Projekt, und fügen Sie dann ProcessURLAsync der MainWindow.xaml.vb- oder "MainWindow.xaml.cs" hinzu.

   • Wenn Sie den Code entwickeln, indem Sie die exemplarische Vorgehensweise vorgenommen haben, fügen Sie ProcessURLAsync der Anwendung hinzu, die die HttpClient.GetByteArrayAsync-Methode verwendet.Die MainWindow.xaml.vb- oder "MainWindow.xaml.cs" für diese Anwendung ist das zweite Beispiel im "vollständige Codebeispiele der exemplarischen Vorgehensweise" Abschnitt.

   Die - Methode ProcessURLAsync konsolidiert die Aktionen im Text der For Each oder foreach-Schleife in SumPageSizesAsync in der ursprünglichen exemplarischen Vorgehensweise.Die - Methode asynchron lädt den Inhalt einer bestimmten Website als Bytearray und dann Anzeigen herunter und gibt die Länge des Bytearrays zurück.

   Der einzige Unterschied ProcessURLAsync von der - Methode in der vorherigen Prozedur ist die Verwendung der HttpClient-Instanz, 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. Kommentieren Sie out oder löschen Sie die For Each oder foreach-Schleife in SumPageSizesAsync, wie im folgenden Code veranschaulicht.

   '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. Definieren Sie Abfrage, das, sofern für die ToArray<TSource>-Methode ausgeführt wird, eine Auflistung Aufgaben erstellt, die den Inhalt jeder Website herunterladen.Die Aufgaben werden gestartet, wenn die Abfrage ausgewertet wird.

   Fügen Sie den folgenden Code SumPageSizesAsync-Methode nach der Deklaration von client und von urlList hinzu.

   ' 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. Als Nächstes wenden Sie Task.WhenAll zur Auflistung von Aufgaben, downloadTasks.Task.WhenAll gibt eine einzelne Aufgabe zurück, die beendet, wenn alle Aufgaben in der Auflistung von Aufgaben abgeschlossen wurden.

   Im folgenden Beispiel erwartet der Await oder await Ausdruck den Abschluss der einzelnen Aufgabe, die WhenAll zurückgibt.Wenn vollständig, wertet Await oder der await Ausdruck zu einem Array von ganzen Zahlen aus, wobei jede ganze Zahl die Länge einer heruntergeladenen Website ist.Fügen Sie den folgenden Code SumPageSizesAsync, direkt nach dem Code hinzu, den Sie im vorherigen Schritt hinzugefügt haben.

   ' 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. Schließlich verwenden Sie die Sum-Methode, um die Summe der Längen aller Websites abzurufen.Fügen Sie die folgende Zeile SumPageSizesAsync hinzu.

   Dim total = lengths.Sum()
   

   int total = lengths.Sum();
   

Um die Task.WhenAll-Projektmappen testen

• Für jede Projektmappe wählen Sie die F5-TASTE, um das Programm auszuführen, und wählen Sie dann die Schaltfläche Start aus.Die Ausgabe sollte der Ausgabe von asynchronen Projektmappen in Exemplarische Vorgehensweise: Zugreifen auf das Web mit Async und Await (C# und Visual Basic) ähneln.Beachten Sie jedoch, dass die Websites in einer anderen Reihenfolge jedes Mal angezeigt werden.

Beispiel

Der folgende Code zeigt die Erweiterungen zum - Projekt an, das die GetURLContentsAsync-Methode verwendet, um Inhalt aus dem Internet herunterladen.

' 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);

        }
    }
}

Der folgende Code zeigt die Erweiterungen zum - Projekt an, das HttpClient.GetByteArrayAsync-Methode verwendet, um Inhalt aus dem Internet herunterladen.

' 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);
        }
    }
}

Siehe auch

Aufgaben

Exemplarische Vorgehensweise: Zugreifen auf das Web mit Async und Await (C# und Visual Basic)

Referenz

Task.WhenAll