Task Task Task Task Class

Definição

Representa uma operação assíncrona.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
Herança
TaskTaskTaskTask
Derivado
Implementações

Comentários

A classe Task representa uma única operação que não retorna um valor e que geralmente é executada de forma assíncrona.The Task class represents a single operation that does not return a value and that usually executes asynchronously. os objetos Task são um dos componentes centrais do padrão assíncrono baseado em tarefa introduzidos pela primeira vez no .NET Framework 4.Task objects are one of the central components of the task-based asynchronous pattern first introduced in the .NET Framework 4. Como o trabalho executado por um objeto Task normalmente é executado de forma assíncrona em um thread do pool de threads em vez de sincronicamente no thread do aplicativo principal, você pode usar a propriedade Status, bem como as propriedades IsCanceled, IsCompleted e IsFaulted, para Determine o estado de uma tarefa.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, uma expressão lambda é usada para especificar o trabalho que a tarefa deve executar.Most commonly, a lambda expression is used to specify the work that the task is to perform.

Para operações que retornam valores, você usa a classe Task<TResult>.For operations that return values, you use the Task<TResult> class.

Nesta seção:In this section:

Exemplos de instanciação de tarefa Task instantiation examples
Criando e executando uma tarefa Creating and executing a task
Separando a criação e a execução da tarefa Separating task creation and execution
Aguardando a conclusão de uma ou mais tarefas Waiting for one or more tasks to complete
tarefas e cultura Tasks and culture
Para desenvolvedores de depuradorFor debugger developers

Instanciação de tarefaTask instantiation

O exemplo a seguir cria e executa quatro tarefas.The following example creates and executes four tasks. Três tarefas executam um delegado Action<T> denominado action, que aceita um argumento do tipo Object.Three tasks execute an Action<T> delegate named action, which accepts an argument of type Object. Uma quarta tarefa executa uma expressão lambda (um delegado Action) que é definida embutida na chamada para o método de criação de tarefa.A fourth task executes a lambda expression (an Action delegate) that is defined inline in the call to the task creation method. Cada tarefa é instanciada e executada de forma diferente:Each task is instantiated and run in a different way:

  • A tarefa t1 é instanciada chamando-se um construtor de classe de tarefa, mas é iniciada chamando seu método Start() somente depois que a tarefa t2 for iniciada.Task t1 is instantiated by calling a Task class constructor, but is started by calling its Start() method only after task t2 has started.

  • A tarefa t2 é instanciada e iniciada em uma única chamada de método chamando o 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.

  • A tarefa t3 é instanciada e iniciada em uma única chamada de método chamando o método Run(Action).Task t3 is instantiated and started in a single method call by calling the Run(Action) method.

  • A tarefa t4 é executada de forma síncrona no thread principal chamando o método RunSynchronously().Task t4 is executed synchronously on the main thread by calling the RunSynchronously() method.

Como a tarefa t4 é executada de forma síncrona, ela é executada no thread do aplicativo principal.Because task t4 executes synchronously, it executes on the main application thread. As tarefas restantes são executadas de forma assíncrona normalmente em um ou mais threads do pool de threads.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

Criando e executando uma tarefaCreating and executing a task

as instâncias Task podem ser criadas de várias maneiras.Task instances may be created in a variety of ways. A abordagem mais comum, que está disponível começando com o .NET Framework 4.5.NET Framework 4.5, é chamar o método estático 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. O método Run fornece uma maneira simples de iniciar uma tarefa usando valores padrão e sem exigir parâmetros adicionais.The Run method provides a simple way to start a task using default values and without requiring additional parameters. O exemplo a seguir usa o método Run(Action) para iniciar uma tarefa que executa um loop e, em seguida, exibe o número de iterações de loop: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

Uma alternativa e o método mais comum para iniciar uma tarefa no .NET Framework 4.NET Framework 4 é o método estático 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. A propriedade Task.Factory retorna um objeto TaskFactory.The Task.Factory property returns a TaskFactory object. Sobrecargas do método TaskFactory.StartNew permitem especificar parâmetros a serem passados para as opções de criação de tarefa e um Agendador de tarefas.Overloads of the TaskFactory.StartNew method let you specify parameters to pass to the task creation options and a task scheduler. O exemplo a seguir usa o método TaskFactory.StartNew para iniciar uma tarefa.The following example uses the TaskFactory.StartNew method to start a task. É funcionalmente equivalente ao código no exemplo 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 obter exemplos mais completos, consulte programação assíncrona baseada em tarefas.For more complete examples, see Task-based Asynchronous Programming.

