TaskCompletionSource<TResult> Classe

Définition

Espace de noms:

System.Threading.Tasks

Assembly:

System.Runtime.dll

Source:

TaskCompletionSource_T.cs

Représente le côté producteur d’un Task<TResult> non lié à un délégué, fournissant l’accès au côté consommateur via la propriété Task.

generic <typename TResult>
public ref class TaskCompletionSource

public class TaskCompletionSource<TResult>

type TaskCompletionSource<'Result> = class

Public Class TaskCompletionSource(Of TResult)

Paramètres de type

TResult

Type de la valeur de résultat associée à cette TaskCompletionSource<TResult>.

Héritage

Object

TaskCompletionSource<TResult>

Exemples

L’exemple suivant montre comment utiliser 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

Remarques

Dans de nombreux scénarios, il est utile d’activer une Task<TResult> pour représenter une opération asynchrone externe. TaskCompletionSource<TResult> est fourni à cet effet. Il permet la création d’une tâche qui peut être distribuée aux consommateurs. Les consommateurs peuvent utiliser les membres de la tâche de la même façon que dans n’importe quel autre scénario qui gère les variables membres de tâche. Toutefois, contrairement à la plupart des tâches, l’état d’une tâche créée par une TaskCompletionSource est contrôlé explicitement par les méthodes sur TaskCompletionSource. Cela permet de propager l’opération asynchrone externe à la tâche sous-jacente. La séparation garantit également que les consommateurs ne peuvent pas passer l’état sans accéder à taskCompletionSource correspondant. Pour plus d’informations, consultez l’entrée The Nature of TaskCompletionSource<TResult> in the Parallel Programming with .NET blog.

Les exemples Extensions parallèles contiennent également des exemples d’utilisation de TaskCompletionSource<TResult>.

Constructeurs

TaskCompletionSource<TResult>()	Crée un TaskCompletionSource<TResult>.
TaskCompletionSource<TResult>(Object)	Crée un TaskCompletionSource<TResult> avec l’état spécifié.
TaskCompletionSource<TResult>(Object, TaskCreationOptions)	Crée une TaskCompletionSource<TResult> avec l’état et les options spécifiés.
TaskCompletionSource<TResult>(TaskCreationOptions)	Crée une TaskCompletionSource<TResult> avec les options spécifiées.

Propriétés

Task	Obtient la Task<TResult> créée par cette TaskCompletionSource<TResult>.

Méthodes

Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
SetCanceled()	Transfère le Task<TResult> sous-jacent à l’état Canceled.
SetCanceled(CancellationToken)	Transfère le Task<TResult> sous-jacent dans l’état Canceled à l’aide du jeton spécifié.
SetException(Exception)	Transfère le Task<TResult> sous-jacent dans l’état Faulted et le lie à une exception spécifiée.
SetException(IEnumerable<Exception>)	Transfère le Task<TResult> sous-jacent dans l’état Faulted et lie une collection d’objets d’exception à celui-ci.
SetResult(TResult)	Transfère le Task<TResult> sous-jacent à l’état RanToCompletion.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
TrySetCanceled()	Tente de faire passer le Task<TResult> sous-jacent à l’état Canceled.
TrySetCanceled(CancellationToken)	Tente de transférer le Task<TResult> sous-jacent dans l’état Canceled et permet de stocker un jeton d’annulation dans la tâche annulée.
TrySetException(Exception)	Tente de faire passer le Task<TResult> sous-jacent à l’état Faulted et le lie à une exception spécifiée.
TrySetException(IEnumerable<Exception>)	Tente de faire passer le Task<TResult> sous-jacent à l’état Faulted et lie une collection d’objets d’exception à celui-ci.
TrySetResult(TResult)	Tente de faire passer le Task<TResult> sous-jacent à l’état RanToCompletion.

Cohérence de thread

Tous les membres de TaskCompletionSource<TResult> sont thread-safe et peuvent être utilisés simultanément à partir de plusieurs threads.

Voir aussi

• l’utilisation de TPL avec d’autres modèles asynchrones
• Comment : encapsuler des modèles EAP dans une tâche