Task Clase

Definición

Representa una operación asincrónica.

public ref class Task : IAsyncResult
public ref class Task : IAsyncResult, IDisposable
public class Task : IAsyncResult
public class Task : IAsyncResult, IDisposable
type Task = class
    interface IAsyncResult
type Task = class
    interface IAsyncResult
    interface IDisposable
Public Class Task
Implements IAsyncResult
Public Class Task
Implements IAsyncResult, IDisposable
Herencia
Task
Derivado
Implementaciones

Comentarios

La Task clase representa una sola operación que no devuelve un valor y que normalmente se ejecuta de forma asincrónica. Task los objetos son uno de los componentes centrales del patrón asincrónico basado en tareas que se introdujo primero en .NET Framework 4. Dado que el trabajo realizado por un Task objeto normalmente se ejecuta de forma asincrónica en un subproceso de grupo de subprocesos en lugar de sincrónicamente en el subproceso de aplicación principal, puede usar la Status propiedad , así como las IsCanceledpropiedades , IsCompletedy IsFaulted para determinar el estado de una tarea. Normalmente, se usa una expresión lambda para especificar el trabajo que debe realizar la tarea.

En el caso de las operaciones que devuelven valores, use la Task<TResult> clase .

En esta sección:

Ejemplos de creación de instancias de tareas
Creación y ejecución de una tarea
Separación de la creación y ejecución de tareas
Esperar a que se completen una o varias tareas
Tareas y referencia cultural
Para desarrolladores del depurador

Creación de instancias de tareas

En el ejemplo siguiente se crean y ejecutan cuatro tareas. Tres tareas ejecutan un Action<T> delegado denominado action, que acepta un argumento de tipo Object. Una cuarta tarea ejecuta una expresión lambda (un Action delegado) que se define insertada en la llamada al método de creación de tareas. Se crea una instancia de cada tarea y se ejecuta de una manera diferente:

  • La tarea t1 se crea mediante una llamada a un constructor de clase Task, pero se inicia llamando a su Start() método solo después de que se haya iniciado la tarea t2 .

  • Se crea una instancia de la tarea t2 y se inicia en una sola llamada de método mediante una llamada al TaskFactory.StartNew(Action<Object>, Object) método .

  • Se crea una instancia de la tarea t3 y se inicia en una sola llamada de método mediante una llamada al Run(Action) método .

  • La tarea t4 se ejecuta sincrónicamente en el subproceso principal mediante una llamada al RunSynchronously() método .

Dado que la tarea t4 se ejecuta sincrónicamente, se ejecuta en el subproceso de aplicación principal. Las tareas restantes se ejecutan de forma asincrónica normalmente en uno o varios subprocesos del grupo de subprocesos.

using System;
using System.Threading;
using System.Threading.Tasks;

class Example
{
    static void Main()
    {
        Action<object> action = (object obj) =>
                                {
                                   Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                   Task.CurrentId, obj,
                                   Thread.CurrentThread.ManagedThreadId);
                                };

        // Create a task but do not start it.
        Task t1 = new Task(action, "alpha");

        // Construct a started task
        Task t2 = Task.Factory.StartNew(action, "beta");
        // Block the main thread to demonstrate that t2 is executing
        t2.Wait();

        // Launch t1 
        t1.Start();
        Console.WriteLine("t1 has been launched. (Main Thread={0})",
                          Thread.CurrentThread.ManagedThreadId);
        // Wait for the task to finish.
        t1.Wait();

        // Construct a started task using Task.Run.
        String taskData = "delta";
        Task t3 = Task.Run( () => {Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                                     Task.CurrentId, taskData,
                                                      Thread.CurrentThread.ManagedThreadId);
                                   });
        // Wait for the task to finish.
        t3.Wait();

        // Construct an unstarted task
        Task t4 = new Task(action, "gamma");
        // Run it synchronously
        t4.RunSynchronously();
        // Although the task was run synchronously, it is a good practice
        // to wait for it in the event exceptions were thrown by the task.
        t4.Wait();
    }
}
// The example displays output like the following:
//       Task=1, obj=beta, Thread=3
//       t1 has been launched. (Main Thread=1)
//       Task=2, obj=alpha, Thread=4
//       Task=3, obj=delta, Thread=3
//       Task=4, obj=gamma, Thread=1
Imports System.Threading
Imports System.Threading.Tasks

