TaskCompletionSource<TResult> Classe

Référence

Définition

Espace de noms:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Représente le côté producteur d'un Task<TResult> indépendant d'un délégué, en 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 à 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> représentation d’une opération asynchrone externe. TaskCompletionSource<TResult> est fourni à cet effet. Elle 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 à l’achèvement de l’opération asynchrone externe de se propager à la tâche sous-jacente. La séparation garantit également que les consommateurs ne peuvent pas passer l’état sans accès au TaskCompletionSource correspondant. Pour plus d’informations, consultez l’entrée The Nature of TaskCompletionSource<TResult> in the Parallel Programming with .NET blog.

Les exemples d’extensions parallèles contiennent également des exemples d’utilisation 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 un TaskCompletionSource<TResult> avec l'état et les options spécifiés.
TaskCompletionSource<TResult>(TaskCreationOptions)	Crée un TaskCompletionSource<TResult> avec les options spécifiées.

Propriétés

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

Méthodes

Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
SetCanceled()	Fait passer le Task<TResult> sous-jacent à l'état Canceled.
SetCanceled(CancellationToken)	Fait passer le Task<TResult> sous-jacent à l’état Canceled à l’aide du jeton spécifié.
SetException(Exception)	Transfère le Task<TResult> sous-jacent en état Faulted et le lie à une exception spécifiée.
SetException(IEnumerable<Exception>)	Transfère le Task<TResult> sous-jacent en état Faulted et lui associe une collection d’objets d’exception.
SetResult(TResult)	Fait passer 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 faire passer le Task<TResult> sous-jacent à l'état Canceled et permet le stockage d'un jeton d'annulation dans la tâche annulée.
TrySetException(Exception)	Tente de faire passer le Task<TResult> sous-jacent en état Faulted et le lie à une exception spécifiée.
TrySetException(IEnumerable<Exception>)	Tente de faire passer le Task<TResult> sous-jacent en état Faulted et lui associe une collection d’objets d’exception.
TrySetResult(TResult)	Tente de faire passer le Task<TResult> sous-jacent à l'état RanToCompletion.

S’applique à

Cohérence de thread

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