Task Task Task Task Class

Definición

Representa una operación asincrónica.Represents an asynchronous operation.

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

Comentarios

La clase Task representa una única operación que no devuelve un valor y que normalmente se ejecuta de forma asincrónica.The Task class represents a single operation that does not return a value and that usually executes asynchronously. los objetos Task son uno de los componentes centrales del modelo asincrónico basado en tareas que se presentó por primera vez en el .NET Framework 4.Task objects are one of the central components of the task-based asynchronous pattern first introduced in the .NET Framework 4. Dado que el trabajo realizado por un objeto Task normalmente se ejecuta de forma asincrónica en un subproceso del grupo de subprocesos en lugar de sincrónicamente en el subproceso principal de la aplicación, puede usar la propiedad Status, así como las propiedades IsCanceled, IsCompleted y IsFaulted, para determinar el estado de una tarea.Because the work performed by a Task object typically executes asynchronously on a thread pool thread rather than synchronously on the main application thread, you can use the Status property, as well as the IsCanceled, IsCompleted, and IsFaulted properties, to determine the state of a task. Normalmente, se usa una expresión lambda para especificar el trabajo que va a realizar la tarea.Most commonly, a lambda expression is used to specify the work that the task is to perform.

En el caso de las operaciones que devuelven valores, se usa la clase Task<TResult>.For operations that return values, you use the Task<TResult> class.

En esta sección:In this section:

Ejemplos de creación de instancias de tareas Task instantiation examples
Crear y ejecutar una tarea Creating and executing a task
Separación de la creación y ejecución de tareas Separating task creation and execution
Esperando a que una o varias tareas se completen Waiting for one or more tasks to complete
Tareas y referencia cultural Tasks and culture
Para desarrolladores del depuradorFor debugger developers

Creación de instancias de tareasTask instantiation

En el ejemplo siguiente se crean y ejecutan cuatro tareas.The following example creates and executes four tasks. Tres tareas ejecutan un delegado Action<T> denominado action, que acepta un argumento de tipo Object.Three tasks execute an Action<T> delegate named action, which accepts an argument of type Object. Una cuarta tarea ejecuta una expresión lambda (un delegado Action) que se define insertada en la llamada al método de creación de la tarea.A fourth task executes a lambda expression (an Action delegate) that is defined inline in the call to the task creation method. Se crea una instancia de cada tarea y se ejecuta de otra manera:Each task is instantiated and run in a different way:

  • Se crea una instancia de la tarea t1 llamando a un constructor de clase de tarea, pero se inicia llamando a su método Start() solo después de que se haya iniciado la tarea t2.Task t1 is instantiated by calling a Task class constructor, but is started by calling its Start() method only after task t2 has started.

  • Se crea una instancia de la tarea t2 y se inicia en una única llamada al método llamando al método TaskFactory.StartNew(Action<Object>, Object).Task t2 is instantiated and started in a single method call by calling the TaskFactory.StartNew(Action<Object>, Object) method.

  • Se crea una instancia de la tarea t3 y se inicia en una única llamada al método llamando al método Run(Action).Task t3 is instantiated and started in a single method call by calling the Run(Action) method.

  • La tarea t4 se ejecuta sincrónicamente en el subproceso principal llamando al método RunSynchronously().Task t4 is executed synchronously on the main thread by calling the RunSynchronously() method.

Dado que la tarea t4 se ejecuta sincrónicamente, se ejecuta en el subproceso de la aplicación principal.Because task t4 executes synchronously, it executes on the main application thread. Las tareas restantes se ejecutan asincrónicamente normalmente en uno o más subprocesos del grupo de subprocesos.The remaining tasks execute asynchronously typically on one or more thread pool threads.

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

Crear y ejecutar una tareaCreating and executing a task