Module Example
    Public Sub Main()
        Dim action As Action(Of Object) = 
              Sub(obj As Object)
                 Console.WriteLine("Task={0}, obj={1}, Thread={2}", 
                 Task.CurrentId, obj,
                 Thread.CurrentThread.ManagedThreadId)
              End Sub

        ' Construct an unstarted task
        Dim t1 As New Task(action, "alpha")

        ' Construct a started task
        Dim t2 As Task = Task.Factory.StartNew(action, "beta")
        ' Block the main thread to demonstrate that t2 is executing
        t2.Wait()

        ' Launch t1 
        t1.Start()
        Console.WriteLine("t1 has been launched. (Main Thread={0})",
                          Thread.CurrentThread.ManagedThreadId)
        ' Wait for the task to finish.
        t1.Wait()

        ' Construct a started task using Task.Run.
        Dim taskData As String = "delta"
        Dim t3 As Task = Task.Run(Sub()
                                     Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                     Task.CurrentId, taskData,
                                     Thread.CurrentThread.ManagedThreadId)
                                  End Sub)
        ' Wait for the task to finish.
        t3.Wait()
        
        ' Construct an unstarted task
        Dim t4 As New Task(action, "gamma")
        ' Run it synchronously
        t4.RunSynchronously()
        ' Although the task was run synchronously, it is a good practice
        ' to wait for it in the event exceptions were thrown by the task.
        t4.Wait()
    End Sub
End Module
' The example displays output like the following:
'       Task=1, obj=beta, Thread=3
'       t1 has been launched. (Main Thread=1)
'       Task=2, obj=alpha, Thread=3
'       Task=3, obj=delta, Thread=3
'       Task=4, obj=gamma, Thread=1

Creación y ejecución de una tarea

Task Las instancias se pueden crear de varias maneras. El enfoque más común, que está disponible a partir de .NET Framework 4.5, es llamar al método estático Run . El Run método proporciona una manera sencilla de iniciar una tarea con valores predeterminados y sin necesidad de parámetros adicionales. En el ejemplo siguiente se usa el Run(Action) método para iniciar una tarea que se repite y, a continuación, se muestra el número de iteraciones de bucle:

using System;
using System.Threading.Tasks;

public class Example
{
   public static async Task Main()
   {
      await Task.Run( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Run(Sub()
                                  ' Just loop.
                                  Dim ctr As Integer = 0
                                  For ctr = 0 to 1000000
                                  Next
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr)
                               End Sub)
      t.Wait()
   End Sub
End Module
' The example displays the following output:
'       Finished 1000001 loop iterations

Una alternativa, y el método más común para iniciar una tarea en .NET Framework 4, es el método estático TaskFactory.StartNew . El Task.Factory propiedad devuelve un TaskFactory objeto. Las sobrecargas del TaskFactory.StartNew método permiten especificar parámetros para pasar a las opciones de creación de tareas y un programador de tareas. En el ejemplo siguiente se usa el TaskFactory.StartNew método para iniciar una tarea. Es funcionalmente equivalente al código del ejemplo anterior.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Factory.StartNew( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
      t.Wait();
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Factory.StartNew(Sub()
                                  ' Just loop.
                                  Dim ctr As Integer = 0
                                  For ctr = 0 to 1000000
                                  Next
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr)
                               End Sub)
      t.Wait()
   End Sub
End Module
' The example displays the following output:
'       Finished 1000001 loop iterations

Para obtener ejemplos más completos, vea Programación asincrónica basada en tareas.

Separación de la creación y ejecución de tareas

La Task clase también proporciona constructores que inicializan la tarea, pero que no la programan para su ejecución. Por motivos de rendimiento, el Task.Run método o TaskFactory.StartNew es el mecanismo preferido para crear y programar tareas computacionales, pero en escenarios en los que se deben separar la creación y programación, puede usar los constructores y, a continuación, llamar al Task.Start método para programar la tarea para su ejecución más adelante.

Esperar a que se completen una o varias tareas

Dado que las tareas normalmente se ejecutan de forma asincrónica en un subproceso de grupo de subprocesos, el subproceso que crea e inicia la tarea continúa la ejecución en cuanto se ha creado una instancia de la tarea. En algunos casos, cuando el subproceso que realiza la llamada es el subproceso de aplicación principal, la aplicación puede finalizar antes de que la tarea comience realmente a ejecutarse. En otros, la lógica de la aplicación puede requerir que el subproceso que realiza la llamada continúe la ejecución solo cuando una o varias tareas hayan completado la ejecución. Puede sincronizar la ejecución del subproceso que realiza la llamada y las tareas asincrónicas que inicia llamando a un Wait método para esperar a que se completen una o varias tareas.

Para esperar a que se complete una sola tarea, puede llamar a su Task.Wait método . Una llamada al Wait método bloquea el subproceso que realiza la llamada hasta que la instancia de clase única haya completado la ejecución.

En el ejemplo siguiente se llama al método sin Wait() parámetros para esperar incondicionalmente hasta que se completa una tarea. La tarea simula el trabajo llamando al Thread.Sleep método para que se suspenda durante dos segundos.

using System;   
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static Random rand = new Random();

    static void Main()
    {
        // Wait on a single task with no timeout specified.
        Task taskA = Task.Run( () => Thread.Sleep(2000));
        Console.WriteLine("taskA Status: {0}", taskA.Status);
        try {
          taskA.Wait();
          Console.WriteLine("taskA Status: {0}", taskA.Status);
       } 
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }   
    }    
}
// The example displays output like the following:
//     taskA Status: WaitingToRun
//     taskA Status: RanToCompletion
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait on a single task with no timeout specified.
      Dim taskA = Task.Run( Sub() Thread.Sleep(2000))
      Console.WriteLine("taskA Status: {0}", taskA.Status)
      Try
        taskA.Wait()
        Console.WriteLine("taskA Status: {0}", taskA.Status)
      Catch e As AggregateException
         Console.WriteLine("Exception in taskA.")
      End Try
   End Sub
