Démarrer plusieurs tâches Asynch et les traiter une fois terminées (C# et Visual Basic)
À l'aide de Task.WhenAny, vous pouvez démarrer plusieurs tâches en même temps et les traiter une par une lorsqu'elles sont terminées, plutôt que de les traiter dans l'ordre dans lequel elles ont démarré.
L'exemple suivant utilise une requête pour créer une collection de tâches. Chaque tâche télécharge le contenu d'un site Web spécifié. Dans chaque itération d'une boucle while, un appel attendu à WhenAny retourne la tâche de la collection de tâches qui termine son téléchargement en premier. Cette tâche est supprimée de la collection et traitée. La boucle se répète jusqu'à ce que la collection ne contienne plus de tâches.
Notes
Pour exécuter les exemples, Visual Studio 2012, Visual Studio 2013, Visual Studio Express 2012 pour Windows Desktop, Visual Studio Express 2013 pour Windows ou le .NET Framework 4.5 ou 4.5.1 doit être installé sur votre ordinateur.
Téléchargement de l'exemple
Vous pouvez télécharger le projet Windows Presentation Foundation (WPF) complet à partir de Exemple async : réglage de votre application et suivre ces étapes.
Décompressez le fichier que vous avez téléchargé, puis démarrez Visual Studio.
Dans la barre de menus, sélectionnez Fichier, Ouvrir, Projet/Solution.
Dans la boîte de dialogue Ouvrir le projet, ouvrez le dossier contenant l'exemple de code que vous avez décompressé, puis ouvrez le fichier solution (.sln) pour AsyncFineTuningCS ou AsyncFineTuningVB.
Dans l'Explorateur de solutions, ouvrez le menu contextuel du projet ProcessTasksAsTheyFinish, puis choisissez Définir comme projet de démarrage.
Sélectionnez la touche F5 pour exécuter le projet.
Appuyez sur les touches Ctrl + F5 pour exécuter le projet sans le déboguer.
Exécutez le projet plusieurs fois pour vérifier que les longueurs téléchargées n'apparaissent pas toujours dans le même ordre.
Si vous ne souhaitez pas télécharger le projet, vous pouvez examiner les fichiers complets MainWindow.xaml.vb et MainWindow.xaml.cs à la fin de cette rubrique.
Création de l'exemple
Cet exemple ajoute au code développé dans Annuler les tâches Asynch restantes lorsque l'une d'elles est terminée (C# et Visual Basic) et utilise la même interface utilisateur.
Pour générer l'exemple vous-même, pas à pas, suivez les instructions de la section « Téléchargement de l'exemple », mais choisissez CancelAfterOneTask comme Projet de démarrage. Ajoutez les modifications de cette rubrique à la méthode AccessTheWebAsync dans ce projet. Les modifications sont marquées avec des astérisques.
Le projet CancelAfterOneTask inclut déjà une requête qui, une fois exécutée, crée une collection de tâches. Chaque appel à ProcessURLAsync dans le code suivant retourne Task où TResult est un entier.
Dim downloadTasksQuery As IEnumerable(Of Task(Of Integer)) =
From url In urlList Select ProcessURLAsync(url, client, ct)
IEnumerable<Task<int>> downloadTasksQuery =
from url in urlList select ProcessURL(url, client, ct);
Dans le fichier MainWindow.xaml.vb ou MainWindow.xaml.cs du projet, apportez les modifications suivantes à la méthode AccessTheWebAsync.
Exécutez la requête en appliquant Enumerable.ToList``1 au lieu de ToArray``1.
Dim downloadTasks As List(Of Task(Of Integer)) = downloadTasksQuery.ToList()List<Task<int>> downloadTasks = downloadTasksQuery.ToList();Ajoutez une boucle while qui exécute les étapes suivantes pour chaque tâche de la collection.
Attend un appel à WhenAny pour identifier la première tâche de la collection à terminer son téléchargement.
Dim firstFinishedTask As Task(Of Integer) = Await Task.WhenAny(downloadTasks)Task<int> firstFinishedTask = await Task.WhenAny(downloadTasks);Supprime cette tâche de la collection.
downloadTasks.Remove(firstFinishedTask)downloadTasks.Remove(firstFinishedTask);Attend firstFinishedTask, qui est retourné par un appel à ProcessURLAsync. La variable firstFinishedTask est un Task où TReturn est un entier. La tâche est déjà terminée, mais vous attendez qu'elle récupère la longueur du site Web téléchargé, comme indiqué dans l'exemple suivant.
Dim length = Await firstFinishedTask resultsTextBox.Text &= String.Format(vbCrLf & "Length of the downloaded website: {0}" & vbCrLf, length)int length = await firstFinishedTask; resultsTextBox.Text += String.Format("\r\nLength of the download: {0}", length);
Vous devriez exécuter le projet plusieurs fois pour vérifier que les longueurs téléchargées n'apparaissent pas toujours dans le même ordre.
Avertissement
L'utilisation de WhenAny dans une boucle, comme décrit dans l'exemple, est parfaite pour résoudre des problèmes qui impliquent un petit nombre de tâches.Toutefois, d'autres approches sont plus efficaces si vous avez un grand nombre de tâches à traiter.Pour plus d'informations et pour découvrir des exemples, consultez Traitement des résultats des tâches qui se terminent.
Exemple complet
Le code suivant est le texte complet du fichier MainWindow.xaml.vb ou MainWindow.xaml.cs de l'exemple. Les astérisques marquent les éléments ajoutés pour cet exemple.
Notez que vous devez ajouter une référence pour System.Net.Http.
Vous pouvez télécharger le projet à partir de Exemple async : réglage de votre application.
' Add an Imports directive and a reference for System.Net.Http.
Imports System.Net.Http
' Add the following Imports directive for System.Threading.
Imports System.Threading
Class MainWindow
' Declare a System.Threading.CancellationTokenSource.
Dim cts As CancellationTokenSource
Private Async Sub startButton_Click(sender As Object, e As RoutedEventArgs)
' Instantiate the CancellationTokenSource.
cts = New CancellationTokenSource()
resultsTextBox.Clear()
Try
Await AccessTheWebAsync(cts.Token)
resultsTextBox.Text &= vbCrLf & "Downloads complete."
Catch ex As OperationCanceledException
resultsTextBox.Text &= vbCrLf & "Downloads canceled." & vbCrLf
Catch ex As Exception
resultsTextBox.Text &= vbCrLf & "Downloads failed." & vbCrLf
End Try
' Set the CancellationTokenSource to Nothing when the download is complete.
cts = Nothing
End Sub
' You can still include a Cancel button if you want to.
Private Sub cancelButton_Click(sender As Object, e As RoutedEventArgs)
If cts IsNot Nothing Then
cts.Cancel()
End If
End Sub
' Provide a parameter for the CancellationToken.
' Change the return type to Task because the method has no return statement.
Async Function AccessTheWebAsync(ct As CancellationToken) As Task
Dim client As HttpClient = New HttpClient()
' Call SetUpURLList to make a list of web addresses.
Dim urlList As List(Of String) = SetUpURLList()
' ***Create a query that, when executed, returns a collection of tasks.
Dim downloadTasksQuery As IEnumerable(Of Task(Of Integer)) =
From url In urlList Select ProcessURLAsync(url, client, ct)
' ***Use ToList to execute the query and start the download tasks.
Dim downloadTasks As List(Of Task(Of Integer)) = downloadTasksQuery.ToList()
' ***Add a loop to process the tasks one at a time until none remain.
While downloadTasks.Count > 0
' ***Identify the first task that completes.
Dim firstFinishedTask As Task(Of Integer) = Await Task.WhenAny(downloadTasks)
' ***Remove the selected task from the list so that you don't
' process it more than once.
downloadTasks.Remove(firstFinishedTask)
' ***Await the first completed task and display the results.
Dim length = Await firstFinishedTask
resultsTextBox.Text &= String.Format(vbCrLf & "Length of the downloaded website: {0}" & vbCrLf, length)
End While
End Function
' Bundle the processing steps for a website into one async method.
Async Function ProcessURLAsync(url As String, client As HttpClient, ct As CancellationToken) As Task(Of Integer)
' GetAsync returns a Task(Of HttpResponseMessage).
Dim response As HttpResponseMessage = Await client.GetAsync(url, ct)
' Retrieve the website contents from the HttpResponseMessage.
Dim urlContents As Byte() = Await response.Content.ReadAsByteArrayAsync()
Return urlContents.Length
End Function
' Add a method that creates a list of web addresses.
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/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
End Class
' Sample output:
' Length of the download: 226093
' Length of the download: 412588
' Length of the download: 175490
' Length of the download: 204890
' Length of the download: 158855
' Length of the download: 145790
' Length of the download: 44908
' Downloads complete.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
// Add a using directive and a reference for System.Net.Http.
using System.Net.Http;
// Add the following using directive.
using System.Threading;
namespace ProcessTasksAsTheyFinish
{
public partial class MainWindow : Window
{
// Declare a System.Threading.CancellationTokenSource.
CancellationTokenSource cts;
public MainWindow()
{
InitializeComponent();
}
private async void startButton_Click(object sender, RoutedEventArgs e)
{
resultsTextBox.Clear();
// Instantiate the CancellationTokenSource.
cts = new CancellationTokenSource();
try
{
await AccessTheWebAsync(cts.Token);
resultsTextBox.Text += "\r\nDownloads complete.";
}
catch (OperationCanceledException)
{
resultsTextBox.Text += "\r\nDownloads canceled.\r\n";
}
catch (Exception)
{
resultsTextBox.Text += "\r\nDownloads failed.\r\n";
}
cts = null;
}
private void cancelButton_Click(object sender, RoutedEventArgs e)
{
if (cts != null)
{
cts.Cancel();
}
}
async Task AccessTheWebAsync(CancellationToken ct)
{
HttpClient client = new HttpClient();
// Make a list of web addresses.
List<string> urlList = SetUpURLList();
// ***Create a query that, when executed, returns a collection of tasks.
IEnumerable<Task<int>> downloadTasksQuery =
from url in urlList select ProcessURL(url, client, ct);
// ***Use ToList to execute the query and start the tasks.
List<Task<int>> downloadTasks = downloadTasksQuery.ToList();
// ***Add a loop to process the tasks one at a time until none remain.
while (downloadTasks.Count > 0)
{
// Identify the first task that completes.
Task<int> firstFinishedTask = await Task.WhenAny(downloadTasks);
// ***Remove the selected task from the list so that you don't
// process it more than once.
downloadTasks.Remove(firstFinishedTask);
// Await the completed task.
int length = await firstFinishedTask;
resultsTextBox.Text += String.Format("\r\nLength of the download: {0}", length);
}
}
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/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;
}
async Task<int> ProcessURL(string url, HttpClient client, CancellationToken ct)
{
// GetAsync returns a Task<HttpResponseMessage>.
HttpResponseMessage response = await client.GetAsync(url, ct);
// Retrieve the website contents from the HttpResponseMessage.
byte[] urlContents = await response.Content.ReadAsByteArrayAsync();
return urlContents.Length;
}
}
}
// Sample Output:
// Length of the download: 226093
// Length of the download: 412588
// Length of the download: 175490
// Length of the download: 204890
// Length of the download: 158855
// Length of the download: 145790
// Length of the download: 44908
// Downloads complete.
Voir aussi
Référence
Concepts
Réglage de votre application Async (C# et Visual Basic)
Programmation asynchrone avec Async et Await (C# et Visual Basic)