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

Definición

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

El tipo del valor del resultado asociado a este TaskCompletionSource<TResult>.The type of the result value associated with this TaskCompletionSource<TResult>.

Herencia
TaskCompletionSource<TResult>TaskCompletionSource<TResult>TaskCompletionSource<TResult>TaskCompletionSource<TResult>

Ejemplos

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

Comentarios

En muchos escenarios, es útil habilitar un Task<TResult> para representar una operación asincrónica externa.In many scenarios, it is useful to enable a Task<TResult> to represent an external asynchronous operation. TaskCompletionSource<TResult> se proporciona para este propósito.TaskCompletionSource<TResult> is provided for this purpose. Permite la creación de una tarea que se puede entregar a los consumidores.It enables the creation of a task that can be handed out to consumers. Los consumidores pueden utilizar a los miembros de la tarea de la misma manera como lo harían en cualquier otro escenario de variables de miembro de la tarea de control.The consumers can use the members of the task the same way as they would in any other scenario handling task member variables. 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 en TaskCompletionSource.However, unlike most tasks, the state of a task created by a TaskCompletionSource is controlled explicitly by the methods on TaskCompletionSource. Esto permite que la finalización de la operación asincrónica externa se propagará a la tarea subyacente.This enables the completion of the external asynchronous operation to be propagated to the underlying Task. La separación también asegura que los consumidores no puede realizar la transición del estado sin acceso a TaskCompletionSource correspondiente.The separation also ensures that consumers are not able to transition the state without access to the corresponding TaskCompletionSource. Para obtener más información, vea la entrada la naturaleza de TaskCompletionSource<TResult > programación en paralelo con .NET blog.For more information, see the entry The Nature of TaskCompletionSource<TResult> in the Parallel Programming with .NET blog.

El ejemplos de extensiones paralelas también contienen ejemplos de cómo usar TaskCompletionSource<TResult>.The Parallel Extensions samples also contain examples of how to use TaskCompletionSource<TResult>.

Constructores

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

Crea una interfaz TaskCompletionSource<TResult>.Creates a TaskCompletionSource<TResult>.

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

Crea un objeto TaskCompletionSource<TResult> con el 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)

Crea un objeto TaskCompletionSource<TResult> con el estado y las opciones especificados.Creates a TaskCompletionSource<TResult> with the specified state and options.

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

Crea un objeto TaskCompletionSource<TResult> con las opciones especificadas.Creates a TaskCompletionSource<TResult> with the specified options.

Propiedades

Task Task Task Task

Obtiene la Task<TResult> creada por este objeto TaskCompletionSource<TResult>.Gets the Task<TResult> created by this TaskCompletionSource<TResult>.

Métodos

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

(Inherited from Object)
SetCanceled() SetCanceled() SetCanceled() SetCanceled()

Transiciona la Task<TResult> subyacente al estado Canceled.Transitions the underlying Task<TResult> into the Canceled state.

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

Realiza transiciones del Task<TResult> subyacente en el estado Faulted y lo enlaza a una excepción 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>)

Realiza transiciones del Task<TResult> subyacente al estado Faulted y enlaza en él una colección de objetos de excepción.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)

Transiciona la Task<TResult> subyacente al estado RanToCompletion.Transitions the underlying Task<TResult> into the RanToCompletion state.

ToString() ToString() ToString() ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Inherited from Object)
TrySetCanceled() TrySetCanceled() TrySetCanceled() TrySetCanceled()

Intenta transicionar la Task<TResult> subyacente al estado Canceled.Attempts to transition the underlying Task<TResult> into the Canceled state.

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

Intenta realizar transiciones del Task<TResult> subyacente al estado Faulted y lo enlaza a una excepción 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>)

Intenta realizar transiciones del Task<TResult> subyacente al estado Faulted y enlaza en él una colección de objetos de excepción.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)

Intenta transicionar la Task<TResult> subyacente al estado RanToCompletion.Attempts to transition the underlying Task<TResult> into the RanToCompletion state.

Se aplica a

Seguridad para subprocesos

Todos los miembros de TaskCompletionSource<TResult> son seguros para subprocesos y se pueden usar desde varios subprocesos simultáneamente.All members of TaskCompletionSource<TResult> are thread-safe and may be used from multiple threads concurrently.

Consulte también: