TaskCompletionSource<TResult> Classe

Referência

Definição

Namespace:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

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

generic <typename TResult>
public ref class TaskCompletionSource

public class TaskCompletionSource<TResult>

type TaskCompletionSource<'Result> = class

Public Class TaskCompletionSource(Of TResult)

Parâmetros de tipo

TResult

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

Herança: Object
TaskCompletionSource<TResult>

Exemplos

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

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());
            }
        }
    }
}

Imports System.Diagnostics
Imports System.Threading
Imports System.Threading.Tasks

Module 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.

    Private Sub Main()
        Dim tcs1 As New TaskCompletionSource(Of Integer)()
        Dim t1 As Task(Of Integer) = tcs1.Task

        ' Start a background task that will complete tcs1.Task
        Task.Factory.StartNew(Sub()
                                  Thread.Sleep(1000)
                                  tcs1.SetResult(15)
                              End Sub)

        ' 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.
        Dim sw As Stopwatch = Stopwatch.StartNew()
        Dim result As Integer = 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
        Dim tcs2 As New TaskCompletionSource(Of Integer)()
        Dim t2 As Task(Of Integer) = tcs2.Task

        ' Start a background Task that will complete tcs2.Task with an exception
        Task.Factory.StartNew(Sub()
                                  Thread.Sleep(1000)
                                  tcs2.SetException(New InvalidOperationException("SIMULATED EXCEPTION"))
                              End Sub)

        ' 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 e As AggregateException
            Console.Write("(ElapsedTime={0}): ", sw.ElapsedMilliseconds)
            Console.WriteLine("The following exceptions have been thrown by t2.Result: (THIS WAS EXPECTED)")
            For j As Integer = 0 To e.InnerExceptions.Count - 1
                Console.WriteLine(vbLf & "-------------------------------------------------" & vbLf & "{0}", e.InnerExceptions(j).ToString())
            Next
        End Try
    End Sub

End Module

Comentários

Em muitos cenários, é útil habilitar uma Task<TResult> 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 fariam 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> in the Parallel Programming with .NET blog.

Os exemplos de Extensões Paralelas também contêm exemplos de como usar TaskCompletionSource<TResult>.

Construtores

TaskCompletionSource<TResult>()	Cria um TaskCompletionSource<TResult>.
TaskCompletionSource<TResult>(Object)	Cria uma TaskCompletionSource<TResult> com o estado especificado.
TaskCompletionSource<TResult>(Object, TaskCreationOptions)	Cria uma 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 esse 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 Object atual. (Herdado de Object)
SetCanceled()	Faz a transição do Task<TResult> subjacente para o estado Canceled.
SetCanceled(CancellationToken)	Faz a transição da Task<TResult> subjacente para o estado Canceled usando o token especificado.
SetException(Exception)	Faz a transição do Task<TResult> subjacente para o estado Faulted e associa-o 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 do 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 do Task<TResult> subjacente para o estado Faulted e o 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 são TaskCompletionSource<TResult> thread-safe e podem ser usados de vários threads simultaneamente.