las instancias de Task se pueden crear de varias maneras.Task instances may be created in a variety of ways. El enfoque más común, que está disponible a partir de .NET Framework 4.5.NET Framework 4.5, es llamar al método estático de Run.The most common approach, which is available starting with the .NET Framework 4.5.NET Framework 4.5, is to call the static Run method. El método Run proporciona una manera sencilla de iniciar una tarea con valores predeterminados y sin necesidad de parámetros adicionales.The Run method provides a simple way to start a task using default values and without requiring additional parameters. En el ejemplo siguiente se usa el método Run(Action) para iniciar una tarea que se repite y, a continuación, se muestra el número de iteraciones del bucle:The following example uses the Run(Action) method to start a task that loops and then displays the number of loop iterations:

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.NET Framework 4, es el método estático de TaskFactory.StartNew.An alternative, and the most common method to start a task in .NET Framework 4.NET Framework 4, is the static TaskFactory.StartNew method. El Task.Factory propiedad devuelve un TaskFactory objeto.The Task.Factory property returns a TaskFactory object. Las sobrecargas del método TaskFactory.StartNew permiten especificar los parámetros que se van a pasar a las opciones de creación de tareas y a un programador de tareas.Overloads of the TaskFactory.StartNew method let you specify parameters to pass to the task creation options and a task scheduler. En el ejemplo siguiente se usa el método TaskFactory.StartNew para iniciar una tarea.The following example uses the TaskFactory.StartNew method to start a task. Es funcionalmente equivalente al código del ejemplo anterior.It is functionally equivalent to the code in the previous example.

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.For more complete examples, see Task-based Asynchronous Programming.

Separación de la creación y ejecución de tareasSeparating task creation and execution

La clase Task también proporciona constructores que inicializan la tarea, pero que no la programan para su ejecución.The Task class also provides constructors that initialize the task but that do not schedule it for execution. Por motivos de rendimiento, el método Task.Run o TaskFactory.StartNew es el mecanismo preferido para crear y programar tareas de cálculo, pero para escenarios en los que se debe separar la creación y la programación, puede usar los constructores y, a continuación, llamar al método Task.Start. para programar la ejecución de la tarea más adelante.For performance reasons, the Task.Run or TaskFactory.StartNew method is the preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation and scheduling must be separated, you can use the constructors and then call the Task.Start method to schedule the task for execution at a later time.

Esperando a que se completen una o varias tareasWaiting for one or more tasks to complete

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.Because tasks typically run asynchronously on a thread pool thread, the thread that creates and starts the task continues execution as soon as the task has been instantiated. En algunos casos, cuando el subproceso de llamada es el subproceso de la aplicación principal, la aplicación puede finalizar antes de que la tarea comience realmente la ejecución.In some cases, when the calling thread is the main application thread, the app may terminate before any the task actually begins execution. 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 finalizado su ejecución.In others, your application's logic may require that the calling thread continue execution only when one or more tasks has completed execution. Puede sincronizar la ejecución del subproceso que realiza la llamada y las tareas asincrónicas que se inician llamando a un método Wait para esperar a que se completen una o más tareas.You can synchronize the execution of the calling thread and the asynchronous tasks it launches by calling a Wait method to wait for one or more tasks to complete.

Para esperar a que se complete una sola tarea, puede llamar a su método Task.Wait.To wait for a single task to complete, you can call its Task.Wait method. Una llamada al método Wait bloquea el subproceso que realiza la llamada hasta que se haya completado la ejecución de la instancia de clase única.A call to the Wait method blocks the calling thread until the single class instance has completed execution.

En el ejemplo siguiente se llama al método Wait() sin parámetros para esperar incondicionalmente hasta que se completa una tarea.The following example calls the parameterless Wait() method to wait unconditionally until a task completes. La tarea simula el trabajo llamando al método Thread.Sleep para que se suspenda durante dos segundos.The task simulates work by calling the Thread.Sleep method to sleep for two seconds.

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.You can also conditionally wait for a task to complete. Los métodos Wait(Int32) y Wait(TimeSpan) bloquean el subproceso que realiza la llamada hasta que finalice la tarea o transcurra un intervalo de tiempo de espera, lo que suceda primero.The Wait(Int32) and Wait(TimeSpan) methods block the calling thread until the task finishes or a timeout interval elapses, whichever comes first. 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 expira el tiempo de espera y antes de que la tarea haya finalizado la ejecución.Since the following example launches a task that sleeps for two seconds but defines a one-second timeout value, the calling thread blocks until the timeout expires and before the task has completed execution.

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 mediante una llamada a los métodos Wait(CancellationToken) y Wait(Int32, CancellationToken).You can also supply a cancellation token by calling the Wait(CancellationToken) and Wait(Int32, CancellationToken) methods. Si la propiedad IsCancellationRequested del token es true o se convierte en true mientras se está ejecutando el método Wait, el método produce una OperationCanceledException.If the token's IsCancellationRequested property is true or becomes true while the Wait method is executing, the method throws an OperationCanceledException.

En algunos casos, puede que desee esperar a que se complete la primera de una serie de tareas en ejecución, pero no se preocupe qué tarea es.In some cases, you may want to wait for the first of a series of executing tasks to complete, but don't care which task it is. Para este propósito, puede llamar a una de las sobrecargas del método Task.WaitAny.For this purpose, you can call one of the overloads of the Task.WaitAny method. En el ejemplo siguiente se crean tres tareas, cada una de las cuales suspende un intervalo determinado por un generador de números aleatorios.The following example creates three tasks, each of which sleeps for an interval determine by a random number generator. El método WaitAny(Task[]) espera a que se complete la primera tarea.The WaitAny(Task[]) method waits for the first task to complete. A continuación, en el ejemplo se muestra información sobre el estado de las tres tareas.The example then displays information about the status of all three tasks.

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 series de tareas llamando al método WaitAll.You can also wait for all of a series of tasks to complete by calling the WaitAll method. En el ejemplo siguiente se crean diez tareas, se espera a que se completen los diez y, a continuación, se muestra su estado.The following example creates ten tasks, waits for all ten to complete, and then displays their status.

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 cuando se espera 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 método Wait, como se muestra en el ejemplo siguiente.Note that when you wait for one or more tasks to complete, any exceptions thrown in the running tasks are propagated on the thread that calls the Wait method, as the following example shows. Inicia 12 tareas, tres de las cuales se completan normalmente y tres de las cuales inician una excepción.It launches 12 tasks, three of which complete normally and three of which throw an exception. De las seis tareas restantes, tres se cancelan antes de que se inicien y tres se cancelan mientras se ejecutan.Of the remaining six tasks, three are cancelled before they start, and three are cancelled while they are executing. Las excepciones se producen en la llamada al método WaitAll y se controlan mediante un bloque try/catch.Exceptions are thrown in the WaitAll method call and are handled by a try/catch block.

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.For more information on exception handling in task-based asynchronous operations, see Exception Handling.

Tareas y referencia culturalTasks and culture

A partir de las aplicaciones de escritorio que tienen como destino .NET Framework 4.6.NET Framework 4.6, la referencia cultural del subproceso que crea e invoca una tarea pasa a formar parte del contexto del subproceso.Starting with desktop apps that target the .NET Framework 4.6.NET Framework 4.6, the culture of the thread that creates and invokes a task becomes part of the thread's context. 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.That is, regardless of the current culture of the thread on which the task executes, the current culture of the task is the culture of the calling thread. En el caso de las aplicaciones destinadas a versiones del .NET Framework antes del .NET Framework 4.6.NET Framework 4.6, la referencia cultural de la tarea es la referencia cultural del subproceso en el que se ejecuta la tarea.For apps that target versions of the .NET Framework prior to the .NET Framework 4.6.NET Framework 4.6, the culture of the task is the culture of the thread on which the task executes. Para obtener más información, vea la sección "referencia cultural y operaciones asincrónicas basadas en tareas" del tema CultureInfo.For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic.

Nota

Las aplicaciones de la tienda siguen las Windows Runtime en configuración y obteniendo la referencia cultural predeterminada.Store apps follow the Windows Runtime in setting and getting the default culture.

Para desarrolladores del depuradorFor debugger developers

