TaskCompletionSource<TResult> Classe

Definição

Namespace:

System.Threading.Tasks

Assembly:

System.Runtime.dll

Origem:

TaskCompletionSource_T.cs

Representa o lado do produtor de uma Task<TResult> não associado a um delegado, fornecendo acesso ao lado do consumidor por meio da propriedade Task.

C#

public class TaskCompletionSource<TResult>

Parâmetros de tipo

TResult

O tipo do valor de resultado associado a esse TaskCompletionSource<TResult>.

Herança

Object

TaskCompletionSource<TResult>

Exemplos

O exemplo a seguir mostra como usar um TaskCompletionSource<TResult>:

C#

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

class TCSDemo
{
    // Demonstrated features:
    // 		TaskCompletionSource ctor()
    // 		TaskCompletionSource.SetResult()
    // 		TaskCompletionSource.SetException()
    //		Task.Result
    // Expected results:
    // 		The attempt to get t1.Result blocks for ~1000ms until tcs1 gets signaled. 15 is printed out.
    // 		The attempt to get t2.Result blocks for ~1000ms until tcs2 gets signaled. An exception is printed out.
    static void Main()
    {
        TaskCompletionSource<int> tcs1 = new TaskCompletionSource<int>();
        Task<int> t1 = tcs1.Task;

        // Start a background task that will complete tcs1.Task
        Task.Factory.StartNew(() =>
        {
            Thread.Sleep(1000);
            tcs1.SetResult(15);
        });

        // The attempt to get the result of t1 blocks the current thread until the completion source gets signaled.
        // It should be a wait of ~1000 ms.
        Stopwatch sw = Stopwatch.StartNew();
        int result = t1.Result;
        sw.Stop();

        Console.WriteLine("(ElapsedTime={0}): t1.Result={1} (expected 15) ", sw.ElapsedMilliseconds, result);

        // ------------------------------------------------------------------

        // Alternatively, an exception can be manually set on a TaskCompletionSource.Task
        TaskCompletionSource<int> tcs2 = new TaskCompletionSource<int>();
        Task<int> t2 = tcs2.Task;

        // Start a background Task that will complete tcs2.Task with an exception
        Task.Factory.StartNew(() =>
        {
            Thread.Sleep(1000);
            tcs2.SetException(new InvalidOperationException("SIMULATED EXCEPTION"));
        });

        // The attempt to get the result of t2 blocks the current thread until the completion source gets signaled with either a result or an exception.
        // In either case it should be a wait of ~1000 ms.
        sw = Stopwatch.StartNew();
        try
        {
            result = t2.Result;

            Console.WriteLine("t2.Result succeeded. THIS WAS NOT EXPECTED.");
        }
        catch (AggregateException e)
        {
            Console.Write("(ElapsedTime={0}): ", sw.ElapsedMilliseconds);
            Console.WriteLine("The following exceptions have been thrown by t2.Result: (THIS WAS EXPECTED)");
            for (int j = 0; j < e.InnerExceptions.Count; j++)
            {
                Console.WriteLine("\n-------------------------------------------------\n{0}", e.InnerExceptions[j].ToString());
            }
        }
    }
}

Comentários

Em muitos cenários, é útil habilitar um Task<TResult> para representar uma operação assíncrona externa. TaskCompletionSource<TResult> é fornecido para essa finalidade. Ele permite a criação de uma tarefa que pode ser entregue aos consumidores. Os consumidores podem usar os membros da tarefa da mesma maneira que em qualquer outro cenário que manipula variáveis de membro da tarefa. No entanto, ao contrário da maioria das tarefas, o estado de uma tarefa criada por um TaskCompletionSource é controlado explicitamente pelos métodos em TaskCompletionSource. Isso permite que a conclusão da operação assíncrona externa seja propagada para a Tarefa subjacente. A separação também garante que os consumidores não possam fazer a transição do estado sem acesso ao TaskCompletionSource correspondente. Para obter mais informações, consulte a entrada The Nature of TaskCompletionSource<TResult> no blog Programação Paralela com .NET.

Os exemplos de Extensões Paralelas do também contêm exemplos de como usar .

Construtores

TaskCompletionSource<TResult>()	Cria um TaskCompletionSource<TResult>.
TaskCompletionSource<TResult>(Object)	Cria um TaskCompletionSource<TResult> com o estado especificado.
TaskCompletionSource<TResult>(Object, TaskCreationOptions)	Cria um TaskCompletionSource<TResult> com o estado e as opções especificados.
TaskCompletionSource<TResult>(TaskCreationOptions)	Cria um TaskCompletionSource<TResult> com as opções especificadas.

Propriedades

Task	Obtém o Task<TResult> criado por este TaskCompletionSource<TResult>.

Métodos

Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Objectatual. (Herdado de Object)
SetCanceled()	Faz a transição da Task<TResult> subjacente para o estado Canceled.
SetCanceled(CancellationToken)	Faz a transição do Task<TResult> subjacente para o estado Canceled usando o token especificado.
SetException(Exception)	Faz a transição da Task<TResult> subjacente para o estado Faulted e a associa a uma exceção especificada.
SetException(IEnumerable<Exception>)	Faz a transição do Task<TResult> subjacente para o estado Faulted e associa uma coleção de objetos de exceção a ele.
SetResult(TResult)	Faz a transição da Task<TResult> subjacente para o estado RanToCompletion.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
TrySetCanceled()	Tenta fazer a transição do Task<TResult> subjacente para o estado Canceled.
TrySetCanceled(CancellationToken)	Tenta fazer a transição do Task<TResult> subjacente para o estado Canceled e permite que um token de cancelamento seja armazenado na tarefa cancelada.
TrySetException(Exception)	Tenta fazer a transição da Task<TResult> subjacente para o estado Faulted e a associa a uma exceção especificada.
TrySetException(IEnumerable<Exception>)	Tenta fazer a transição do Task<TResult> subjacente para o estado Faulted e associa uma coleção de objetos de exceção a ele.
TrySetResult(TResult)	Tenta fazer a transição do Task<TResult> subjacente para o estado RanToCompletion.

Aplica-se a

Acesso thread-safe

Todos os membros de TaskCompletionSource<TResult> são thread-safe e podem ser usados de vários threads simultaneamente.

Confira também

• usando TPL com outros padrões assíncronos
• Como encapsular padrões EAP em uma tarefa