Separando a criação e a execução da tarefaSeparating task creation and execution

A classe Task também fornece construtores que inicializam a tarefa, mas que não o agendam para execução.The Task class also provides constructors that initialize the task but that do not schedule it for execution. Por motivos de desempenho, o método Task.Run ou TaskFactory.StartNew é o mecanismo preferido para criar e agendar tarefas computacionais, mas para cenários em que a criação e o agendamento devem ser separados, você pode usar os construtores e, em seguida, chamar o método Task.Start para agendar a execução da tarefa em um momento posterior.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.

Aguardando a conclusão de uma ou mais tarefasWaiting for one or more tasks to complete

Como as tarefas normalmente são executadas de forma assíncrona em um thread de pool de threads, o thread que cria e inicia a tarefa continua a execução assim que a tarefa tiver sido instanciada.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. Em alguns casos, quando o thread de chamada é o thread do aplicativo principal, o aplicativo pode ser encerrado antes de qualquer tarefa realmente começar a execução.In some cases, when the calling thread is the main application thread, the app may terminate before any the task actually begins execution. Em outros, a lógica do seu aplicativo pode exigir que o thread de chamada continue a execução somente quando uma ou mais tarefas tiverem concluído a execução.In others, your application's logic may require that the calling thread continue execution only when one or more tasks has completed execution. Você pode sincronizar a execução do thread de chamada e as tarefas assíncronas que ele inicia chamando um método Wait para aguardar a conclusão de uma ou mais tarefas.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 aguardar a conclusão de uma única tarefa, você pode chamar seu método Task.Wait.To wait for a single task to complete, you can call its Task.Wait method. Uma chamada para o método Wait bloqueia o thread de chamada até que a instância de classe única tenha concluído a execução.A call to the Wait method blocks the calling thread until the single class instance has completed execution.

O exemplo a seguir chama o método Wait() sem parâmetros para aguardar incondicionalmente até que uma tarefa seja concluída.The following example calls the parameterless Wait() method to wait unconditionally until a task completes. A tarefa simula o trabalho chamando o método Thread.Sleep como Sleep por dois 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

Você também pode aguardar a conclusão de uma tarefa condicionalmente.You can also conditionally wait for a task to complete. Os métodos Wait(Int32) e Wait(TimeSpan) bloqueiam o thread de chamada até que a tarefa seja concluída ou um intervalo de tempo limite decorra, o que ocorrer primeiro.The Wait(Int32) and Wait(TimeSpan) methods block the calling thread until the task finishes or a timeout interval elapses, whichever comes first. Como o exemplo a seguir inicia uma tarefa que é suspensa por dois segundos, mas define um valor de tempo limite de um segundo, o thread de chamada é bloqueado até que o tempo limite expire e antes que a tarefa tenha concluído a execução.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.

Você também pode fornecer um token de cancelamento chamando os métodos Wait(CancellationToken) e Wait(Int32, CancellationToken).You can also supply a cancellation token by calling the Wait(CancellationToken) and Wait(Int32, CancellationToken) methods. Se a propriedade IsCancellationRequested do token for true ou se tornar true enquanto o método Wait estiver em execução, o método lançará um OperationCanceledException.If the token's IsCancellationRequested property is true or becomes true while the Wait method is executing, the method throws an OperationCanceledException.

Em alguns casos, talvez você queira aguardar até que a primeira série de tarefas em execução seja concluída, mas não se preocupe com a tarefa.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 essa finalidade, você pode chamar uma das sobrecargas do método Task.WaitAny.For this purpose, you can call one of the overloads of the Task.WaitAny method. O exemplo a seguir cria três tarefas, cada uma das quais é suspenso por um intervalo determinado por um gerador de números aleatórios.The following example creates three tasks, each of which sleeps for an interval determine by a random number generator. O método WaitAny(Task[]) aguarda a conclusão da primeira tarefa.The WaitAny(Task[]) method waits for the first task to complete. Em seguida, o exemplo exibe informações sobre o status de todas as três tarefas.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