End Module
' The example displays output like the following:
'     taskA Status: WaitingToRun
'     taskA Status: RanToCompletion

También puede esperar condicionalmente a que se complete una tarea. Los Wait(Int32) métodos y Wait(TimeSpan) bloquean el subproceso que llama hasta que finaliza la tarea o transcurre un intervalo de tiempo de espera, lo que ocurra primero. Dado que en el ejemplo siguiente se inicia una tarea que se suspende durante dos segundos, pero define un valor de tiempo de espera de un segundo, el subproceso que realiza la llamada se bloquea hasta que expire el tiempo de espera y antes de que la tarea haya completado la ejecución.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Wait on a single task with a timeout specified.
      Task taskA = Task.Run( () => Thread.Sleep(2000));
      try {
        taskA.Wait(1000);       // Wait for 1 second.
        bool completed = taskA.IsCompleted;
        Console.WriteLine("Task A completed: {0}, Status: {1}",
                         completed, taskA.Status);
        if (! completed)
           Console.WriteLine("Timed out before task A completed.");                 
       }
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }   
   }
}
// The example displays output like the following:
//     Task A completed: False, Status: Running
//     Timed out before task A completed.
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait on a single task with a timeout specified.
      Dim taskA As Task = Task.Run( Sub() Thread.Sleep(2000))
      Try
         taskA.Wait(1000)        ' Wait for 1 second.
         Dim completed As Boolean = taskA.IsCompleted
         Console.WriteLine("Task.Completed: {0}, Status: {1}",
                           completed, taskA.Status)
         If Not completed Then 
            Console.WriteLine("Timed out before task A completed.")
         End If                     
      Catch e As AggregateException
         Console.WriteLine("Exception in taskA.")
      End Try
   End Sub
End Module
' The example displays the following output:
'     Task A completed: False, Status: Running
'     Timed out before task A completed.

También puede proporcionar un token de cancelación llamando a los Wait(CancellationToken) métodos y Wait(Int32, CancellationToken) . Si la propiedad del IsCancellationRequested token es true o se convierte true en mientras se ejecuta el Wait método , el método produce una OperationCanceledExceptionexcepción .

En algunos casos, es posible que desee esperar a que se complete la primera de una serie de tareas en ejecución, pero no le importa qué tarea es. Para ello, puede llamar a una de las sobrecargas del Task.WaitAny método . En el ejemplo siguiente se crean tres tareas, cada una de las cuales se suspende durante un intervalo determinado por un generador de números aleatorios. El WaitAny(Task[]) método espera a que se complete la primera tarea. A continuación, en el ejemplo se muestra información sobre el estado de las tres tareas.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var tasks = new Task[3];
      var rnd = new Random();
      for (int ctr = 0; ctr <= 2; ctr++)
         tasks[ctr] = Task.Run( () => Thread.Sleep(rnd.Next(500, 3000)));

      try {
         int index = Task.WaitAny(tasks);
         Console.WriteLine("Task #{0} completed first.\n", tasks[index].Id);
         Console.WriteLine("Status of all tasks:");
         foreach (var t in tasks)
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
      }
      catch (AggregateException) {
         Console.WriteLine("An exception occurred.");
      }
   }
}
// The example displays output like the following:
//     Task #1 completed first.
//     
//     Status of all tasks:
//        Task #3: Running
//        Task #1: RanToCompletion
//        Task #4: Running
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks(2) As Task
      Dim rnd As New Random()
      For ctr As Integer = 0 To 2
         tasks(ctr) = Task.Run( Sub()  Thread.Sleep(rnd.Next(500, 3000)))
      Next
      
      Try 
         Dim index As Integer= Task.WaitAny(tasks)
         Console.WriteLine("Task #{0} completed first.", tasks(index).Id)
         Console.WriteLine()
         Console.WriteLine("Status of all tasks:")
         For Each t in tasks
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
         Next   
      Catch e As AggregateException
         Console.WriteLine("An exception occurred.")
      End Try
   End Sub
