TaskCompletionSource<TResult> Klasse

Definition

Namespace:

System.Threading.Tasks

Assembly:

System.Runtime.dll

Quelle:

TaskCompletionSource_T.cs

Stellt die Produzentenseite eines Task<TResult> ungebunden an eine Stellvertretung dar, wodurch der Zugriff auf die Verbraucherseite über die eigenschaft Task ermöglicht wird.

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>verwenden:

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, eine Task<TResult> für einen externen asynchronen Vorgang zu aktivieren. TaskCompletionSource<TResult> wird zu diesem Zweck bereitgestellt. Sie ermöglicht die Erstellung einer Aufgabe, die den Verbrauchern übergeben werden kann. Die Consumer können die Mitglieder der Aufgabe auf die gleiche Weise verwenden wie in jedem anderen Szenario, in dem Aufgabenmembervariablen 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 die zugrunde liegende Aufgabe 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 von TaskCompletionSource<TResult>.

Konstruktoren

TaskCompletionSource<TResult>()	Erstellt eine TaskCompletionSource<TResult>.
TaskCompletionSource<TResult>(Object)	Erstellt eine TaskCompletionSource<TResult> mit dem angegebenen Zustand.
TaskCompletionSource<TResult>(Object, TaskCreationOptions)	Erstellt eine TaskCompletionSource<TResult> mit dem angegebenen Zustand und den angegebenen Optionen.
TaskCompletionSource<TResult>(TaskCreationOptions)	Erstellt eine TaskCompletionSource<TResult> mit den angegebenen Optionen.

Eigenschaften

Task	Ruft die von diesem TaskCompletionSource<TResult>erstellte Task<TResult> ab.

Methoden

Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object)
GetHashCode()	Dient als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
SetCanceled()	Übergibt die zugrunde liegende Task<TResult> in den Canceled Zustand.
SetCanceled(CancellationToken)	Übergibt die zugrunde liegende Task<TResult> mithilfe des angegebenen Tokens in den Canceled Zustand.
SetException(Exception)	Übergibt die zugrunde liegende Task<TResult> in den Faulted Zustand und bindet sie an eine angegebene Ausnahme.
SetException(IEnumerable<Exception>)	Übergibt die zugrunde liegende Task<TResult> in den Faulted Zustand und bindet eine Auflistung von Ausnahmeobjekten an sie.
SetResult(TResult)	Übergibt die zugrunde liegende Task<TResult> in den RanToCompletion Zustand.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
TrySetCanceled()	Versucht, die zugrunde liegende Task<TResult> in den Canceled Zustand zu übertragen.
TrySetCanceled(CancellationToken)	Versucht, die zugrunde liegende Task<TResult> in den zustand Canceled umzusteigen und ermöglicht das Speichern eines Abbruchtokens in der abgebrochenen Aufgabe.
TrySetException(Exception)	Versucht, die zugrunde liegende Task<TResult> in den Faulted Zustand zu übertragen und an eine angegebene Ausnahme zu binden.
TrySetException(IEnumerable<Exception>)	Versucht, die zugrunde liegende Task<TResult> in den Faulted Zustand zu übertragen und eine Auflistung von Ausnahmeobjekten an sie zu binden.
TrySetResult(TResult)	Versucht, die zugrunde liegende Task<TResult> in den RanToCompletion Zustand zu übertragen.

Threadsicherheit

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

Weitere Informationen

• Verwenden von TPL mit anderen asynchronen Mustern
• How to: Wrap EAP Patterns in a Task