Para los desarrolladores que implementan depuradores personalizados, varios miembros internos y privados de tarea pueden ser útiles (pueden cambiar de una versión a una).For developers implementing custom debuggers, several internal and private members of task may be useful (these may change from release to release). El campo m_taskId actúa como la memoria auxiliar de la propiedad Id; sin embargo, el acceso a este campo directamente desde un depurador puede ser más eficaz que el acceso al mismo valor mediante el método de captador de la propiedad (el contador s_taskIdCounter se usa para recuperar el siguiente IDENTIFICADOR disponible para una tarea).The m_taskId field serves as the backing store for the Id property, however accessing this field directly from a debugger may be more efficient than accessing the same value through the property's getter method (the s_taskIdCounter counter is used to retrieve the next available ID for a task). Del mismo modo, el campo m_stateFlags almacena información sobre la fase actual del ciclo de vida de la tarea, la información también accesible a través de la propiedad Status.Similarly, the m_stateFlags field stores information about the current lifecycle stage of the task, information also accessible through the Status property. El campo m_action almacena una referencia al delegado de la tarea y el campo m_stateObject almacena el estado Async que el desarrollador ha pasado a la tarea.The m_action field stores a reference to the task's delegate, and the m_stateObject field stores the async state passed to the task by the developer. Por último, en el caso de los depuradores que analizan marcos de pila, el método InternalWait sirve para un marcador potencial cuando una tarea está entrando en una operación de espera.Finally, for debuggers that parse stack frames, the InternalWait method serves a potential marker for when a task is entering a wait operation.

Constructores

Task(Action) Task(Action) Task(Action) Task(Action)

Inicializa una nueva instancia de Task con la acción especificada.Initializes a new Task with the specified action.

Task(Action, CancellationToken) Task(Action, CancellationToken) Task(Action, CancellationToken) Task(Action, CancellationToken)

Inicializa una nueva instancia de Task con la acción especificada y CancellationToken.Initializes a new Task with the specified action and CancellationToken.

Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions)

Inicializa un nuevo objeto Task con la acción y las opciones de creación especificadas.Initializes a new Task with the specified action and creation options.

Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions)

Inicializa un nuevo objeto Task con la acción y las opciones de creación especificadas.Initializes a new Task with the specified action and creation options.

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

Inicializa una nueva instancia de Task con la acción y el estado especificados.Initializes a new Task with the specified action and state.

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

Inicializa un nuevo objeto Task con la acción, el estado y las opciones especificados.Initializes a new Task with the specified action, state, and options.

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

Inicializa un nuevo objeto Task con la acción, el estado y las opciones especificados.Initializes a new Task with the specified action, state, and options.

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

Inicializa un nuevo objeto Task con la acción, el estado y las opciones especificados.Initializes a new Task with the specified action, state, and options.

Propiedades

AsyncState AsyncState AsyncState 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.Gets the state object supplied when the Task was created, or null if none was supplied.

CompletedTask CompletedTask CompletedTask CompletedTask

Obtiene una tarea que ya ha finalizado correctamente.Gets a task that has already completed successfully.

CreationOptions CreationOptions CreationOptions CreationOptions

Obtiene el objeto TaskCreationOptions usado para crear esta tarea.Gets the TaskCreationOptions used to create this task.

CurrentId CurrentId CurrentId CurrentId

Devuelve el identificador del objeto Task que se está ejecutando actualmente.Returns the ID of the currently executing Task.

Exception Exception Exception Exception

Obtiene la excepción AggregateException que causó la finalización prematura del objeto Task.Gets the AggregateException that caused the Task to end prematurely. Si Task se completó correctamente o no ha iniciado ninguna excepción, el valor devuelto será null.If the Task completed successfully or has not yet thrown any exceptions, this will return null.

Factory Factory Factory Factory

Proporciona acceso a patrones de diseño para crear y configurar instancias de Task y Task<TResult>.Provides access to factory methods for creating and configuring Task and Task<TResult> instances.

Id Id Id Id

Obtiene un identificador para esta instancia de Task.Gets an ID for this Task instance.

IsCanceled IsCanceled IsCanceled IsCanceled

Obtiene un valor que indica si esta instancia de Task ha completado su ejecución debido a una cancelación.Gets whether this Task instance has completed execution due to being canceled.

IsCompleted IsCompleted IsCompleted IsCompleted

Obtiene un valor que indica si la tarea se ha completado.Gets a value that indicates whether the task has completed.

IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully

Obtiene si la tarea se ejecutó hasta completarse.Gets whether the task ran to completion.

IsFaulted IsFaulted IsFaulted IsFaulted

Obtiene un valor que indica si el objeto Task se ha completado debido a una excepción no controlada.Gets whether the Task completed due to an unhandled exception.

Status Status Status Status

Obtiene el objeto TaskStatus de esta tarea.Gets the TaskStatus of this task.

Métodos

ConfigureAwait(Boolean) ConfigureAwait(Boolean) ConfigureAwait(Boolean) ConfigureAwait(Boolean)