End Module
' The example displays output like the following:
'     Task #1 completed first.
'     
'     Status of all tasks:
'        Task #3: Running
'        Task #1: RanToCompletion
'        Task #4: Running

También puede esperar a que se completen todas las tareas mediante una llamada al WaitAll método . En el ejemplo siguiente se crean diez tareas, se espera a que se completen las diez y, a continuación, se muestra su estado.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Wait for all tasks to complete.
      Task[] tasks = new Task[10];
      for (int i = 0; i < 10; i++)
      {
          tasks[i] = Task.Run(() => Thread.Sleep(2000));
      }
      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
         Console.WriteLine("One or more exceptions occurred: ");
         foreach (var ex in ae.Flatten().InnerExceptions)
            Console.WriteLine("   {0}", ex.Message);
      }   

      Console.WriteLine("Status of completed tasks:");
      foreach (var t in tasks)
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
   }
}
// The example displays the following output:
//     Status of completed tasks:
//        Task #2: RanToCompletion
//        Task #1: RanToCompletion
//        Task #3: RanToCompletion
//        Task #4: RanToCompletion
//        Task #6: RanToCompletion
//        Task #5: RanToCompletion
//        Task #7: RanToCompletion
//        Task #8: RanToCompletion
//        Task #9: RanToCompletion
//        Task #10: RanToCompletion
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait for all tasks to complete.
      Dim tasks(9) As Task
      For i As Integer = 0 To 9
          tasks(i) = Task.Run( Sub() Thread.Sleep(2000) )
      Next
      Try 
         Task.WaitAll(tasks)
      Catch ae As AggregateException
         Console.WriteLine("One or more exceptions occurred: ")
         For Each ex In ae.Flatten().InnerExceptions
            Console.WriteLine("   {0}", ex.Message)
         Next
      End Try   

      Console.WriteLine("Status of completed tasks:")
      For Each t in tasks
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
      Next   
   End Sub
End Module
' The example displays the following output:
'     Status of completed tasks:
'        Task #2: RanToCompletion
'        Task #1: RanToCompletion
'        Task #3: RanToCompletion
'        Task #4: RanToCompletion
'        Task #6: RanToCompletion
'        Task #5: RanToCompletion
'        Task #7: RanToCompletion
'        Task #8: RanToCompletion
'        Task #9: RanToCompletion
'        Task #10: RanToCompletion