Você também pode aguardar a conclusão de todas as várias tarefas chamando o método WaitAll.You can also wait for all of a series of tasks to complete by calling the WaitAll method. O exemplo a seguir cria dez tarefas, aguarda que todas as dez sejam concluídas e, em seguida, exibe seu status.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

Observe que quando você aguarda a conclusão de uma ou mais tarefas, todas as exceções geradas nas tarefas em execução são propagadas no thread que chama o método Wait, como mostra o exemplo a seguir.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. Ele inicia 12 tarefas, três das quais são concluídas normalmente e três das quais geram uma exceção.It launches 12 tasks, three of which complete normally and three of which throw an exception. Das seis tarefas restantes, três são canceladas antes de serem iniciadas e três são canceladas enquanto estão em execução.Of the remaining six tasks, three are cancelled before they start, and three are cancelled while they are executing. As exceções são geradas na chamada do método WaitAll e são manipuladas por um bloco 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 obter mais informações sobre o tratamento de exceções em operações assíncronas baseadas em tarefas, consulte manipulação de exceção.For more information on exception handling in task-based asynchronous operations, see Exception Handling.

Tarefas e culturaTasks and culture

A partir de aplicativos de área de trabalho que se destinam ao .NET Framework 4.6.NET Framework 4.6, a cultura do thread que cria e invoca uma tarefa torna-se parte do contexto do thread.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. Ou seja, independentemente da cultura atual do thread no qual a tarefa é executada, a cultura atual da tarefa é a cultura do thread de chamada.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. Para aplicativos que visam versões do .NET Framework antes do .NET Framework 4.6.NET Framework 4.6, a cultura da tarefa é a cultura do thread no qual a tarefa é executada.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 obter mais informações, consulte a seção "operações assíncronas baseadas em cultura e tarefa" no tópico CultureInfo.For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic.

Observação

Os aplicativos da loja seguem a Windows Runtime na configuração e obtenção da cultura padrão.Store apps follow the Windows Runtime in setting and getting the default culture.

Para desenvolvedores de depuradorFor debugger developers

Para os desenvolvedores que implementam depuradores personalizados, vários membros internos e privados da tarefa podem ser úteis (eles podem mudar de liberação para liberação).For developers implementing custom debuggers, several internal and private members of task may be useful (these may change from release to release). O campo m_taskId serve como repositório de backup para a propriedade Id, no entanto, acessar esse campo diretamente de um depurador pode ser mais eficiente do que acessar o mesmo valor por meio do método getter da propriedade (o contador s_taskIdCounter é usado para recuperar o próximo ID disponível para uma tarefa).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). Da mesma forma, o campo m_stateFlags armazena informações sobre o estágio atual do ciclo de vida da tarefa, as informações também podem ser acessadas por meio da propriedade Status.Similarly, the m_stateFlags field stores information about the current lifecycle stage of the task, information also accessible through the Status property. O campo m_action armazena uma referência ao delegado da tarefa e o campo m_stateObject armazena o estado assíncrono passado para a tarefa pelo desenvolvedor.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 fim, para os depuradores que analisam os quadros de pilha, o método InternalWait atende a um marcador potencial para quando uma tarefa está entrando em uma operação 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.

Construtores

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

Inicializa um novo Task com a ação especificada.Initializes a new Task with the specified action.

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

Inicializa um novo Task com a ação especificada e 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 um novo Task com a ação especificada e opções de criação.Initializes a new Task with the specified action and creation options.

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

Inicializa um novo Task com a ação especificada e opções de criação.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 um novo Task com a ação especificada e estado.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 um novo Task com a ação, o estado e as opções 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 um novo Task com a ação, o estado e as opções 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 um novo Task com a ação, o estado e as opções especificados.Initializes a new Task with the specified action, state, and options.

Propriedades

AsyncState AsyncState AsyncState AsyncState

Obtém o objeto de estado fornecido quando o Task foi criado ou nulo se não foi fornecido.Gets the state object supplied when the Task was created, or null if none was supplied.

CompletedTask CompletedTask CompletedTask CompletedTask

Obtém uma tarefa que já foi concluída com êxito.Gets a task that has already completed successfully.

CreationOptions CreationOptions CreationOptions CreationOptions

Obtém o TaskCreationOptions usado para criar esta tarefa.Gets the TaskCreationOptions used to create this task.