Configura un awaiter utilizado para esperar a este objeto Task.Configures an awaiter used to await this Task.

ContinueWith(Action<Task,Object>, Object) ContinueWith(Action<Task,Object>, Object) ContinueWith(Action<Task,Object>, Object) 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.Creates a continuation that receives caller-supplied state information and executes when the target Task completes.

ContinueWith(Action<Task,Object>, Object, CancellationToken) ContinueWith(Action<Task,Object>, Object, CancellationToken) ContinueWith(Action<Task,Object>, Object, CancellationToken) 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.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes asynchronously when the target Task completes.

ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) 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.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes when the target Task completes. La continuación se ejecuta según un conjunto de condiciones especificadas y usa un programador especificado.The continuation executes based on a set of specified conditions and uses a specified scheduler.

ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions) ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions) ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions) 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.Creates a continuation that receives caller-supplied state information and executes when the target Task completes. La continuación se ejecuta según un conjunto de condiciones especificadas.The continuation executes based on a set of specified conditions.

ContinueWith(Action<Task,Object>, Object, TaskScheduler) ContinueWith(Action<Task,Object>, Object, TaskScheduler) ContinueWith(Action<Task,Object>, Object, TaskScheduler) 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.Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. La continuación usa un programador especificado.The continuation uses a specified scheduler.

ContinueWith(Action<Task>) ContinueWith(Action<Task>) ContinueWith(Action<Task>) ContinueWith(Action<Task>)

Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino.Creates a continuation that executes asynchronously when the target Task completes.

ContinueWith(Action<Task>, CancellationToken) ContinueWith(Action<Task>, CancellationToken) ContinueWith(Action<Task>, CancellationToken) 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.Creates a continuation that receives a cancellation token and executes asynchronously when the target Task completes.

ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler) 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.Creates a continuation that executes when the target task competes according to the specified TaskContinuationOptions. La continuación recibe un token de cancelación y usa un programador especificado.The continuation receives a cancellation token and uses a specified scheduler.

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

Crea una continuación que se ejecuta cuando se completa la tarea de destino según el elemento TaskContinuationOptions especificado.Creates a continuation that executes when the target task completes according to the specified TaskContinuationOptions.

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

Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino.Creates a continuation that executes asynchronously when the target Task completes. La continuación usa un programador especificado.The continuation uses a specified scheduler.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object) ContinueWith<TResult>(Func<Task,Object,TResult>, Object) ContinueWith<TResult>(Func<Task,Object,TResult>, Object) 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.Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes and returns a value.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken) 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.Creates a continuation that executes asynchronously when the target Task completes and returns a value. La continuación recibe información de estado proporcionada por el autor de la llamada y un token de cancelación.The continuation receives caller-supplied state information and a cancellation token.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) 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.Creates a continuation that executes based on the specified task continuation options when the target Task completes and returns a value. 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.The continuation receives caller-supplied state information and a cancellation token and uses the specified scheduler.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions) 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.Creates a continuation that executes based on the specified task continuation options when the target Task completes. La continuación recibe información de estado proporcionada por el autor de la llamada.The continuation receives caller-supplied state information.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler) 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.Creates a continuation that executes asynchronously when the target Task completes. La continuación recibe información de estado proporcionada por el autor de la llamada y usa a un programador especificado.The continuation receives caller-supplied state information and uses a specified scheduler.

ContinueWith<TResult>(Func<Task,TResult>) ContinueWith<TResult>(Func<Task,TResult>) ContinueWith<TResult>(Func<Task,TResult>) 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.Creates a continuation that executes asynchronously when the target Task<TResult> completes and returns a value.

ContinueWith<TResult>(Func<Task,TResult>, CancellationToken) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken) 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.Creates a continuation that executes asynchronously when the target Task completes and returns a value. La continuación recibe un token de cancelación.The continuation receives a cancellation token.

ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler) 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.Creates a continuation that executes according to the specified continuation options and returns a value. Se pasa un token de cancelación a la continuación y usa un programador especificado.The continuation is passed a cancellation token and uses a specified scheduler.

ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions) 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.Creates a continuation that executes according to the specified continuation options and returns a value.

ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler) ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler) ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler) 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.Creates a continuation that executes asynchronously when the target Task completes and returns a value. La continuación usa un programador especificado.The continuation uses a specified scheduler.

