TaskCompletionSource<TResult> Classe

Définition

Espace de noms:

System.Threading.Tasks

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

TaskCompletionSource_T.cs

Représente le côté producteur d’un Task<TResult> délégué qui fournit l’accès au côté consommateur par le biais de la Task propriété.

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 à ce 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> 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.

Constructeurs

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

Propriétés

Nom	Description
Task	Obtient le Task<TResult> fichier créé par ce TaskCompletionSource<TResult>fichier .

Méthodes

Nom	Description
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()	Fait passer le sous-jacent Task<TResult> à l’état Canceled .
SetCanceled(CancellationToken)	Transfère le sous-jacent Task<TResult> dans l’état à l’aide Canceled du jeton spécifié.
SetException(Exception)	Transfère le sous-jacent Task<TResult> dans l’état Faulted et le lie à une exception spécifiée.
SetException(IEnumerable<Exception>)	Transfère le sous-jacent Task<TResult> dans l’état Faulted et lie une collection d’objets d’exception à celui-ci.
SetFromTask(Task<TResult>)	Effectue la transition du sous-jacent Task<TResult> dans le même état d’achèvement que celui spécifié completedTask.
SetResult(TResult)	Fait passer le sous-jacent Task<TResult> à l’état RanToCompletion .
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
TrySetCanceled()	Tente de faire passer le sous-jacent Task<TResult> à l’état Canceled .
TrySetCanceled(CancellationToken)	Tente de transférer le sous-jacent Task<TResult> 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 sous-jacent Task<TResult> à l’état Faulted et le lie à une exception spécifiée.
TrySetException(IEnumerable<Exception>)	Tente de faire passer le sous-jacent Task<TResult> à l’état Faulted et lie une collection d’objets d’exception à celui-ci.
TrySetFromTask(Task<TResult>)	Tente de faire passer le sous-jacent Task<TResult> dans le même état d’achèvement que celui spécifié completedTask.
TrySetResult(TResult)	Tente de faire passer le sous-jacent Task<TResult> à l’état RanToCompletion .

Cohérence de thread

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

Voir aussi

• Utilisation de TPL avec d’autres modèles asynchrones
• Guide pratique pour encapsuler des modèles EAP dans une tâche