TaskCompletionSource<TResult> TaskCompletionSource<TResult> TaskCompletionSource<TResult> TaskCompletionSource<TResult> Class

Definição

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.Represents the producer side of a Task<TResult> unbound to a delegate, providing access to the consumer side through the Task property.

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>.The type of the result value associated with this TaskCompletionSource<TResult>.

Herança
TaskCompletionSource<TResult>TaskCompletionSource<TResult>TaskCompletionSource<TResult>TaskCompletionSource<TResult>

Exemplos

O exemplo a seguir mostra como usar um TaskCompletionSource<TResult>:The following example shows how to use a 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 um Task<TResult> para representar uma operação assíncrona externa.In many scenarios, it is useful to enable a Task<TResult> to represent an external asynchronous operation. TaskCompletionSource<TResult> é fornecido para essa finalidade.TaskCompletionSource<TResult> is provided for this purpose. Ele permite a criação de uma tarefa que pode ser enviada para os consumidores.It enables the creation of a task that can be handed out to consumers. Os consumidores podem usar os membros da tarefa da mesma forma como faria em qualquer outro cenário de manipulação de variáveis de membro de tarefas.The consumers can use the members of the task the same way as they would in any other scenario handling task member variables. No entanto, ao contrário da maioria das tarefas, o estado de uma tarefa criada por um TaskCompletionSource é controlado explicitamente por métodos em TaskCompletionSource.However, unlike most tasks, the state of a task created by a TaskCompletionSource is controlled explicitly by the methods on TaskCompletionSource. Isso permite que a conclusão da operação assíncrona externa sejam propagadas para a tarefa subjacente.This enables the completion of the external asynchronous operation to be propagated to the underlying Task. A separação também garante que os consumidores não são capazes de fazer a transição de estado sem acesso a TaskCompletionSource correspondente.The separation also ensures that consumers are not able to transition the state without access to the corresponding TaskCompletionSource. Para obter mais informações, consulte a entrada natureza de TaskCompletionSource<TResult > na programação paralela no blog do .NET.For more information, see the entry The Nature of TaskCompletionSource<TResult> in the Parallel Programming with .NET blog.

O exemplos de extensões paralelas também contêm exemplos de como usar TaskCompletionSource<TResult>.The Parallel Extensions samples also contain examples of how to use TaskCompletionSource<TResult>.

Construtores

TaskCompletionSource<TResult>() TaskCompletionSource<TResult>() TaskCompletionSource<TResult>() TaskCompletionSource<TResult>()

Cria um TaskCompletionSource<TResult>.Creates a TaskCompletionSource<TResult>.

TaskCompletionSource<TResult>(Object) TaskCompletionSource<TResult>(Object) TaskCompletionSource<TResult>(Object) TaskCompletionSource<TResult>(Object)

Cria uma TaskCompletionSource<TResult> com o estado especificado.Creates a TaskCompletionSource<TResult> with the specified state.

TaskCompletionSource<TResult>(Object, TaskCreationOptions) TaskCompletionSource<TResult>(Object, TaskCreationOptions) TaskCompletionSource<TResult>(Object, TaskCreationOptions) TaskCompletionSource<TResult>(Object, TaskCreationOptions)

Cria uma TaskCompletionSource<TResult> com o estado e as opções especificados.Creates a TaskCompletionSource<TResult> with the specified state and options.

TaskCompletionSource<TResult>(TaskCreationOptions) TaskCompletionSource<TResult>(TaskCreationOptions) TaskCompletionSource<TResult>(TaskCreationOptions) TaskCompletionSource<TResult>(TaskCreationOptions)

Cria um TaskCompletionSource<TResult> com as opções especificadas.Creates a TaskCompletionSource<TResult> with the specified options.

Propriedades

Task Task Task Task

Obtém o Task<TResult> criado por esse TaskCompletionSource<TResult>.Gets the Task<TResult> created by this TaskCompletionSource<TResult>.

Métodos

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

Faz a transição do Task<TResult> subjacente para o estado Canceled.Transitions the underlying Task<TResult> into the Canceled state.

SetException(Exception) SetException(Exception) SetException(Exception) SetException(Exception)

Faz a transição do Task<TResult> subjacente para o estado Faulted e associa-o a uma exceção especificada.Transitions the underlying Task<TResult> into the Faulted state and binds it to a specified exception.

SetException(IEnumerable<Exception>) SetException(IEnumerable<Exception>) SetException(IEnumerable<Exception>) 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.Transitions the underlying Task<TResult> into the Faulted state and binds a collection of exception objects to it.

SetResult(TResult) SetResult(TResult) SetResult(TResult) SetResult(TResult)

Faz a transição do Task<TResult> subjacente para o estado RanToCompletion.Transitions the underlying Task<TResult> into the RanToCompletion state.

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

Tenta fazer a transição do Task<TResult> subjacente para o estado Canceled.Attempts to transition the underlying Task<TResult> into the Canceled state.

TrySetCanceled(CancellationToken) TrySetCanceled(CancellationToken) TrySetCanceled(CancellationToken) 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.Attempts to transition the underlying Task<TResult> into the Canceled state and enables a cancellation token to be stored in the canceled task.

TrySetException(Exception) TrySetException(Exception) TrySetException(Exception) TrySetException(Exception)

Tenta fazer a transição do Task<TResult> subjacente para o estado Faulted e o associa a uma exceção especificada.Attempts to transition the underlying Task<TResult> into the Faulted state and binds it to a specified exception.

TrySetException(IEnumerable<Exception>) TrySetException(IEnumerable<Exception>) TrySetException(IEnumerable<Exception>) 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.Attempts to transition the underlying Task<TResult> into the Faulted state and binds a collection of exception objects to it.

TrySetResult(TResult) TrySetResult(TResult) TrySetResult(TResult) TrySetResult(TResult)

Tenta fazer a transição do Task<TResult> subjacente para o estado RanToCompletion.Attempts to transition the underlying Task<TResult> into the RanToCompletion state.

Aplica-se a

Acesso thread-safe

Todos os membros de TaskCompletionSource<TResult> são thread-safe e podem ser usados simultaneamente de vários threads.All members of TaskCompletionSource<TResult> are thread-safe and may be used from multiple threads concurrently.

Veja também