Tenga en cuenta que, al esperar a que se completen una o varias tareas, las excepciones producidas en las tareas en ejecución se propagan en el subproceso que llama al Wait método , como se muestra en el ejemplo siguiente. Inicia 12 tareas, tres de las cuales se completan normalmente y tres de las cuales inician una excepción. De las seis tareas restantes, se cancelan tres antes de comenzar, y tres se cancelan mientras se ejecutan. Las excepciones se inician en la WaitAll llamada al método y se controlan mediante un try/catch bloque .

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Create a cancellation token and cancel it.
      var source1 = new CancellationTokenSource();
      var token1 = source1.Token;
      source1.Cancel();
      // Create a cancellation token for later cancellation.
      var source2 = new CancellationTokenSource();
      var token2 = source2.Token;
       
      // Create a series of tasks that will complete, be cancelled, 
      // timeout, or throw an exception.
      Task[] tasks = new Task[12];
      for (int i = 0; i < 12; i++)
      {
          switch (i % 4) 
          {
             // Task should run to completion.
             case 0:
                tasks[i] = Task.Run(() => Thread.Sleep(2000));
                break;
             // Task should be set to canceled state.
             case 1:   
                tasks[i] = Task.Run( () => Thread.Sleep(2000),
                         token1);
                break;         
             case 2:
                // Task should throw an exception.
                tasks[i] = Task.Run( () => { throw new NotSupportedException(); } );
                break;
             case 3:
                // Task should examine cancellation token.
                tasks[i] = Task.Run( () => { Thread.Sleep(2000); 
                                             if (token2.IsCancellationRequested)
                                                token2.ThrowIfCancellationRequested();
                                             Thread.Sleep(500); }, token2);   
                break;
          }
      }
      Thread.Sleep(250);
      source2.Cancel();
       
      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
          Console.WriteLine("One or more exceptions occurred:");
          foreach (var ex in ae.InnerExceptions)
             Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message);
       }   

      Console.WriteLine("\nStatus of tasks:");
      foreach (var t in tasks) {
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
         if (t.Exception != null) {
            foreach (var ex in t.Exception.InnerExceptions)
               Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                 ex.Message);
         }
      }
   }
}
// The example displays output like the following:
//   One or more exceptions occurred:
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//   
//   Status of tasks:
//      Task #13: RanToCompletion
//      Task #1: Canceled
//      Task #3: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #8: Canceled
//      Task #14: RanToCompletion
//      Task #4: Canceled
//      Task #6: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #7: Canceled
//      Task #15: RanToCompletion
//      Task #9: Canceled
//      Task #11: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #12: Canceled
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Create a cancellation token and cancel it.
      Dim source1 As New CancellationTokenSource()
      Dim token1 As CancellationToken = source1.Token
      source1.Cancel()
      ' Create a cancellation token for later cancellation.
      Dim source2 As New CancellationTokenSource()
      Dim token2 As CancellationToken = source2.Token
       
      ' Create a series of tasks that will complete, be cancelled, 
      ' timeout, or throw an exception.
      Dim tasks(11) As Task
      For i As Integer = 0 To 11
          Select Case i Mod 4 
             ' Task should run to completion.
             Case 0
                tasks(i) = Task.Run( Sub() Thread.Sleep(2000))
             ' Task should be set to canceled state.
             Case 1   
                tasks(i) = Task.Run( Sub() Thread.Sleep(2000), token1)
             Case 2
                ' Task should throw an exception.
                tasks(i) = Task.Run( Sub() 
                                        Throw New NotSupportedException() 
                                     End Sub)
             Case 3
                ' Task should examine cancellation token.
                tasks(i) = Task.Run( Sub() 
                                        Thread.Sleep(2000) 
                                        If token2.IsCancellationRequested
                                           token2.ThrowIfCancellationRequested()
                                        End If
                                        Thread.Sleep(500) 
                                     End Sub, token2)   
          End Select
      Next
      Thread.Sleep(250)
      source2.Cancel()
       
      Try 
         Task.WaitAll(tasks)
      Catch ae As AggregateException
         Console.WriteLine("One or more exceptions occurred:")
         For Each ex in ae.InnerExceptions
             Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message)
         Next
      End Try   
      Console.WriteLine()
      
      Console.WriteLine("Status of tasks:")
      For Each t in tasks
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
         If t.Exception IsNot Nothing Then
            For Each ex in t.Exception.InnerExceptions
               Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                 ex.Message)
            Next
         End If
      Next
   End Sub
End Module
' The example displays output like the following:
'   One or more exceptions occurred:
'      TaskCanceledException: A task was canceled.
'      NotSupportedException: Specified method is not supported.
'      TaskCanceledException: A task was canceled.
'      TaskCanceledException: A task was canceled.
'      NotSupportedException: Specified method is not supported.
'      TaskCanceledException: A task was canceled.
'      TaskCanceledException: A task was canceled.
'      NotSupportedException: Specified method is not supported.
'      TaskCanceledException: A task was canceled.
'   
'   Status of tasks:
'      Task #13: RanToCompletion
'      Task #1: Canceled
'      Task #3: Faulted
'         NotSupportedException: Specified method is not supported.
'      Task #8: Canceled
'      Task #14: RanToCompletion
'      Task #4: Canceled
'      Task #6: Faulted
'         NotSupportedException: Specified method is not supported.
'      Task #7: Canceled
'      Task #15: RanToCompletion
'      Task #9: Canceled
'      Task #11: Faulted
'         NotSupportedException: Specified method is not supported.
'      Task #12: Canceled

Para obtener más información sobre el control de excepciones en las operaciones asincrónicas basadas en tareas, vea Control de excepciones.

Tareas y referencia cultural

A partir de las aplicaciones de escritorio destinadas a .NET Framework 4.6, la referencia cultural del subproceso que crea e invoca una tarea se convierte en parte del contexto del subproceso. Es decir, independientemente de la referencia cultural actual del subproceso en el que se ejecuta la tarea, la referencia cultural actual de la tarea es la referencia cultural del subproceso que realiza la llamada. En el caso de las aplicaciones destinadas a versiones de .NET Framework anteriores a .NET Framework 4.6, la referencia cultural de la tarea es la referencia cultural del subproceso en el que se ejecuta la tarea. Para obtener más información, vea la sección "Referencia cultural y operaciones asincrónicas basadas en tareas" del CultureInfo tema.

Nota

Las aplicaciones de la Tienda siguen el Windows Runtime en la configuración y la obtención de la referencia cultural predeterminada.