Delay(Int32) Delay(Int32) Delay(Int32) Delay(Int32)

Crea una tarea que se completa después de un número especificado de milisegundos.Creates a task that completes after a specified number of milliseconds.

Delay(Int32, CancellationToken) Delay(Int32, CancellationToken) Delay(Int32, CancellationToken) Delay(Int32, CancellationToken)

Crea una tarea cancelable que se completa después de un número especificado de milisegundos.Creates a cancellable task that completes after a specified number of milliseconds.

Delay(TimeSpan) Delay(TimeSpan) Delay(TimeSpan) Delay(TimeSpan)

Crea una tarea que se completa después de un intervalo de tiempo especificado.Creates a task that completes after a specified time interval.

Delay(TimeSpan, CancellationToken) Delay(TimeSpan, CancellationToken) Delay(TimeSpan, CancellationToken) Delay(TimeSpan, CancellationToken)

Crea una tarea cancelable que se completa después de un intervalo de tiempo específico.Creates a cancellable task that completes after a specified time interval.

Dispose() Dispose() Dispose() Dispose()

Libera todos los recursos usados por la instancia actual de la clase Task.Releases all resources used by the current instance of the Task class.

Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Desecha el objeto Task y libera todos sus recursos no administrados.Disposes the Task, releasing all of its unmanaged resources.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
FromCanceled(CancellationToken) FromCanceled(CancellationToken) FromCanceled(CancellationToken) FromCanceled(CancellationToken)

Crea una Task que se finaliza debido a la cancelación con un token de cancelación especificado.Creates a Task that's completed due to cancellation with a specified cancellation token.

FromCanceled<TResult>(CancellationToken) FromCanceled<TResult>(CancellationToken) FromCanceled<TResult>(CancellationToken) FromCanceled<TResult>(CancellationToken)

Crea una Task<TResult> que se finaliza debido a la cancelación con un token de cancelación especificado.Creates a Task<TResult> that's completed due to cancellation with a specified cancellation token.

FromException(Exception) FromException(Exception) FromException(Exception) FromException(Exception)

Crea una Task que finalizó con una excepción especificada.Creates a Task that has completed with a specified exception.

FromException<TResult>(Exception) FromException<TResult>(Exception) FromException<TResult>(Exception) FromException<TResult>(Exception)

Crea una Task<TResult> que finalizó con una excepción especificada.Creates a Task<TResult> that's completed with a specified exception.

FromResult<TResult>(TResult) FromResult<TResult>(TResult) FromResult<TResult>(TResult) FromResult<TResult>(TResult)

Crea un objeto Task<TResult> que se ha completado correctamente con el resultado especificado.Creates a Task<TResult> that's completed successfully with the specified result.

GetAwaiter() GetAwaiter() GetAwaiter() GetAwaiter()

Obtiene un awaiter utilizado para esperar a este objeto Task.Gets an awaiter used to await this Task.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

(Inherited from Object)
Run(Action) Run(Action) Run(Action) Run(Action)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un objeto Task que representa ese trabajo.Queues the specified work to run on the thread pool and returns a Task object that represents that work.

Run(Action, CancellationToken) Run(Action, CancellationToken) Run(Action, CancellationToken) 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.Queues the specified work to run on the thread pool and returns a Task object that represents that work. Un token de cancelación permite cancelar el trabajo.A cancellation token allows the work to be cancelled.

Run(Func<Task>) Run(Func<Task>) Run(Func<Task>) 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.Queues the specified work to run on the thread pool and returns a proxy for the task returned by function.

Run(Func<Task>, CancellationToken) Run(Func<Task>, CancellationToken) Run(Func<Task>, CancellationToken) 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.Queues the specified work to run on the thread pool and returns a proxy for the task returned by function.

Run<TResult>(Func<Task<TResult>>) Run<TResult>(Func<Task<TResult>>) Run<TResult>(Func<Task<TResult>>) 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.Queues the specified work to run on the thread pool and returns a proxy for the Task(TResult) returned by function.

Run<TResult>(Func<Task<TResult>>, CancellationToken) Run<TResult>(Func<Task<TResult>>, CancellationToken) Run<TResult>(Func<Task<TResult>>, CancellationToken) 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.Queues the specified work to run on the thread pool and returns a proxy for the Task(TResult) returned by function.