CurrentId CurrentId CurrentId CurrentId

Retorna a ID de execução que atualmente está executando Task.Returns the ID of the currently executing Task.

Exception Exception Exception Exception

Obtém o AggregateException que fez com que o Task fosse encerrado prematuramente.Gets the AggregateException that caused the Task to end prematurely. Se o Task tiver sido concluído com êxito ou ainda não tiver lançado exceções, isso retornará null.If the Task completed successfully or has not yet thrown any exceptions, this will return null.

Factory Factory Factory Factory

Fornece acesso a métodos de fábrica para criar e configurar as instâncias Task e Task<TResult>.Provides access to factory methods for creating and configuring Task and Task<TResult> instances.

Id Id Id Id

Obtém uma ID para esta instância Task.Gets an ID for this Task instance.

IsCanceled IsCanceled IsCanceled IsCanceled

Obtém se essa instância Task concluiu sua execução porque foi cancelada.Gets whether this Task instance has completed execution due to being canceled.

IsCompleted IsCompleted IsCompleted IsCompleted

Obtém um valor que indica se a tarefa foi concluída.Gets a value that indicates whether the task has completed.

IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully

Determina se a tarefa foi executada até a conclusão.Gets whether the task ran to completion.

IsFaulted IsFaulted IsFaulted IsFaulted

Obtém se o Task foi concluído devido a uma exceção sem tratamento.Gets whether the Task completed due to an unhandled exception.

Status Status Status Status

Obtém o TaskStatus dessa tarefa.Gets the TaskStatus of this task.

Métodos

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

Configura um awaiter usado para aguardar este 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)

Cria uma continuação que recebe informações de estado fornecidas pelo chamador e executa quando Task de destino for concluída.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)

Cria uma continuação que recebe informações de estado e um token de cancelamento fornecidos pelo chamador e que será executada de maneira assíncrona quando a Task de destino for concluída.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)

Cria uma continuação que recebe informações de estado e um token de cancelamento fornecidos pelo chamador e que será executada quando a Task de destino for concluída.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes when the target Task completes. A continuação é executada com base em um conjunto de condições especificadas e usa um agendador 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)

Cria uma continuação que recebe informações de estado fornecidas pelo chamador e executa quando Task de destino for concluída.Creates a continuation that receives caller-supplied state information and executes when the target Task completes. A continuação é executada com base em um conjunto de condições 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)

Cria uma continuação que recebe informações de estado fornecidas pelo chamador e executa de forma assíncrona quando o destino Task for concluído.Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. A continuação usa um agendador especificado.The continuation uses a specified scheduler.

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

Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído.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)

Cria uma continuação que recebe um token de cancelamento e é executada de forma assíncrona quando o Task de destino é concluído.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)

Cria uma continuação que é executada quando a tarefa de destino compete conforme o TaskContinuationOptions especificado.Creates a continuation that executes when the target task competes according to the specified TaskContinuationOptions. A continuação recebe um token de cancelamento e usa um agendador 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)

Cria uma continuação que é executada quando a tarefa de destino é concluída conforme o 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)

Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído.Creates a continuation that executes asynchronously when the target Task completes. A continuação usa um agendador 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)

Cria uma continuação que recebe informações de estado fornecidas pelo chamador e que é executada de forma assíncrona quando o Task de destino é concluído e retorna um 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)

Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído e retornar um valor.Creates a continuation that executes asynchronously when the target Task completes and returns a value. A continuação recebe informações de estado fornecido pelo chamador e um token de cancelamento.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)

Cria uma continuação executada com base nas opções de continuação de tarefas especificadas quando o Task de destino for concluído e retornar um valor.Creates a continuation that executes based on the specified task continuation options when the target Task completes and returns a value. A continuação recebe informações de estado fornecidas pelo chamador e um token de cancelamento e usa o agendador 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)

Cria uma continuação que é executada com base nas opções de continuação de tarefas especificadas quando o Task de destino é concluído.Creates a continuation that executes based on the specified task continuation options when the target Task completes. A continuação recebe informações de estado fornecidas pelo chamador.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)

Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído.Creates a continuation that executes asynchronously when the target Task completes. A continuação recebe informações de estado fornecidas pelo chamador e usa um agendador 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>)

