Comment : étendre la procédure pas à pas à l'aide de Task.WhenAll (C# et Visual Basic)

Article
03/04/2013

Vous pouvez améliorer les performances de la solution async dans Procédure pas à pas : accès au Web avec Async et Await (C# et Visual Basic) à l'aide de la méthode Task.WhenAll .Cette méthode attend de façon asynchrone plusieurs opérations asynchrones, représentées comme une collection de tâches.

Vous avez peut-être remarqué dans la procédure pas-à- pas que les sites Web sont téléchargés à des taux différents.Quelquefois un des sites Web est très lent, ce qui qui retarde les téléchargements restants.Lorsque vous exécutez les solutions asynchrones que vous générez dans la procédure pas- à- pas, vous pouvez exécuter le programme facilement si vous ne souhaitez pas attendre, mais une meilleure option est de commencer les téléchargements en même temps et de laisser des téléchargements plus rapides continuer sans attendre celui qui est différé.

Vous appliquez la méthode Task.WhenAll à une collection de tâches.L'application de WhenAll retourne une tâche unique qui n'est pas terminée tant que chaque tâche dans la collection n'est pas terimée.Les tâches supplémentaires sont implicitement exécutées en parallèle, mais aucun thread supplémentaire n'est créé.Les tâches peuvent s'exécuter dans n'importe quel ordre.

Important

Les procédures suivantes décrivent les extensions des applications async qui sont développées dans Procédure pas à pas : accès au Web avec Async et Await (C# et Visual Basic).Vous pouvez développer des applications en suivant la procédure ou téléchargez le code de Exemples de code de développement.

Pour exécuter l'exemple, vous devez avoir installé Visual Studio 2012 Visual Studio express 2012 pour le bureau Windows, ou .NET Framework 4,5 sur votre ordinateur.

Pour ajouter Task.WhenAll à votre solution GetURLContentsAsync

Ajoutez la méthode d' ProcessURLAsync à la première application qui est développée dans Procédure pas à pas : accès au Web avec Async et Await (C# et Visual Basic).
- Si vous avez téléchargé le code Exemples de code de développementà partir de, ouvrez le projet d'AsyncWalkthrough, puis ajoutez ProcessURLAsync au fichier de MainWindow.xaml.vb ou MainWindow.xaml.cs.
- Si vous avez développé le code en suivant la procédure pas - à - pas, ajoutez ProcessURLAsync à l'application qui inclut la méthode d' GetURLContentsAsync .Le fichier de MainWindow.xaml.vb ou MainWindow.xaml.cs pour cette application est le premier exemple dans « exemples de code complets la section de la procédure pas - à - pas ».
La méthode d' ProcessURLAsync consolide les actions au corps de la boucle d' For Each ou d' foreach dans SumPageSizesAsync de la procédure d'origine.La méthode télécharge de façon asynchrone le contenu d'un site Web spécifié comme un tableau d'octets, puis l'affiche et retourne la longueur du tableau d'octets.
```
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;
}
```

Commentez ou supprimez la boucle For Each ou foreach dans SumPageSizesAsync, comme l'illustre le code suivant.

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

Créer une collection de tâches.Le code suivant définit une requête qui, lorsqu'elle est exécutée par la méthode ToArray<TSource> , crée une collection de tâches qui téléchargent le contenu de chaque site Web.Les tâches sont démarrées lorsque la requête est évaluée.

Ajoutez le code suivant à la classe SumPageSizesAsync, après la déclaration d' 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();

Appliquez Task.WhenAll à la collection de tâches, downloadTasks.Task.WhenAll retourne une tâche unique qui se termine lorsque toutes les tâches dans la collection de tâches sont terminées.

Dans l'exemple suivant, l'expression Await ou await attend la fin de la tâche unique que WhenAll retourne.L'expression correspond à un tableau d'entiers, où chaque entier est la longueur d'un site Web téléchargé.Ajoutez le code suivant à SumPageSizesAsync, juste après le code que vous avez ajouté dans l'étape précédente.

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

Enfin, utilisez la méthode Sum pour calculer la somme des longueurs de tous les sites Web.Ajoutez le code suivant à SumPageSizesAsync.
```
Dim total = lengths.Sum()
```
```
int total = lengths.Sum();
```

Pour ajouter Task.WhenAll à la solution HttpClient.GetByteArrayAsync

Ajoutez la version suivante pour ProcessURLAsync à la seconde application qui est développée dans Procédure pas à pas : accès au Web avec Async et Await (C# et Visual Basic).
- Si vous avez téléchargé le code Exemples de code de développementà partir de, ouvrez le projet d'AsyncWalkthrough_HttpClient, puis ajoutez ProcessURLAsync au fichier de MainWindow.xaml.vb ou MainWindow.xaml.cs.
- Si vous avez développé le code en suivant la procédure pas - à - pas, ajoutez ProcessURLAsync à l'application utilisant la méthode d' HttpClient.GetByteArrayAsync .Le fichier de MainWindow.xaml.vb ou MainWindow.xaml.cs pour cette application est le deuxième exemple dans « exemples de code complets la section de la procédure pas - à - pas ».
La méthode d' ProcessURLAsync consolide les actions au corps de la boucle d' For Each ou d' foreach dans SumPageSizesAsync de la procédure d'origine.La méthode télécharge de façon asynchrone le contenu d'un site Web spécifié comme un tableau d'octets, puis l'affiche et retourne la longueur du tableau d'octets.

La seule différence de la méthode ProcessURLAsync dans la procédure précédente est l'utilisation de l'instance 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;
}
```

Commentez ou supprimez la boucle For Each ou foreach dans SumPageSizesAsync, comme l'illustre le code suivant.

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

Définis une requête qui, éxécutée par la méthode ToArray<TSource> , créee une collection de tâches qui téléchargent le contenu de chaque site web.Les tâches sont démarrées lorsque la requête est évaluée.

Ajoutez le code suivant à la méthode SumPageSizesAsync, après la déclaration de client et 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();

Puis, appliquez Task.WhenAll à la collection de tâches downloadTasks.Task.WhenAll retourne une tâche unique qui se termine lorsque toutes les tâches dans la collection de tâches sont terminées.

Dans l'exemple suivant, l'expression Await ou await attend la fin de la tâche unique que WhenAll retourne.Dès son achèvement, l'expression Await ou l'expression await correspond à un tableau d'entiers, où chaque entier est la longueur d'un site Web téléchargé.Ajoutez le code suivant à SumPageSizesAsync, juste après le code que vous avez ajouté dans l'étape précédente.
```
' 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;
```
Finallement, utilisez la méthode Sum pour obtenir la somme des longueurs de tous les sites web.Ajoutez le code suivant à SumPageSizesAsync.
```
Dim total = lengths.Sum()
```
```
int total = lengths.Sum();
```

Pour tester les solutions de Task.WhenAll

Pour l'un ou l'autre de solutions, sélectionnez la touche F5 pour exécuter le programme, puis choisissez le bouton Démarrer .La sortie doit ressembler à la sortie des solutions async dans Procédure pas à pas : accès au Web avec Async et Await (C# et Visual Basic).Toutefois, notez que les sites Web s'affichent dans un ordre différent à chaque fois.

Exemple

Le code suivant affiche les extensions au projet qui utilise la méthode de GetURLContentsAsync pour télécharger le contenu du 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);

        }
    }
}

Le code suivant montre les extensions au projet qui utilisent la méthode HttpClient.GetByteArrayAsync pour télécharger du contenu 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);
        }
    }
}

Comment : étendre la procédure pas à pas à l'aide de Task.WhenAll (C# et Visual Basic)

Pour ajouter Task.WhenAll à votre solution GetURLContentsAsync

Pour ajouter Task.WhenAll à la solution HttpClient.GetByteArrayAsync

Pour tester les solutions de Task.WhenAll

Exemple

Voir aussi

Tâches

Référence

Ressources supplémentaires