Task<TResult> Task<TResult> Task<TResult> Task<TResult> Class

Definição

Representa uma operação assíncrona que pode retornar um valor.Represents an asynchronous operation that can return a value.

generic <typename TResult>
public ref class Task : System::Threading::Tasks::Task
public class Task<TResult> : System.Threading.Tasks.Task
type Task<'Result> = class
    inherit Task
Public Class Task(Of TResult)
Inherits Task

Parâmetros de tipo

TResult

O tipo do resultado produzido por este Task<TResult>.The type of the result produced by this Task<TResult>.

Herança
Task<TResult>Task<TResult>Task<TResult>Task<TResult>

Comentários

A Task<TResult> classe representa uma única operação que retorna um valor e que geralmente é executada de forma assíncrona.The Task<TResult> class represents a single operation that returns a value and that usually executes asynchronously. Task<TResult>os objetos são um dos componentes centrais do padrão assíncrono baseado em tarefa introduzido pela primeira vez no .NET Framework 4.Task<TResult> 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 Task<TResult> objeto normalmente é executado de forma assíncrona em um thread do pool de threads em vez de sincronicamente no thread do Status aplicativo principal, você pode usar IsCanceleda IsCompletedPropriedade, bem como o, e IsFaulted Propriedades, para determinar o estado de uma tarefa.Because the work performed by a Task<TResult> 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.

Task<TResult>as instâncias podem ser criadas de várias maneiras.Task<TResult> instances may be created in a variety of ways. A abordagem mais comum, que está disponível a partir do .NET Framework 4.5.NET Framework 4.5, é chamar o método estático Task.Run<TResult>(Func<TResult>) ou Task.Run<TResult>(Func<TResult>, CancellationToken) .The most common approach, which is available starting with the .NET Framework 4.5.NET Framework 4.5, is to call the static Task.Run<TResult>(Func<TResult>) or Task.Run<TResult>(Func<TResult>, CancellationToken) method. Esses métodos fornecem uma maneira simples de iniciar uma tarefa usando valores padrão e sem adquirir parâmetros adicionais.These methods provide a simple way to start a task by using default values and without acquiring additional parameters. O exemplo a seguir usa Task.Run<TResult>(Func<TResult>) o método 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 Task.Run<TResult>(Func<TResult>) 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 void Main()
   {
      var t = Task<int>.Run( () => {
                                      // Just loop.
                                      int max = 1000000;
                                      int ctr = 0;
                                      for (ctr = 0; ctr <= max; ctr++) {
                                         if (ctr == max / 2 && DateTime.Now.Hour <= 12) {
                                            ctr++;
                                            break;
                                         }
                                      }
                                      return ctr;
                                    } );
      Console.WriteLine("Finished {0:N0} iterations.", t.Result);
   }
}
// The example displays output like the following:
//        Finished 1,000,001 loop iterations.
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task(Of Integer) = Task.Run(Function()
                                  Dim max As Integer = 1000000
                                  Dim ctr As Integer
                                  For ctr = 0 to max
                                     If ctr = max \ 2 And Date.Now.Hour <= 12 Then
                                        ctr += 1
                                        Exit For
                                     End If
                                  Next
                                  Return ctr
                               End Function)
      Console.WriteLine("Finished {0:N0} iterations.", t.Result)
   End Sub
End Module
' The example displays the following output:
'       Finished 1,000,001 loop iterations