Run<TResult>(Func<TResult>) Run<TResult>(Func<TResult>) Run<TResult>(Func<TResult>) 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.Queues the specified work to run on the thread pool and returns a Task<TResult> object that represents that work.

Run<TResult>(Func<TResult>, CancellationToken) Run<TResult>(Func<TResult>, CancellationToken) Run<TResult>(Func<TResult>, CancellationToken) 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.Queues the specified work to run on the thread pool and returns a Task(TResult) object that represents that work. Un token de cancelación permite cancelar el trabajo.A cancellation token allows the work to be cancelled.

RunSynchronously() RunSynchronously() RunSynchronously() RunSynchronously()

Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler actual.Runs the Task synchronously on the current TaskScheduler.

RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler)

Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler proporcionado.Runs the Task synchronously on the TaskScheduler provided.

Start() Start() Start() Start()

Inicia el objeto Task, programando su ejecución en el objeto TaskScheduler actual.Starts the Task, scheduling it for execution to the current TaskScheduler.

Start(TaskScheduler) Start(TaskScheduler) Start(TaskScheduler) Start(TaskScheduler)

Inicia el objeto Task, programando su ejecución en el objeto TaskScheduler especificado.Starts the Task, scheduling it for execution to the specified TaskScheduler.

ToString() ToString() ToString() ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Inherited from Object)
Wait() Wait() Wait() Wait()

Espera a que se complete la ejecución del objeto Task.Waits for the Task to complete execution.

Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken)

Espera a que se complete la ejecución del objeto Task.Waits for the Task to complete execution. La espera finalizará si un token de cancelación se cancela antes de que finalice la tarea.The wait terminates if a cancellation token is canceled before the task completes.

Wait(Int32) Wait(Int32) Wait(Int32) Wait(Int32)

Espera a que el objeto Task complete la ejecución dentro de un número especificado de milisegundos.Waits for the Task to complete execution within a specified number of milliseconds.

Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken)

Espera a que se complete la ejecución del objeto Task.Waits for the Task to complete execution. 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.The wait terminates if a timeout interval elapses or a cancellation token is canceled before the task completes.

Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan)

Espera a que Task complete la ejecución dentro de un intervalo de tiempo especificado.Waits for the Task to complete execution within a specified time interval.

WaitAll(Task[]) WaitAll(Task[]) WaitAll(Task[]) WaitAll(Task[])

Espera que se complete la ejecución de todos los objetos Task proporcionados.Waits for all of the provided Task objects to complete execution.

WaitAll(Task[], CancellationToken) WaitAll(Task[], CancellationToken) WaitAll(Task[], CancellationToken) WaitAll(Task[], CancellationToken)

Espera que se complete la ejecución de todos los objetos Task proporcionados, a menos que se cancele la espera.Waits for all of the provided Task objects to complete execution unless the wait is cancelled.

WaitAll(Task[], Int32) WaitAll(Task[], Int32) WaitAll(Task[], Int32) WaitAll(Task[], Int32)

Espera a que todos los objetos proporcionados de Task completen la ejecución dentro de un número especificado de milisegundos.Waits for all of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAll(Task[], Int32, CancellationToken) WaitAll(Task[], Int32, CancellationToken) WaitAll(Task[], Int32, CancellationToken) 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.Waits for all of the provided Task objects to complete execution within a specified number of milliseconds or until the wait is cancelled.

WaitAll(Task[], TimeSpan) WaitAll(Task[], TimeSpan) WaitAll(Task[], TimeSpan) 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.Waits for all of the provided cancellable Task objects to complete execution within a specified time interval.

WaitAny(Task[]) WaitAny(Task[]) WaitAny(Task[]) WaitAny(Task[])

Espera a que se complete la ejecución de cualquiera de los objetos Task proporcionados.Waits for any of the provided Task objects to complete execution.

WaitAny(Task[], CancellationToken) WaitAny(Task[], CancellationToken) WaitAny(Task[], CancellationToken) WaitAny(Task[], CancellationToken)

Espera que se complete la ejecución de cualquiera de los objetos Task proporcionados, a menos que se cancele la espera.Waits for any of the provided Task objects to complete execution unless the wait is cancelled.

