Task<TResult> Classe

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>

Comentários

A classe Task<TResult> 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> 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 objeto de Task<TResult> 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, IsCompletede IsFaulted, 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> 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 da .NET Framework 4.5.NET Framework 4.5, é chamar o Task.Run<TResult>(Func<TResult>) estático ou o método 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 o método Task.Run<TResult>(Func<TResult>) 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 na .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 propriedade Task.Factory retorna um objeto TaskFactory e a propriedade Task<TResult>.Factory retorna um objeto TaskFactory<TResult>.The Task.Factory property returns a TaskFactory object, and the Task<TResult>.Factory property returns a TaskFactory<TResult> object. Sobrecargas de seu método StartNew 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 o método TaskFactory<TResult>.StartNew(Func<TResult>) 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 classe Task<TResult> 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, os métodos Task.Run e Task.Factory.StartNew 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 método de Start da tarefa pode 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 trabalho direcionados 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. 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 classe Task.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 referência, use a estrutura System.Threading.Tasks.ValueTask<TResult>.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)

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)

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)

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)

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

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

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)

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)

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

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.

(Herdado de Task)
CreationOptions

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

(Herdado de Task)
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.

(Herdado de Task)
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.

Id

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

(Herdado de Task)
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.

(Herdado de Task)
IsCompleted

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

(Herdado de Task)
IsCompletedSuccessfully

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

(Herdado de Task)
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.

(Herdado de Task)
Result

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

Status

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

(Herdado de Task)

Métodos

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)

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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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)

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)

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)

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)

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

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)

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)

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)

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)

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

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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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)

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)

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)

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)

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

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)

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)

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)

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)

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)

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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
Dispose(Boolean)

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

(Herdado de Task)
Equals(Object)

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

(Herdado de Object)
GetAwaiter()

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

GetHashCode()

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

(Herdado de Object)
GetType()

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

(Herdado de Object)
MemberwiseClone()

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

(Herdado de Object)
RunSynchronously()

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

(Herdado de Task)
RunSynchronously(TaskScheduler)

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

(Herdado de Task)
Start()

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

(Herdado de Task)
Start(TaskScheduler)

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

(Herdado de Task)
ToString()

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

(Herdado de Object)
Wait()

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

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)
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.

(Herdado de Task)

Implantações explícitas de interface

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.

(Herdado de Task)
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.

(Herdado de Task)

Métodos de Extensão

DispatcherOperationWait(Task)

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

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)

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)

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

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 de Task<TResult>, exceto para Dispose(), 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