Criará uma continuação executada de forma assíncrona quando o Task<TResult> de destino for concluído e retornar um 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)

Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído e retornar um valor.Creates a continuation that executes asynchronously when the target Task completes and returns a value. A continuação recebe um token de cancelamento.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)

Cria uma continuação que executa de acordo com as opções de continuação especificadas e retorna um valor.Creates a continuation that executes according to the specified continuation options and returns a value. Um token de cancelamento é passado à continuação e ela usa um agendador 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)

Cria uma continuação que executa de acordo com as opções de continuação especificadas e retorna um 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)

Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído e retornar um valor.Creates a continuation that executes asynchronously when the target Task completes and returns a value. A continuação usa um agendador especificado.The continuation uses a specified scheduler.

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

Cria uma tarefa que é concluída após um número especificado de milissegundos.Creates a task that completes after a specified number of milliseconds.

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

Cria uma tarefa cancelável concluída após um número especificado de milissegundos.Creates a cancellable task that completes after a specified number of milliseconds.

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

Cria uma tarefa que é concluída após um intervalo de tempo especificado.Creates a task that completes after a specified time interval.

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

Cria uma tarefa cancelável concluída após um intervalo de tempo especificado.Creates a cancellable task that completes after a specified time interval.

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

Libera todos os recursos usados pela instância atual da classe Task.Releases all resources used by the current instance of the Task class.

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

Descarta o Task, liberando todos os seus recursos não gerenciados.Disposes the Task, releasing all of its unmanaged resources.

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

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

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

Cria um Task que é concluído devido ao cancelamento com um token de cancelamento 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)

Cria um Task<TResult> que é concluído devido ao cancelamento com um token de cancelamento especificado.Creates a Task<TResult> that's completed due to cancellation with a specified cancellation token.

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

Cria um Task que foi concluído com uma exceção especificada.Creates a Task that has completed with a specified exception.

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

Cria um Task<TResult> que é concluído com uma exceção especificada.Creates a Task<TResult> that's completed with a specified exception.

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

Cria um Task<TResult> que é concluído com êxito com o resultado especificado.Creates a Task<TResult> that's completed successfully with the specified result.

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

Obtém um awaiter usado para aguardar este Task.Gets an awaiter used to await this Task.

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

Serve como a função de hash padrão.Serves as the default hash function.

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

Obtém o Type da instância atual.Gets the Type of the current instance.

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

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

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

Coloca o trabalho especificado em fila para execução no pool de threads e retorna um objeto Task que representa o trabalho.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)

Coloca o trabalho especificado em fila para execução no pool de threads e retorna um objeto Task que representa o trabalho.Queues the specified work to run on the thread pool and returns a Task object that represents that work. Um token de cancelamento permite que o trabalho seja cancelado.A cancellation token allows the work to be cancelled.

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

Coloca o trabalho especificado na fila para execução no pool de threads e retorna um proxy para a tarefa retornada pelo 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)

Coloca o trabalho especificado na fila para execução no pool de threads e retorna um proxy para a tarefa retornada pelo 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>>)

Coloca o trabalho especificado na fila para execução no pool de threads e retorna um proxy para Task(TResult) retornado por 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)

Coloca o trabalho especificado na fila para execução no pool de threads e retorna um proxy para Task(TResult) retornado por 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>)

Coloca o trabalho especificado em fila para execução no pool de threads e retorna um objeto Task<TResult> que representa o trabalho.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)

Coloca o trabalho especificado em fila para execução no pool de threads e retorna um objeto Task(TResult) que representa o trabalho.Queues the specified work to run on the thread pool and returns a Task(TResult) object that represents that work. Um token de cancelamento permite que o trabalho seja cancelado.A cancellation token allows the work to be cancelled.

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

Executa o Task de forma síncrona no TaskScheduler atual.Runs the Task synchronously on the current TaskScheduler.

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

Executa o Task de forma síncrona no TaskScheduler fornecido.Runs the Task synchronously on the TaskScheduler provided.

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

Inicia o Task, agendando-o para execução no TaskScheduler atual.Starts the Task, scheduling it for execution to the current TaskScheduler.

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

Inicia o Task, agendando-o para execução no TaskScheduler especificado.Starts the Task, scheduling it for execution to the specified TaskScheduler.

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

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

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

Aguarda o Task concluir a execução.Waits for the Task to complete execution.

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

