TaskCompletionSource<TResult> Klasse

Definition

Stellt die Producerseite eines Task<TResult>-Objekts dar, dessen Bindung an einen Delegaten aufgehoben wurde. Das Element ermöglicht mithilfe der Task-Eigenschaft den Zugriff auf die Consumerseite.

generic <typename TResult>
public ref class TaskCompletionSource
public class TaskCompletionSource<TResult>
type TaskCompletionSource<'Result> = class
Public Class TaskCompletionSource(Of TResult)

Typparameter

TResult

Der Typ des Ergebniswerts, der diesem zugeordnet TaskCompletionSource<TResult> ist.

Vererbung
TaskCompletionSource<TResult>

Beispiele

Im folgenden Beispiel wird die Verwendung von TaskCompletionSource<TResult> veranschaulicht:

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

Hinweise

In vielen Szenarien ist es nützlich, zu aktivieren, Task<TResult> um einen externen asynchronen Vorgang darzustellen. TaskCompletionSource<TResult> wird zu diesem Zweck bereitgestellt. Sie ermöglicht die Erstellung einer Aufgabe, die an Consumer übergeben werden kann. Die Consumer können die Member der Aufgabe auf die gleiche Weise wie in jedem anderen Szenario verwenden, das Taskmembervariablen behandelt. Im Gegensatz zu den meisten Aufgaben wird der Zustand einer Aufgabe, die von einer TaskCompletionSource erstellt wurde, jedoch explizit durch die -Methoden in TaskCompletionSource gesteuert. Dadurch kann der Abschluss des externen asynchronen Vorgangs an den zugrunde liegenden Task weitergegeben werden. Die Trennung stellt außerdem sicher, dass Consumer den Zustand nicht ohne Zugriff auf die entsprechende TaskCompletionSource übergehen können. Weitere Informationen finden Sie im Blog Parallel Programming with .NET (Parallele Programmierung mit .NET) im Eintrag The Nature of TaskCompletionSource (The Nature of TaskCompletionSource). <TResult>

Die Beispiele für parallele Erweiterungen enthalten auch Beispiele für die Verwendung von TaskCompletionSource<TResult> .

Konstruktoren

TaskCompletionSource<TResult>()

Erstellt eine TaskCompletionSource<TResult>.

TaskCompletionSource<TResult>(Object)

Erstellt ein TaskCompletionSource<TResult>-Objekt mit dem angegebenen Zustand.

TaskCompletionSource<TResult>(Object, TaskCreationOptions)

Erstellt ein TaskCompletionSource<TResult>-Objekt mit dem angegebenen Zustand und den angegebenen Optionen.

TaskCompletionSource<TResult>(TaskCreationOptions)

Erstellt ein TaskCompletionSource<TResult>-Objekt mit den angegebenen Optionen.

Eigenschaften

Task

Ruft den von der Task<TResult> erstellten TaskCompletionSource<TResult> ab.

Methoden

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
SetCanceled()

Sorgt für den Übergang des zugrunde liegenden Task<TResult>-Objekts in den Canceled-Zustand.

SetCanceled(CancellationToken)

Versetzt die zugrunde liegende Task<TResult> mithilfe des angegebenen Tokens in den Zustand Canceled.

SetException(Exception)

Lässt den zugrunde liegenden Task<TResult> in den Faulted-Status übergehen und bindet ihn an eine angegebene Ausnahme.

SetException(IEnumerable<Exception>)

Sorgt für den Übergang des zugrunde liegenden Task<TResult> in den Faulted-Status und bindet eine Sammlung von Ausnahmeobjekten daran.

SetResult(TResult)

Sorgt für den Übergang des zugrunde liegenden Task<TResult>-Objekts in den RanToCompletion-Zustand.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)
TrySetCanceled()

Versucht, den Übergang des zugrunde liegenden Task<TResult>-Objekts in den Canceled-Zustand auszuführen.

TrySetCanceled(CancellationToken)

Versucht, den Übergang des zugrunde liegenden Task<TResult>-Objekts in den Canceled-Zustand auszuführen, und ermöglicht das Speichern eines Abbruchtokens in der abgebrochenen Aufgabe.

TrySetException(Exception)

Versucht den Übergang der zugrunde liegenden Task<TResult> in den Faulted-Status und bindet sie an eine angegebene Ausnahme.

TrySetException(IEnumerable<Exception>)

Versucht den Übergang der zugrunde liegenden Task<TResult> in den Faulted-Status und bindet eine Sammlung von Ausnahmeobjekten daran.

TrySetResult(TResult)

Versucht, den Übergang des zugrunde liegenden Task<TResult>-Objekts in den RanToCompletion-Zustand auszuführen.

Gilt für

Threadsicherheit

Alle Member von TaskCompletionSource<TResult> sind threadsicher und können von mehreren Threads gleichzeitig verwendet werden.

Siehe auch