Para desarrolladores del depurador

Para los desarrolladores que implementan depuradores personalizados, pueden resultar útiles varios miembros internos y privados de la tarea (pueden cambiar de versión a versión). El m_taskId campo actúa como almacén de respaldo para la Id propiedad, pero el acceso a este campo directamente desde un depurador puede ser más eficaz que tener acceso al mismo valor a través del método getter de la propiedad (el s_taskIdCounter contador se usa para recuperar el siguiente identificador disponible para una tarea). Del mismo modo, el m_stateFlags campo almacena información sobre la fase actual del ciclo de vida de la tarea, también se puede acceder a la información a través de la Status propiedad . El m_action campo almacena una referencia al delegado de la tarea y el m_stateObject campo almacena el estado asincrónico pasado a la tarea por el desarrollador. Por último, para los depuradores que analizan marcos de pila, el InternalWait método sirve un marcador potencial para cuando una tarea entra en una operación de espera.

Constructores

Task(Action)

Inicializa una nueva instancia de Task con la acción especificada.

Task(Action, CancellationToken)

Inicializa una nueva instancia de Task con la acción especificada y CancellationToken.

Task(Action, CancellationToken, TaskCreationOptions)

Inicializa un nuevo objeto Task con la acción y las opciones de creación especificadas.

Task(Action, TaskCreationOptions)

Inicializa un nuevo objeto Task con la acción y las opciones de creación especificadas.

Task(Action<Object>, Object)

Inicializa una nueva instancia de Task con la acción y el estado especificados.

Task(Action<Object>, Object, CancellationToken)

Inicializa un nuevo objeto Task con la acción, el estado y las opciones especificados.

Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)

Inicializa un nuevo objeto Task con la acción, el estado y las opciones especificados.

Task(Action<Object>, Object, TaskCreationOptions)

Inicializa un nuevo objeto Task con la acción, el estado y las opciones especificados.

Propiedades

AsyncState

Obtiene el objeto de estado que se proporcionó al crearse el objeto Task, o null si no se proporcionó ningún objeto de estado.

CompletedTask

Obtiene una tarea que ya ha finalizado correctamente.

CreationOptions

Obtiene el objeto TaskCreationOptions usado para crear esta tarea.

CurrentId

Devuelve el identificador del objeto Task que se está ejecutando actualmente.

Exception

Obtiene la excepción AggregateException que causó la finalización prematura del objeto Task. Si Task se completó correctamente o no ha iniciado ninguna excepción, el valor devuelto será null.

Factory

Proporciona acceso a patrones de diseño para crear y configurar instancias de Task y Task<TResult>.

Id

Obtiene un identificador para esta instancia de Task.

IsCanceled

Obtiene un valor que indica si esta instancia de Task ha completado su ejecución debido a una cancelación.

IsCompleted

Obtiene un valor que indica si la tarea se ha completado.

IsCompletedSuccessfully

Obtiene si la tarea se ejecutó hasta completarse.

IsFaulted

Obtiene un valor que indica si el objeto Task se ha completado debido a una excepción no controlada.

Status

Obtiene el objeto TaskStatus de esta tarea.

Métodos

ConfigureAwait(Boolean)

Configura un awaiter utilizado para esperar a este objeto Task.

ContinueWith(Action<Task,Object>, Object)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta cuando el elemento Task de destino se completa.

ContinueWith(Action<Task,Object>, Object, CancellationToken)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y un token de cancelación y que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa.

ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y un token de cancelación y que se ejecuta cuando el elemento Task de destino se completa. La continuación se ejecuta según un conjunto de condiciones especificadas y usa un programador especificado.

ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta cuando el elemento Task de destino se completa. La continuación se ejecuta según un conjunto de condiciones especificadas.

ContinueWith(Action<Task,Object>, Object, TaskScheduler)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta de forma asincrónica cuando el elemento Task de destino se completa. La continuación usa un programador especificado.

ContinueWith(Action<Task>)

Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino.

ContinueWith(Action<Task>, CancellationToken)

Crea una continuación que recibe un token de cancelación y se ejecuta de forma asincrónica cuando el elemento Task de destino se completa.

ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que se ejecuta cuando se completa la tarea de destino según el elemento TaskContinuationOptions especificado. La continuación recibe un token de cancelación y usa un programador especificado.

ContinueWith(Action<Task>, TaskContinuationOptions)

Crea una continuación que se ejecuta cuando se completa la tarea de destino según el elemento TaskContinuationOptions especificado.