WaitAny(Task[], Int32) WaitAny(Task[], Int32) WaitAny(Task[], Int32) 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.Waits for any of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAny(Task[], Int32, CancellationToken) WaitAny(Task[], Int32, CancellationToken) WaitAny(Task[], Int32, CancellationToken) 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.Waits for any of the provided Task objects to complete execution within a specified number of milliseconds or until a cancellation token is cancelled.

WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan)

Espera a que se complete la ejecución de cualquier objeto Task proporcionado en un intervalo de tiempo especificado.Waits for any of the provided Task objects to complete execution within a specified time interval.

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

Crea una tarea que se completará cuando todos los objetos Task de una colección enumerable se hayan completado.Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[])

Crea una tarea que se completará cuando todos los objetos Task de una matriz se hayan completado.Creates a task that will complete when all of the Task objects in an array have completed.

WhenAll<TResult>(IEnumerable<Task<TResult>>) WhenAll<TResult>(IEnumerable<Task<TResult>>) WhenAll<TResult>(IEnumerable<Task<TResult>>) 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.Creates a task that will complete when all of the Task<TResult> objects in an enumerable collection have completed.

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

Crea una tarea que se completará cuando todos los objetos Task<TResult> de una matriz se hayan completado.Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

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

Crea una tarea que se completará cuando se haya completado cualquiera de las tareas proporcionadas.Creates a task that will complete when any of the supplied tasks have completed.

WhenAny(Task[]) WhenAny(Task[]) WhenAny(Task[]) WhenAny(Task[])

Crea una tarea que se completará cuando se haya completado cualquiera de las tareas proporcionadas.Creates a task that will complete when any of the supplied tasks have completed.

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

Crea una tarea que se completará cuando se haya completado cualquiera de las tareas proporcionadas.Creates a task that will complete when any of the supplied tasks have completed.

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

Crea una tarea que se completará cuando se haya completado cualquiera de las tareas proporcionadas.Creates a task that will complete when any of the supplied tasks have completed.

Yield() Yield() Yield() Yield()

Crea una tarea que admite "await" que, de forma asincrónica, devuelve al contexto actual cuando es "awaited".Creates an awaitable task that asynchronously yields back to the current context when awaited.

Implementaciones de interfaz explícitas

IAsyncResult.AsyncWaitHandle IAsyncResult.AsyncWaitHandle IAsyncResult.AsyncWaitHandle IAsyncResult.AsyncWaitHandle

Obtiene un identificador WaitHandle que se puede usar para esperar a que se complete la tarea.Gets a WaitHandle that can be used to wait for the task to complete.

IAsyncResult.CompletedSynchronously IAsyncResult.CompletedSynchronously IAsyncResult.CompletedSynchronously IAsyncResult.CompletedSynchronously

Obtiene un valor que indica si la operación se ha completado sincrónicamente.Gets an indication of whether the operation completed synchronously.

Métodos de extensión

DispatcherOperationWait(Task) DispatcherOperationWait(Task) DispatcherOperationWait(Task) DispatcherOperationWait(Task)

Espera indefinidamente a que se complete la DispatcherOperation subyacente.Waits indefinitely for the underlying DispatcherOperation to complete.

DispatcherOperationWait(Task, TimeSpan) DispatcherOperationWait(Task, TimeSpan) DispatcherOperationWait(Task, TimeSpan) DispatcherOperationWait(Task, TimeSpan)

Espera la cantidad de tiempo especificada para que se complete el DispatcherOperation subyacente.Waits for the specified amount of time for the underlying DispatcherOperation to complete.

IsDispatcherOperationTask(Task) IsDispatcherOperationTask(Task) IsDispatcherOperationTask(Task) IsDispatcherOperationTask(Task)

Devuelve un valor que indica si este Task está asociado con un DispatcherOperation.Returns a value that indicates whether this Task is associated with a DispatcherOperation.

AsAsyncAction(Task) AsAsyncAction(Task) AsAsyncAction(Task) AsAsyncAction(Task)

Devuelve una acción asincrónica de Windows Runtime que representa una tarea iniciada.Returns a Windows Runtime asynchronous action that represents a started task.

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.All members of Task, except for Dispose(), are thread-safe and may be used from multiple threads concurrently.

Consulte también: