Cancelar las tareas asincrónicas restantes cuando se completa una (C# y Visual Basic)

Artículo
06/10/2015

Mediante el uso conjunto del método Task.WhenAny y del método CancellationToken, se pueden cancelar todas las tareas restantes cuando se completa una tarea. El método WhenAny toma un argumento que es una colección de tareas. El método inicia todas las tareas y devuelve una tarea única. Se completa la tarea única cuando se completa cualquier tarea de la colección.

Este ejemplo muestra cómo utilizar un token de cancelación junto con WhenAny para esperar desde la primera tarea a que finalice la colección de tareas y cancelar las tareas restantes. Cada tarea descarga el contenido de un sitio web. El ejemplo muestra la longitud del contenido de la primera descarga para completar y cancela las otras descargas.

Nota

Para ejecutar los ejemplos, debe tener Visual Studio 2012, Visual Studio 2013, Visual Studio Express 2012 para escritorio de Windows, Visual Studio Express 2013 para Windows, o .NET Framework 4.5 o 4.5.1 instalado en su equipo.

Descargar el ejemplo

Puede descargar el proyecto completado de Windows Presentation Foundation (WPF) en Ejemplo Async: Ajuste de la aplicación y seguir estos pasos.

Descomprima el archivo que ha descargado y, a continuación, inicie Visual Studio.
En la barra de menú, elija Archivo, Abrir, Proyecto/Solución.
En el cuadro Abrir proyecto, abra la carpeta que contiene código de ejemplo que descomprimió y, a continuación, abra el archivo de solución (.sln) para AsyncFineTuningCS o AsyncFineTuningVB.
En el Explorador de soluciones, abra el acceso directo para el proyecto CancelAfterOneTask y, a continuación, elija Establecer como proyecto de inicio.
Elija la tecla F5 para ejecutar el proyecto.

Elija las teclas CTRL+F5 para ejecutar el proyecto sin depurarlo.
Ejecute el programa varias veces para comprobar que distintas descargas finalizan primero.

Si no desea descargar el proyecto, puede revisar los archivos completos de MainWindow.xaml.vb y de MainWindow.xaml.cs al final de este tema.

Compilar el ejemplo

El ejemplo de este tema se suma al proyecto que se desarrolla en Cancelar una tarea asincrónica o una lista de tareas (C# y Visual Basic) para cancelar una lista de tareas. El ejemplo utiliza la misma interfaz de usuario, aunque el botón Cancelar no se utilice explícitamente.

Para compilar el ejemplo usted mismo, paso a paso, siga las instrucciones de la sección “Descargar el ejemplo” pero elija CancelAListOfTasks como el Proyecto de inicio. Agregue los cambios de este tema a dicho proyecto.

En el archivo MainWindow.xaml.vb o MainWindow.xaml.cs del proyecto CancelAListOfTasks, inicie la transición moviendo los pasos de procesamiento de cada sitio web del bucle en AccessTheWebAsync al siguiente método asincrónico.

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

// ***Bundle the processing steps for a website into one async method.
async Task<int> ProcessURLAsync(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;
}

En AccessTheWebAsync, este ejemplo utiliza una consulta, el método ToArray``1 y el método WhenAny para crear e iniciar una matriz de tareas. La aplicación de WhenAny a la matriz devuelve una única tarea que, cuando se espera, evalúa desde la primera tarea hasta lograr la finalización en la matriz de tareas.

Realice los cambios siguientes en AccessTheWebAsync. Los asteriscos marcan los cambios en el archivo de código.

Marque como comentario o elimine el bucle.

Cree una consulta que, cuando se ejecuta, genera una colección de tareas genéricas. Cada llamada a ProcessURLAsync devuelve Task, donde TResult es un entero.

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

// ***Create a query that, when executed, returns a collection of tasks.
IEnumerable<Task<int>> downloadTasksQuery =
    from url in urlList select ProcessURLAsync(url, client, ct);

Llame a ToArray para ejecutar la consulta y para iniciar las tareas. La aplicación del método WhenAny en el paso siguiente ejecutará la consulta y comenzará las tareas sin utilizar ToArray, pero otros métodos podrían no hacerlo. El procedimiento más seguro es forzar la ejecución de la consulta explícitamente.
```
' ***Use ToArray to execute the query and start the download tasks.  
Dim downloadTasks As Task(Of Integer)() = downloadTasksQuery.ToArray()
```
```
// ***Use ToArray to execute the query and start the download tasks. 
Task<int>[] downloadTasks = downloadTasksQuery.ToArray();
```
Llame a WhenAny en la colección de tareas. WhenAny devuelve Task(Of Task(Of Integer)) o Task<Task<int>>. Es decir, WhenAny devuelve una tarea que evalúa solo Task(Of Integer) o Task<int> cuando se haya esperado. Esa tarea única es la primera tarea de la colección que se ha de finalizar. La tarea que finalizó primero se asigna a firstFinishedTask. El tipo de firstFinishedTask es Task donde TResult es un entero porque es el tipo de valor devuelto por ProcessURLAsync.
```
' ***Call WhenAny and then await the result. The task that finishes  
' first is assigned to firstFinishedTask. 
Dim firstFinishedTask As Task(Of Integer) = Await Task.WhenAny(downloadTasks)
```
```
// ***Call WhenAny and then await the result. The task that finishes  
// first is assigned to firstFinishedTask.
Task<int> firstFinishedTask = await Task.WhenAny(downloadTasks);
```

En este ejemplo, solo le interesa la tarea que finaliza primero. Por consiguiente, utilice CancellationTokenSource.Cancel para cancelar las tareas restantes.

' ***Cancel the rest of the downloads. You just want the first one.
cts.Cancel()

// ***Cancel the rest of the downloads. You just want the first one.
cts.Cancel();

Finalmente, espere a que firstFinishedTask recupere la longitud del contenido descargado.

Dim length = Await firstFinishedTask
resultsTextBox.Text &= String.Format(vbCrLf & "Length of the downloaded website:  {0}" & vbCrLf, length)

var length = await firstFinishedTask;
resultsTextBox.Text += String.Format("\r\nLength of the downloaded website:  {0}\r\n", length);

Ejecute el programa varias veces para comprobar que distintas descargas finalizan primero.

Ejemplo completo

El código siguiente es el archivo completo de MainWindow.xaml.vb o de MainWindow.xaml.cs para el ejemplo. Los asteriscos marcan los elementos agregados para este ejemplo.

Observe que debe agregar una referencia para System.Net.Http.

Puede descargar el proyecto desde Ejemplo Async: Ajuste de la aplicación.

' 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 & "Download complete." 

        Catch ex As OperationCanceledException
            resultsTextBox.Text &= vbCrLf & "Download canceled." & vbCrLf

        Catch ex As Exception
            resultsTextBox.Text &= vbCrLf & "Download 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()

        '' Comment out or delete the loop. 
        ''For Each url In urlList 
        ''    ' GetAsync returns a Task(Of HttpResponseMessage).  
        ''    ' Argument ct carries the message if the Cancel button is chosen.  
        ''    ' Note that the Cancel button can cancel all remaining downloads. 
        ''    Dim response As HttpResponseMessage = Await client.GetAsync(url, ct) 

        ''    ' Retrieve the website contents from the HttpResponseMessage. 
        ''    Dim urlContents As Byte() = Await response.Content.ReadAsByteArrayAsync() 

        ''    resultsTextBox.Text &= 
        ''        String.Format(vbCrLf & "Length of the downloaded string: {0}." & vbCrLf, urlContents.Length) 
        ''Next 

        ' ***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 ToArray to execute the query and start the download tasks.  
        Dim downloadTasks As Task(Of Integer)() = downloadTasksQuery.ToArray()

        ' ***Call WhenAny and then await the result. The task that finishes  
        ' first is assigned to firstFinishedTask. 
        Dim firstFinishedTask As Task(Of Integer) = Await Task.WhenAny(downloadTasks)

        ' ***Cancel the rest of the downloads. You just want the first one.
        cts.Cancel()

        ' ***Await the first completed task and display the results 
        ' Run the program several times to demonstrate that different 
        ' websites can finish first. 
        Dim length = Await firstFinishedTask
        resultsTextBox.Text &= String.Format(vbCrLf & "Length of the downloaded website:  {0}" & vbCrLf, length)
    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 downloaded website:  158856 

' Download 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 CancelAfterOneTask
{
    public partial class MainWindow : Window
    {
        // Declare a System.Threading.CancellationTokenSource.
        CancellationTokenSource cts;

        public MainWindow()
        {
            InitializeComponent();
        }


        private async void startButton_Click(object sender, RoutedEventArgs e)
        {
            // Instantiate the CancellationTokenSource.
            cts = new CancellationTokenSource();

            resultsTextBox.Clear();

            try
            {
                await AccessTheWebAsync(cts.Token);
                resultsTextBox.Text += "\r\nDownload complete.";
            }
            catch (OperationCanceledException)
            {
                resultsTextBox.Text += "\r\nDownload canceled.";
            }
            catch (Exception)
            {
                resultsTextBox.Text += "\r\nDownload failed.";
            }

            // Set the CancellationTokenSource to null when the download is complete.
            cts = null;
        }


        // You can still include a Cancel button if you want to. 
        private void cancelButton_Click(object sender, RoutedEventArgs e)
        {
            if (cts != null)
            {
                cts.Cancel();
            }
        }


        // Provide a parameter for the CancellationToken.
        async Task AccessTheWebAsync(CancellationToken ct)
        {
            HttpClient client = new HttpClient();

            // Call SetUpURLList to make a list of web addresses.
            List<string> urlList = SetUpURLList();

            // ***Comment out or delete the loop. 
            //foreach (var url in urlList) 
            //{ 
            //    // GetAsync returns a Task<HttpResponseMessage>.  
            //    // Argument ct carries the message if the Cancel button is chosen.  
            //    // ***Note that the Cancel button can cancel all remaining downloads. 
            //    HttpResponseMessage response = await client.GetAsync(url, ct); 

            //    // Retrieve the website contents from the HttpResponseMessage. 
            //    byte[] urlContents = await response.Content.ReadAsByteArrayAsync(); 

            //    resultsTextBox.Text += 
            //        String.Format("\r\nLength of the downloaded string: {0}.\r\n", urlContents.Length);
            //} 

            // ***Create a query that, when executed, returns a collection of tasks.
            IEnumerable<Task<int>> downloadTasksQuery =
                from url in urlList select ProcessURLAsync(url, client, ct);

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

            // ***Call WhenAny and then await the result. The task that finishes  
            // first is assigned to firstFinishedTask.
            Task<int> firstFinishedTask = await Task.WhenAny(downloadTasks);

            // ***Cancel the rest of the downloads. You just want the first one.
            cts.Cancel();

            // ***Await the first completed task and display the results.  
            // Run the program several times to demonstrate that different 
            // websites can finish first. 
            var length = await firstFinishedTask;
            resultsTextBox.Text += String.Format("\r\nLength of the downloaded website:  {0}\r\n", length);
        }


        // ***Bundle the processing steps for a website into one async method.
        async Task<int> ProcessURLAsync(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;
        }


        // Add a method that creates a list of web addresses. 
        private List<string> SetUpURLList()
        {
            List<string> urls = new List<string> 
            { 
                "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;
        }
    }
    // Sample output: 

    // Length of the downloaded website:  158856 

    // Download complete.
}

Vea también

Cancelar las tareas asincrónicas restantes cuando se completa una (C# y Visual Basic)

Descargar el ejemplo

Compilar el ejemplo

Ejemplo completo

Vea también

Referencia

Conceptos

Otros recursos

Recursos adicionales