Uma alternativa, e a maneira mais comum de iniciar uma tarefa no .NET Framework 4.NET Framework 4, é chamar o método estático TaskFactory.StartNew ou TaskFactory<TResult>.StartNew .An alternative, and the most common way to start a task in the .NET Framework 4.NET Framework 4, is to call the static TaskFactory.StartNew or TaskFactory<TResult>.StartNew method. A Task.Factory propriedade retorna um TaskFactory objeto e a Task<TResult>.Factory propriedade retorna um TaskFactory<TResult> objeto.The Task.Factory property returns a TaskFactory object, and the Task<TResult>.Factory property returns a TaskFactory<TResult> object. Sobrecargas de seu StartNew método permitem que você passe argumentos, defina opções de criação de tarefas e especifique um Agendador de tarefas.Overloads of their StartNew method let you pass arguments, define task creation options, and specify a task scheduler. O exemplo a seguir usa TaskFactory<TResult>.StartNew(Func<TResult>) o método para iniciar uma tarefa.The following example uses the TaskFactory<TResult>.StartNew(Func<TResult>) 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()
   {
      var t = Task<int>.Factory.StartNew( () => {
                                      // Just loop.
                                      int max = 1000000;
                                      int ctr = 0;
                                      for (ctr = 0; ctr <= max; ctr++) {
                                         if (ctr == max / 2 && DateTime.Now.Hour <= 12) {
                                            ctr++;
                                            break;
                                         }
                                      }
                                      return ctr;
                               } );
      Console.WriteLine("Finished {0:N0} iterations.", t.Result);
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t = Task(Of Integer).Factory.StartNew(Function()
                                  Dim max As Integer = 1000000
                                  Dim ctr As Integer
                                  For ctr = 0 to max
                                     If ctr = max \ 2 And Date.Now.Hour <= 12 Then
                                       ctr += 1
                                       Exit For
                                     End If
                                  Next
                                  Return ctr
                               End Function)
      Console.WriteLine("Finished {0:N0} iterations.", t.Result)
   End Sub
End Module
' The example displays output like the following:
'       Finished 1,000,001 iterations

Para obter exemplos mais completos, consulte programação assíncrona baseada em tarefas.For more complete examples, see Task-based Asynchronous Programming.

A Task<TResult> classe também fornece construtores que inicializam a tarefa, mas que não o agendam para execução.The Task<TResult> class also provides constructors that initialize the task but that do not schedule it for execution. Por motivos de desempenho, Task.Run os Task.Factory.StartNew métodos e são os mecanismos preferenciais para criar e agendar tarefas computacionais, mas para cenários em que a criação e o agendamento de tarefas devem ser separados, os construtores podem ser usados e o o método Start da tarefa pode então ser usado para agendar a tarefa para execução em um momento posterior.For performance reasons, the Task.Run and Task.Factory.StartNew methods are the preferred mechanisms for creating and scheduling computational tasks, but for scenarios where task creation and scheduling must be separated, the constructors may be used, and the task's Start method may then be used to schedule the task for execution at a later time.

A partir de aplicativos de área de .NET Framework 4.6.NET Framework 4.6trabalho direcionados para o, 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 CultureInfo " no tópico.For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic. Observe que os aplicativos da loja seguem a Windows Runtime na configuração e obtenção da cultura padrão.Note that Store apps follow the Windows Runtime in setting and getting the default culture.

Para operações que não retornam um valor, você usa a Task classe.For operations that do not return a value, you use the Task class. A partir C# de 7,0, para uma tarefa mais leve que é um tipo de valor em vez de um tipo de System.Threading.Tasks.ValueTask<TResult> referência, use a estrutura.Starting with C# 7.0, for a more lightweight task that is a value type rather than a reference type, use the System.Threading.Tasks.ValueTask<TResult> structure.

Construtores

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

Inicializa um novo Task<TResult> com a função e o estado especificados.Initializes a new Task<TResult> with the specified function and state.

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

Inicializa um novo Task<TResult> com a ação, o estado e as opções especificados.Initializes a new Task<TResult> with the specified action, state, and options.

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

Inicializa um novo Task<TResult> com a ação, o estado e as opções especificados.Initializes a new Task<TResult> with the specified action, state, and options.

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

Inicializa um novo Task<TResult> com a ação, o estado e as opções especificados.Initializes a new Task<TResult> with the specified action, state, and options.

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

Inicializa um novo Task<TResult> com a função especificada.Initializes a new Task<TResult> with the specified function.

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

Inicializa um novo Task<TResult> com a função especificada.Initializes a new Task<TResult> with the specified function.

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

Inicializa um novo Task<TResult> com a função especificada e opções de criação.Initializes a new Task<TResult> with the specified function and creation options.

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

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

(Inherited from Task)
CreationOptions CreationOptions CreationOptions CreationOptions

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

(Inherited from 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.

(Inherited from Task)
Factory Factory Factory Factory

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

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.

(Inherited from Task)
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.

(Inherited from Task)
Id Id Id Id

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

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully

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

(Inherited from Task)
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.

(Inherited from Task)
Result Result Result Result

Obtém o valor de resultado desse Task<TResult>.Gets the result value of this Task<TResult>.

Status Status Status Status

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

(Inherited from Task)

Métodos

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

Configura um awaiter usado para aguardar este Task<TResult>.Configures an awaiter used to await this Task<TResult>.

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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
ContinueWith(Action<Task<TResult>,Object>, Object) ContinueWith(Action<Task<TResult>,Object>, Object) ContinueWith(Action<Task<TResult>,Object>, Object) ContinueWith(Action<Task<TResult>,Object>, Object)

Cria uma continuação que recebe informações de estado e executa quando a Task<TResult> de destino for concluída.Creates a continuation that is passed state information and that executes when the target Task<TResult> completes.

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

Criará uma continuação executada quando o Task<TResult> de destino for concluído.Creates a continuation that executes when the target Task<TResult> completes.

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

Criará uma continuação executada quando o Task<TResult> de destino for concluído.Creates a continuation that executes when the target Task<TResult> completes.

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

Criará uma continuação executada quando o Task<TResult> de destino for concluído.Creates a continuation that executes when the target Task<TResult> completes.

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

Criará uma continuação executada quando o Task<TResult> de destino for concluído.Creates a continuation that executes when the target Task<TResult> completes.

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

Cria uma continuação que é executada de forma assíncrona quando a tarefa de destino é concluída.Creates a continuation that executes asynchronously when the target task completes.

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

Cria uma continuação cancelável executada de forma assíncrona quando a Task<TResult> de destino for concluída.Creates a cancelable continuation that executes asynchronously when the target Task<TResult> completes.

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

Cria uma continuação executada de acordo com a condição especificada em continuationOptions.Creates a continuation that executes according the condition specified in continuationOptions.

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

Cria uma continuação executada de acordo com a condição especificada em continuationOptions.Creates a continuation that executes according the condition specified in continuationOptions.

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

Criará uma continuação executada de forma assíncrona quando o Task<TResult> de destino for concluído.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object) ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object) ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object) ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object)

Criará uma continuação executada quando o Task<TResult> de destino for concluído.Creates a continuation that executes when the target Task<TResult> completes.

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

Criará uma continuação executada quando o Task<TResult> de destino for concluído.Creates a continuation that executes when the target Task<TResult> completes.

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

Criará uma continuação executada quando o Task<TResult> de destino for concluído.Creates a continuation that executes when the target Task<TResult> completes.

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

Criará uma continuação executada quando o Task<TResult> de destino for concluído.Creates a continuation that executes when the target Task<TResult> completes.

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

Criará uma continuação executada quando o Task<TResult> de destino for concluído.Creates a continuation that executes when the target Task<TResult> completes.

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

Criará uma continuação executada de forma assíncrona quando o Task<TResult> de destino for concluído.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

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

Criará uma continuação executada de forma assíncrona quando o Task<TResult> de destino for concluído.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

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

Cria uma continuação executada de acordo com a condição especificada em continuationOptions.Creates a continuation that executes according the condition specified in continuationOptions.

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

Cria uma continuação executada de acordo com a condição especificada em continuationOptions.Creates a continuation that executes according the condition specified in continuationOptions.

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

Criará uma continuação executada de forma assíncrona quando o Task<TResult> de destino for concluído.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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)
GetAwaiter() GetAwaiter() GetAwaiter() GetAwaiter()

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

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)
RunSynchronously() RunSynchronously() RunSynchronously() RunSynchronously()

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

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)
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.

(Inherited from Task)

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.

AsAsyncOperation<TResult>(Task<TResult>) AsAsyncOperation<TResult>(Task<TResult>) AsAsyncOperation<TResult>(Task<TResult>) AsAsyncOperation<TResult>(Task<TResult>)

Retorna uma operação assíncrona do Windows Runtime que representa uma tarefa iniciada que retorna um resultado.Returns a Windows Runtime asynchronous operation that represents a started task that returns a result.

Aplica-se a

Acesso thread-safe

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

Veja também