Aguarda o Task concluir a execução.Waits for the Task to complete execution. A espera termina se um token de cancelamento for cancelado antes que a tarefa seja concluída.The wait terminates if a cancellation token is canceled before the task completes.

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

Aguarda o Task concluir a execução dentro de um número especificado. de milissegundos.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)

Aguarda o Task concluir a execução.Waits for the Task to complete execution. A espera termina se um intervalo de tempo limite expirar ou um token de cancelamento for cancelado antes que a tarefa seja concluída.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)

Aguarda o Task concluir a execução dentro de um intervalo especificado.Waits for the Task to complete execution within a specified time interval.

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

Aguarda até que todos os objetos Task fornecidos tenham concluído a execução.Waits for all of the provided Task objects to complete execution.

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

Aguarda até que todos os objetos Task fornecidos tenham concluído a execução, a menos que a espera seja cancelada.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)

Aguarda todos os objetos Task fornecidos concluírem a execução dentro de um número especificado de milissegundos.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)

Aguarda todos os objetos Task fornecidos concluírem a execução em um número especificado de milissegundos ou até que a espera seja cancelada.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)

Aguarda todos os objetos Task canceláveis fornecidos concluírem a execução dentro de um intervalo de tempo 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[])

Aguarda até que todos os objetos Task fornecidos tenham concluído a execução.Waits for any of the provided Task objects to complete execution.

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

Aguarda até que os objetos Task fornecidos tenham concluído a execução, a menos que a espera seja cancelada.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)

Aguarda qualquer um dos objetos Task fornecidos concluírem a execução dentro de um número especificado de milissegundos.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)

Aguarda alguns dos objetos Task fornecidos concluírem a execução em um número especificado de milissegundos ou até que o token de cancelamento seja cancelado.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)

Aguarda algum dos objetos Task fornecidos concluir a execução em um intervalo 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>)

Cria uma tarefa que será concluída quando todos os objetos Task em uma coleção enumerável forem concluídos.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[])

Cria uma tarefa que será concluída quando todos os objetos Task em uma matriz forem concluídos.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>>)

Cria uma tarefa que será concluída quando todos os objetos Task<TResult> em uma coleção enumerável forem concluídos.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>[])

Cria uma tarefa que será concluída quando todos os objetos Task<TResult> em uma matriz forem concluídos.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>)

Cria uma tarefa que será concluída quando qualquer uma das tarefas fornecidas foi concluídaCreates a task that will complete when any of the supplied tasks have completed.

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

Cria uma tarefa que será concluída quando qualquer uma das tarefas fornecidas foi concluídaCreates 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>>)

Cria uma tarefa que será concluída quando qualquer uma das tarefas fornecidas foi concluídaCreates 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>[])

Cria uma tarefa que será concluída quando qualquer uma das tarefas fornecidas foi concluídaCreates a task that will complete when any of the supplied tasks have completed.

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

Cria uma tarefa que é possível aguardar que retorna assincronamente para o contexto atual quando aguardada.Creates an awaitable task that asynchronously yields back to the current context when awaited.

Implantações explícitas de interface

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

Obtém um WaitHandle que pode ser usado para aguardar a conclusão da tarefa.Gets a WaitHandle that can be used to wait for the task to complete.

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

Obtém uma indicação de se a operação foi concluída de forma síncrona.Gets an indication of whether the operation completed synchronously.

Métodos de Extensão

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

Aguarda indefinidamente a conclusão do DispatcherOperation subjacente.Waits indefinitely for the underlying DispatcherOperation to complete.

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

Aguarda a conclusão do DispatcherOperation subjacente pelo período de tempo especificado.Waits for the specified amount of time for the underlying DispatcherOperation to complete.

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

Retorna um valor que indica se este Task está associado a um DispatcherOperation.Returns a value that indicates whether this Task is associated with a DispatcherOperation.

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

Retorna uma ação assíncrona do Windows Runtime que representa uma tarefa iniciada.Returns a Windows Runtime asynchronous action that represents a started task.

Aplica-se a

Acesso thread-safe

Todos os membros de Task, exceto para Dispose(), são thread-safe e podem ser usados de vários threads simultaneamente.All members of Task, except for Dispose(), are thread-safe and may be used from multiple threads concurrently.

Veja também