TaskCompletionSource<TResult> Klasse

Referenz

Definition

Namespace:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

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 TaskCompletionSource<TResult>zugeordnet ist.

Vererbung: Object
TaskCompletionSource<TResult>

Beispiele

Das folgende Beispiel zeigt, wie Sie eine 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

Hinweise

In vielen Szenarien ist es nützlich, einen Task<TResult> externen asynchronen Vorgang darzustellen. TaskCompletionSource<TResult> hierfür vorgesehen. Es ermöglicht die Erstellung einer Aufgabe, die den Verbrauchern übergeben werden kann. Die Verbraucher können die Mitglieder der Aufgabe auf dieselbe Weise wie in einem anderen Szenario verwenden, in dem Aufgabenelementvariablen behandelt werden. Im Gegensatz zu den meisten Vorgängen wird der Zustand einer Aufgabe, die von einer TaskCompletionSource erstellt wurde, jedoch explizit von den Methoden auf TaskCompletionSource gesteuert. Dadurch kann der abschluss des externen asynchronen Vorgangs an den zugrunde liegenden Vorgang weitergegeben werden. Durch die Trennung wird auch sichergestellt, dass Verbraucher den Zustand nicht ohne Zugriff auf die entsprechende TaskCompletionSource übertragen können. Weitere Informationen finden Sie im Eintrag "The Nature of TaskCompletionSource<TResult> " im Parallel Programming with .NET Blog.

Die Beispiele für parallele Erweiterungen enthalten auch Beispiele für die Verwendung 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 gleichzeitig aus mehreren Threads verwendet werden.