ContinueWith(Action<Task>, TaskScheduler)

Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino. La continuación usa un programador especificado.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor. La continuación recibe información de estado proporcionada por el autor de la llamada y un token de cancelación.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que se ejecuta según las opciones de continuación de la tarea especificadas cuando el elemento Task de destino se completa y devuelve un valor. La continuación recibe información de estado proporcionada por el autor de la llamada y un token de cancelación y usa el programador especificado.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)

Crea una continuación que se ejecuta según las opciones de continuación de la tarea especificadas cuando el elemento Task de destino se completa. La continuación recibe información de estado proporcionada por el autor de la llamada.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)

Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino. La continuación recibe información de estado proporcionada por el autor de la llamada y usa a un programador especificado.

ContinueWith<TResult>(Func<Task,TResult>)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task<TResult> de destino se completa y devuelve un valor.

ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor. La continuación recibe un token de cancelación.

ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que se ejecuta según las opciones de continuación especificadas y devuelve un valor. Se pasa un token de cancelación a la continuación y usa un programador especificado.

ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)

Crea una continuación que se ejecuta según las opciones de continuación especificadas y devuelve un valor.

ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor. La continuación usa un programador especificado.

Delay(Int32)

Crea una tarea que se completa después de un número especificado de milisegundos.

Delay(Int32, CancellationToken)

Crea una tarea cancelable que se completa después de un número especificado de milisegundos.

Delay(TimeSpan)

Crea una tarea que se completa después de un intervalo de tiempo especificado.

Delay(TimeSpan, CancellationToken)

Crea una tarea cancelable que se completa después de un intervalo de tiempo específico.

Dispose()

Libera todos los recursos usados por la instancia actual de la clase Task.

Dispose(Boolean)

Desecha el objeto Task y libera todos sus recursos no administrados.

Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.

(Heredado de Object)
FromCanceled(CancellationToken)

Crea una Task que se finaliza debido a la cancelación con un token de cancelación especificado.

FromCanceled<TResult>(CancellationToken)

Crea una Task<TResult> que se finaliza debido a la cancelación con un token de cancelación especificado.

FromException(Exception)

Crea una Task que finalizó con una excepción especificada.

FromException<TResult>(Exception)

Crea una Task<TResult> que finalizó con una excepción especificada.

FromResult<TResult>(TResult)

Crea un objeto Task<TResult> que se ha completado correctamente con el resultado especificado.

GetAwaiter()

Obtiene un awaiter utilizado para esperar a este objeto Task.

GetHashCode()

Sirve como la función hash predeterminada.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.

(Heredado de Object)
Run(Action)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un objeto Task que representa ese trabajo.

Run(Action, CancellationToken)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un objeto Task que representa ese trabajo. Un token de cancelación permite cancelar el trabajo si aún no se ha iniciado.

Run(Func<Task>)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un proxy para la tarea devuelta por function.

Run(Func<Task>, CancellationToken)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un proxy para la tarea devuelta por function. Un token de cancelación permite cancelar el trabajo si aún no se ha iniciado.

Run<TResult>(Func<Task<TResult>>)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un proxy para Task(TResult) que devuelve function. Un token de cancelación permite cancelar el trabajo si aún no se ha iniciado.

Run<TResult>(Func<Task<TResult>>, CancellationToken)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un proxy para Task(TResult) que devuelve function.

Run<TResult>(Func<TResult>)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un objeto Task<TResult> que representa ese trabajo. Un token de cancelación permite cancelar el trabajo si aún no se ha iniciado.

Run<TResult>(Func<TResult>, CancellationToken)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un objeto Task(TResult) que representa ese trabajo.

RunSynchronously()

Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler actual.

RunSynchronously(TaskScheduler)

Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler proporcionado.

Start()

Inicia el objeto Task, programando su ejecución en el objeto TaskScheduler actual.

Start(TaskScheduler)

Inicia el objeto Task, programando su ejecución en el objeto TaskScheduler especificado.

ToString()

Devuelve una cadena que representa el objeto actual.

(Heredado de Object)
Wait()

Espera a que se complete la ejecución del objeto Task.

Wait(CancellationToken)

Espera a que se complete la ejecución del objeto Task. La espera finalizará si un token de cancelación se cancela antes de que finalice la tarea.

Wait(Int32)

Espera a que el objeto Task complete la ejecución dentro de un número especificado de milisegundos.

Wait(Int32, CancellationToken)

Espera a que se complete la ejecución del objeto Task. La espera finalizará si transcurre un intervalo de tiempo de espera o un token de cancelación se cancela antes de que finalice la tarea.

Wait(TimeSpan)

Espera a que Task complete la ejecución dentro de un intervalo de tiempo especificado.

Wait(TimeSpan, CancellationToken)

Espera a que se complete la ejecución del objeto Task.

WaitAll(Task[])

