TaskCompletionSource<TResult> Clase

Referencia

Definición

Espacio de nombres:: System.Threading.Tasks

Ensamblado:: System.Threading.Tasks.dll

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Representa el lado del productor de una Task<TResult> sin enlazar a un delegado, proporcionando acceso al lado del consumidor mediante 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>objeto .

Herencia: Object
TaskCompletionSource<TResult>

Ejemplos

En el ejemplo siguiente se muestra cómo usar :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 al taskCompletionSource correspondiente. Para obtener más información, vea la entrada The Nature of TaskCompletionSource<TResult> en el blog Programación paralela con .NET.

Los ejemplos de Extensiones paralelas también contienen ejemplos de cómo usar TaskCompletionSource<TResult>.

Constructores

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

Propiedades

Task	Obtiene la Task<TResult> creada por este objeto TaskCompletionSource<TResult>.

Métodos

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

Se aplica a

Seguridad para subprocesos

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