TaskCompletionSource<TResult> Clase

Definición

Espacio de nombres:

System.Threading.Tasks

Ensamblado:

System.Runtime.dll

Source:

TaskCompletionSource_T.cs

Representa el lado productor de un Task<TResult> sin enlazar a un delegado, lo que proporciona acceso al lado del consumidor a través de la propiedad 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

Tipo del valor de resultado asociado a este TaskCompletionSource<TResult>.

Herencia

Object

TaskCompletionSource<TResult>

Ejemplos

En el ejemplo siguiente se muestra cómo usar un 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

Comentarios

En muchos escenarios, resulta útil habilitar un Task<TResult> para representar una operación asincrónica externa. TaskCompletionSource<TResult> se proporciona para este fin. Permite la creación de una tarea que se puede entregar a los consumidores. Los consumidores pueden usar los miembros de la tarea de la misma manera que lo harían en cualquier otro escenario que controle variables de miembro de tarea. Sin embargo, a diferencia de la mayoría de las tareas, el estado de una tarea creada por taskCompletionSource se controla explícitamente mediante los métodos de TaskCompletionSource. Esto permite que la finalización de la operación asincrónica externa se propague a la tarea subyacente. La separación también garantiza que los consumidores no puedan realizar la transición del estado sin acceso a TaskCompletionSource correspondiente. Para obtener más información, consulte la entrada The Nature of TaskCompletionSource<TResult> en el blog Programación paralela con .NET.

Los ejemplos de extensiones paralelas de también contienen ejemplos de cómo usar .

Constructores

TaskCompletionSource<TResult>()	Crea un TaskCompletionSource<TResult>.
TaskCompletionSource<TResult>(Object)	Crea un TaskCompletionSource<TResult> con el estado especificado.
TaskCompletionSource<TResult>(Object, TaskCreationOptions)	Crea un TaskCompletionSource<TResult> con el estado y las opciones especificados.
TaskCompletionSource<TResult>(TaskCreationOptions)	Crea un TaskCompletionSource<TResult> con las opciones especificadas.

Propiedades

Task	Obtiene el Task<TResult> creado por este TaskCompletionSource<TResult>.

Métodos

Equals(Object)	Determina si el objeto especificado es igual al objeto actual. (Heredado de Object)
GetHashCode()	Actúa como función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Objectactual. (Heredado de Object)
SetCanceled()	Realiza la transición del Task<TResult> subyacente al estado Canceled.
SetCanceled(CancellationToken)	Realiza la transición del Task<TResult> subyacente al estado Canceled mediante el token especificado.
SetException(Exception)	Realiza la transición del Task<TResult> subyacente al estado Faulted y lo enlaza a una excepción especificada.
SetException(IEnumerable<Exception>)	Realiza la transición del Task<TResult> subyacente al estado de Faulted y enlaza una colección de objetos de excepción a él.
SetResult(TResult)	Realiza la transición del Task<TResult> subyacente al estado RanToCompletion.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
TrySetCanceled()	Intenta realizar la transición del Task<TResult> subyacente al estado Canceled.
TrySetCanceled(CancellationToken)	Intenta realizar la transición del Task<TResult> subyacente al estado Canceled y permite almacenar un token de cancelación en la tarea cancelada.
TrySetException(Exception)	Intenta realizar la transición del Task<TResult> subyacente al estado Faulted y lo enlaza a una excepción especificada.
TrySetException(IEnumerable<Exception>)	Intenta realizar la transición del Task<TResult> subyacente al estado Faulted y enlaza una colección de objetos de excepción a él.
TrySetResult(TResult)	Intenta realizar la transición del Task<TResult> subyacente al estado RanToCompletion.

Seguridad para subprocesos

Todos los miembros de TaskCompletionSource<TResult> son seguros para subprocesos y se pueden usar de varios subprocesos simultáneamente.

Consulte también

• usar TPL con otros patrones asincrónicos
• Cómo: Encapsular patrones de EAP en un de tareas