Espera que se complete la ejecución de todos los objetos Task proporcionados.

WaitAll(Task[], CancellationToken)

Espera que se complete la ejecución de todos los objetos Task proporcionados, a menos que se cancele la espera.

WaitAll(Task[], Int32)

Espera a que todos los objetos proporcionados de Task completen la ejecución dentro de un número especificado de milisegundos.

WaitAll(Task[], Int32, CancellationToken)

Espera a que todos los objetos Task proporcionados completen la ejecución dentro de un número especificado de milisegundos o hasta que se cancele la espera.

WaitAll(Task[], TimeSpan)

Espera a que todos los objetos Task cancelables que se hayan proporcionado completen la ejecución en un intervalo de tiempo especificado.

WaitAny(Task[])

Espera a que se complete la ejecución de cualquiera de los objetos Task proporcionados.

WaitAny(Task[], CancellationToken)

Espera que se complete la ejecución de cualquiera de los objetos Task proporcionados, a menos que se cancele la espera.

WaitAny(Task[], Int32)

Espera a que cualquiera de los objetos Task que se hayan proporcionado complete su ejecución dentro de un número especificado de milisegundos.

WaitAny(Task[], Int32, CancellationToken)

Espera a que cualquiera de los objetos Task proporcionados complete la ejecución dentro de un número especificado de milisegundos o hasta que se cancele un token de cancelación.

WaitAny(Task[], TimeSpan)

Espera a que se complete la ejecución de cualquier objeto Task proporcionado en un intervalo de tiempo especificado.

WaitAsync(CancellationToken)

Obtiene un Task objeto que se completará cuando se Task complete o cuando se haya solicitado la cancelación especificada CancellationToken .

WaitAsync(TimeSpan)

Obtiene un Task objeto que se completará cuando Task finalice o cuando expire el tiempo de espera especificado.

WaitAsync(TimeSpan, CancellationToken)

Obtiene un Task objeto que se completará cuando Task finalice, cuando expire el tiempo de espera especificado o cuando se haya solicitado la cancelación especificada CancellationToken .

WhenAll(IEnumerable<Task>)

Crea una tarea que se completará cuando todos los objetos Task de una colección enumerable se hayan completado.

WhenAll(Task[])

Crea una tarea que se completará cuando todos los objetos Task de una matriz se hayan completado.

WhenAll<TResult>(IEnumerable<Task<TResult>>)

Crea una tarea que se completará cuando todos los objetos Task<TResult> de una colección enumerable se hayan completado.

WhenAll<TResult>(Task<TResult>[])

Crea una tarea que se completará cuando todos los objetos Task<TResult> de una matriz se hayan completado.

WhenAny(IEnumerable<Task>)

Crea una tarea que se completará cuando se haya completado cualquiera de las tareas proporcionadas.

WhenAny(Task, Task)

Crea una tarea que se finalizará cuando se haya completado cualquiera de las tareas proporcionadas.

WhenAny(Task[])

Crea una tarea que se completará cuando se haya completado cualquiera de las tareas proporcionadas.

WhenAny<TResult>(IEnumerable<Task<TResult>>)

Crea una tarea que se completará cuando se haya completado cualquiera de las tareas proporcionadas.

WhenAny<TResult>(Task<TResult>, Task<TResult>)

Crea una tarea que se finalizará cuando se haya completado cualquiera de las tareas proporcionadas.

WhenAny<TResult>(Task<TResult>[])

Crea una tarea que se completará cuando se haya completado cualquiera de las tareas proporcionadas.

Yield()

Crea una tarea que admite "await" que, de forma asincrónica, devuelve al contexto actual cuando es "awaited".

Implementaciones de interfaz explícitas

IAsyncResult.AsyncWaitHandle

Obtiene un identificador WaitHandle que se puede usar para esperar a que se complete la tarea.

IAsyncResult.CompletedSynchronously

Obtiene un valor que indica si la operación se ha completado sincrónicamente.

Métodos de extensión

DispatcherOperationWait(Task)

Espera indefinidamente a que se complete la DispatcherOperation subyacente.

DispatcherOperationWait(Task, TimeSpan)

Espera la cantidad de tiempo especificada para que se complete el DispatcherOperation subyacente.

IsDispatcherOperationTask(Task)

Devuelve un valor que indica si este Task está asociado con un DispatcherOperation.

AsAsyncAction(Task)

Devuelve una acción asincrónica de Windows Runtime que representa una tarea iniciada.

Se aplica a

Seguridad para subprocesos

Todos los miembros de Task, excepto para Dispose(), son seguros para subprocesos y se pueden usar desde varios subprocesos simultáneamente.

Consulte también