Task<TResult> Klasse

Definition

Stellt einen asynchronen Vorgang dar, der einen Wert zurückgeben kann.

generic <typename TResult>
public ref class Task : System::Threading::Tasks::Task
public class Task<TResult> : System.Threading.Tasks.Task
type Task<'Result> = class
    inherit Task
Public Class Task(Of TResult)
Inherits Task

Typparameter

TResult

Der von diesem Task<TResult> erzeugte Ergebnistyp.

Vererbung
Task<TResult>

Hinweise

Die Task<TResult> -Klasse stellt einen einzelnen Vorgang dar, der einen Wert zurückgibt und in der Regel asynchron ausgeführt wird. Task<TResult>-Objekte sind eine der zentralen Komponenten des aufgabenbasierten asynchronen Musters, das zuerst in .NET Framework 4 eingeführt wurde. Da die von einem -Objekt ausgeführte Arbeit in der Regel asynchron in einem Threadpoolthread und nicht synchron im Hauptanwendungsthread ausgeführt wird, können Sie die -Eigenschaft sowie die Eigenschaften , und verwenden, um den Status einer Aufgabe zu Task<TResult> Status IsCanceled IsCompleted IsFaulted bestimmen. In der Regel wird ein Lambdaausdruck verwendet, um die Arbeit anzugeben, die die Aufgabe ausführen soll.

Task<TResult> -Instanzen können auf unterschiedliche Weise erstellt werden. Der gängigste Ansatz, der ab .NET Framework 4.5 verfügbar ist, ist das Aufrufen der statischen Task.Run<TResult>(Func<TResult>) -Methode oder der Task.Run<TResult>(Func<TResult>, CancellationToken) -Methode. Diese Methoden stellen eine einfache Möglichkeit zum Starten einer Aufgabe mithilfe von Standardwerten und ohne zusätzliche Parameter zur Verfügung. Im folgenden Beispiel wird die -Methode verwendet, um eine Aufgabe zu starten, die schleifent und dann die Task.Run<TResult>(Func<TResult>) Anzahl der Schleifeniterationen anzeigt:

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task<int>.Run( () => {
                                      // Just loop.
                                      int max = 1000000;
                                      int ctr = 0;
                                      for (ctr = 0; ctr <= max; ctr++) {
                                         if (ctr == max / 2 && DateTime.Now.Hour <= 12) {
                                            ctr++;
                                            break;
                                         }
                                      }
                                      return ctr;
                                    } );
      Console.WriteLine("Finished {0:N0} iterations.", t.Result);
   }
}
// The example displays output like the following:
//        Finished 1,000,001 loop iterations.
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task(Of Integer) = Task.Run(Function()
                                  Dim max As Integer = 1000000
                                  Dim ctr As Integer
                                  For ctr = 0 to max
                                     If ctr = max \ 2 And Date.Now.Hour <= 12 Then
                                        ctr += 1
                                        Exit For
                                     End If
                                  Next
                                  Return ctr
                               End Function)
      Console.WriteLine("Finished {0:N0} iterations.", t.Result)
   End Sub
End Module
' The example displays the following output:
'       Finished 1,000,001 loop iterations

Eine Alternative und die gängigste Methode zum Starten einer Aufgabe in der .NET Framework 4 ist das Aufrufen der statischen TaskFactory.StartNew -Methode oder der TaskFactory<TResult>.StartNew -Methode. Die Task.Factory -Eigenschaft gibt ein TaskFactory -Objekt zurück, und Task<TResult>.Factory die -Eigenschaft gibt ein TaskFactory<TResult> -Objekt zurück. Mit Überladungen der StartNew -Methode können Sie Argumente übergeben, Aufgabenerstellungsoptionen definieren und einen Aufgabenplaner angeben. Im folgenden Beispiel wird die TaskFactory<TResult>.StartNew(Func<TResult>) -Methode verwendet, um eine Aufgabe zu starten. Sie entspricht funktional dem Code im vorherigen Beispiel.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task<int>.Factory.StartNew( () => {
                                      // Just loop.
                                      int max = 1000000;
                                      int ctr = 0;
                                      for (ctr = 0; ctr <= max; ctr++) {
                                         if (ctr == max / 2 && DateTime.Now.Hour <= 12) {
                                            ctr++;
                                            break;
                                         }
                                      }
                                      return ctr;
                               } );
      Console.WriteLine("Finished {0:N0} iterations.", t.Result);
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t = Task(Of Integer).Factory.StartNew(Function()
                                  Dim max As Integer = 1000000
                                  Dim ctr As Integer
                                  For ctr = 0 to max
                                     If ctr = max \ 2 And Date.Now.Hour <= 12 Then
                                       ctr += 1
                                       Exit For
                                     End If
                                  Next
                                  Return ctr
                               End Function)
      Console.WriteLine("Finished {0:N0} iterations.", t.Result)
   End Sub
End Module
' The example displays output like the following:
'       Finished 1,000,001 iterations

Weitere vollständige Beispiele finden Sie unter Aufgabenbasierte asynchrone Programmierung.

Die Task<TResult> -Klasse bietet auch Konstruktoren, die den Task initialisieren, aber nicht für die Ausführung planen. Aus Leistungsgründen sind die Methoden und die bevorzugten Mechanismen zum Erstellen und Planen von Berechnungsaufgaben. In Szenarien, in denen die Aufgabenerstellung und -planung getrennt werden müssen, können jedoch die Konstruktoren verwendet werden, und die -Methode der Aufgabe kann dann verwendet werden, um die Ausführung der Aufgabe zu einem späteren Zeitpunkt zu Task.Run Task.Factory.StartNew Start planen.

Beginnend mit Desktop-Apps, die auf .NET Framework 4.6 zielen, wird die Kultur des Threads, der eine Aufgabe erstellt und aufruft, Teil des Threadkontexts. Das heißt, unabhängig von der aktuellen Kultur des Threads, in dem die Aufgabe ausgeführt wird, ist die aktuelle Kultur der Aufgabe die Kultur des aufrufenden Threads. Bei Apps, die auf Versionen der .NET Framework vor .NET Framework 4.6, ist die Kultur der Aufgabe die Kultur des Threads, in dem die Aufgabe ausgeführt wird. Weitere Informationen finden Sie im Abschnitt "Kultur und aufgabenbasierte asynchrone Vorgänge" des CultureInfo Themas. Beachten Sie, Store-Apps die Windows Runtime unter Festlegen und Abrufen der Standardkultur befolgen.

Für Vorgänge, die keinen Wert zurückgeben, verwenden Sie die Task -Klasse. Verwenden Sie ab C# 7.0 für eine schlankere Aufgabe, bei der es sich um einen Werttyp und nicht um einen Verweistyp handelt, die System.Threading.Tasks.ValueTask<TResult> -Struktur.

Konstruktoren

Task<TResult>(Func<Object,TResult>, Object)

Initialisiert einen neuen Task<TResult> mit den angegebenen Werten für Funktion und Zustand.

Task<TResult>(Func<Object,TResult>, Object, CancellationToken)

Initialisiert einen neuen Task<TResult> mit den angegebenen Werten für Aktion, Zustand und Optionen.

Task<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions)

Initialisiert einen neuen Task<TResult> mit den angegebenen Werten für Aktion, Zustand und Optionen.

Task<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)

Initialisiert einen neuen Task<TResult> mit den angegebenen Werten für Aktion, Zustand und Optionen.

Task<TResult>(Func<TResult>)

Initialisiert einen neuen Task<TResult> mit der angegebenen Funktion.

Task<TResult>(Func<TResult>, CancellationToken)

Initialisiert einen neuen Task<TResult> mit der angegebenen Funktion.

Task<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions)

Initialisiert einen neuen Task<TResult> mit den angegebenen Werten für Funktion und Erstellungsoptionen.

Task<TResult>(Func<TResult>, TaskCreationOptions)

Initialisiert einen neuen Task<TResult> mit den angegebenen Werten für Funktion und Erstellungsoptionen.

Eigenschaften

AsyncState

Ruft das beim Erstellen des Task angegebene Zustandsobjekt ab, oder NULL, wenn kein Zustandsobjekt angegeben wurde.

(Geerbt von Task)
CreationOptions

Ruft die zum Erstellen dieser Aufgabe verwendeten TaskCreationOptions ab.

(Geerbt von Task)
Exception

Ruft die AggregateException ab, die die vorzeitige Beendigung der Task verursacht hat. Wenn der Task erfolgreich abgeschlossen wurde oder noch keine Ausnahmen ausgelöst wurden, wird null zurückgegeben.

(Geerbt von Task)
Factory

Ruft eine Factorymethode zum Erstellen und Konfigurieren von Task<TResult> -Instanzen ab.

Id

Ruft eine ID für diese Task-Instanz ab.

(Geerbt von Task)
IsCanceled

Ruft einen Wert ab, der angibt, ob diese Task-Instanz die Ausführung aufgrund eines Abbruchs abgeschlossen hat.

(Geerbt von Task)
IsCompleted

Ruft einen Wert ab, der angibt, ob die Aufgabe abgeschlossen wurde.

(Geerbt von Task)
IsCompletedSuccessfully

Ruft ab, ob der Task bis zum Abschluss ausgeführt wurde.

(Geerbt von Task)
IsFaulted

Ruft einen Wert ab, der angibt, ob die Task aufgrund einer nicht behandelten Ausnahme abgeschlossen wurde.

(Geerbt von Task)
Result

Ruft den Ergebniswert dieses Task<TResult> ab.

Status

Ruft den TaskStatus dieser Aufgabe ab.

(Geerbt von Task)

Methoden

ConfigureAwait(Boolean)

Konfiguriert einen Awaiter, der verwendet wird, um diese Task<TResult> zu erwarten.

ConfigureAwait(Boolean)

Konfiguriert einen Awaiter, der verwendet wird, um diese Task zu erwarten.

(Geerbt von Task)
ContinueWith(Action<Task,Object>, Object)

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird ausgeführt, wenn der Ziel-Task abgeschlossen ist.

(Geerbt von Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken)

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.

(Geerbt von Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken empfängt und ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt und verwendet einen angegebenen Zeitplan.

(Geerbt von Task)
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird ausgeführt, wenn der Ziel-Task abgeschlossen ist. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt.

(Geerbt von Task)
ContinueWith(Action<Task,Object>, Object, TaskScheduler)

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird asynchron ausgeführt, wenn der Ziel-Task abgeschlossen ist. Die Fortsetzung verwendet einen angegebenen Zeitplan.

(Geerbt von Task)
ContinueWith(Action<Task<TResult>,Object>, Object)

Erstellt eine Fortsetzung, an die Zustandsinformationen übergeben werden und die ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen ist.

ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken)

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions)

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler)

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

ContinueWith(Action<Task<TResult>>)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn die Zielaufgabe abgeschlossen wurde.

ContinueWith(Action<Task<TResult>>, CancellationToken)

Erstellt eine abzubrechende Fortsetzung, die asynchron ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen wurde.

ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.

ContinueWith(Action<Task<TResult>>, TaskContinuationOptions)

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.

ContinueWith(Action<Task<TResult>>, TaskScheduler)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde.

ContinueWith(Action<Task>)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.

(Geerbt von Task)
ContinueWith(Action<Task>, CancellationToken)

Erstellt eine Fortsetzung, die ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.

(Geerbt von Task)
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Erstellt eine Fortsetzung, die, sobald die Zielaufgabe abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird. Die Fortsetzung empfängt ein Abbruchtoken und verwendet einen angegebenen Zeitplan.

(Geerbt von Task)
ContinueWith(Action<Task>, TaskContinuationOptions)

Erstellt eine Fortsetzung, die, sobald die Zielaufgabe abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird.

(Geerbt von Task)
ContinueWith(Action<Task>, TaskScheduler)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Die Fortsetzung verwendet einen angegebenen Zeitplan.

(Geerbt von Task)
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object)

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken)

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions)

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler)

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde.

ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde.

ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.

ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions)

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.

ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskScheduler)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object)

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird asynchron ausgeführt, wenn der Ziel-Task abgeschlossen ist, und gibt einen Wert zurück.

(Geerbt von Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken.

(Geerbt von Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Erstellt eine Fortsetzung, die entsprechend den angegebenen Aufgabenfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist, und gibt einen Wert zurück. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken und verwendet den angegebenen Zeitplan.

(Geerbt von Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)

Erstellt eine Fortsetzung, die entsprechend den angegebenen Aufgabenfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen.

(Geerbt von Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen und verwendet einen angegebenen Zeitplan.

(Geerbt von Task)
ContinueWith<TResult>(Func<Task,TResult>)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde, und gibt einen Wert zurück.

(Geerbt von Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück. Die Fortsetzung empfängt ein Abbruchtoken.

(Geerbt von Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Erstellt eine Fortsetzung, die entsprechend den angegebenen Fortsetzungsoptionen ausgeführt wird, und gibt einen Wert zurück. An die Fortsetzung wird ein Abbruchtoken übergeben, und sie verwendet einen angegebenen Zeitplan.

(Geerbt von Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)

Erstellt eine Fortsetzung, die entsprechend den angegebenen Fortsetzungsoptionen ausgeführt wird, und gibt einen Wert zurück.

(Geerbt von Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück. Die Fortsetzung verwendet einen angegebenen Zeitplan.

(Geerbt von Task)
Dispose()

Gibt alle von der aktuellen Instanz der Task-Klasse verwendeten Ressourcen frei.

(Geerbt von Task)
Dispose(Boolean)

Verwirft den Task und gibt somit alle von ihm verwendeten nicht verwalteten Ressourcen frei.

(Geerbt von Task)
Equals(Object)

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

(Geerbt von Object)
GetAwaiter()

Ruft einen Awaiter ab, der verwendet wird, um diese Task<TResult> zu erwarten.

GetAwaiter()

Ruft einen Awaiter ab, der verwendet wird, um diese Task zu erwarten.

(Geerbt von Task)
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)
RunSynchronously()

Führt den Task synchron mit dem aktuellen TaskScheduler aus.

(Geerbt von Task)
RunSynchronously(TaskScheduler)

Führt die Task synchron mit dem bereitgestellten TaskScheduler aus.

(Geerbt von Task)
Start()

Startet die Task und plant ihre Ausführung mit dem aktuellen TaskScheduler.

(Geerbt von Task)
Start(TaskScheduler)

Startet die Task und plant ihre Ausführung mit dem angegebenen TaskScheduler.

(Geerbt von Task)
ToString()

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

(Geerbt von Object)
Wait()

Wartet, bis der Task die Ausführung abschließt.

(Geerbt von Task)
Wait(CancellationToken)

Wartet, bis der Task die Ausführung abschließt. Der Wartevorgang wird beendet, wenn ein Abbruchtoken abgebrochen wird, bevor die Aufgabe abgeschlossen ist.

(Geerbt von Task)
Wait(Int32)

Wartet darauf, dass die Task innerhalb einer angegebenen Anzahl an Millisekunden vollständig ausgeführt wird.

(Geerbt von Task)
Wait(Int32, CancellationToken)

Wartet, bis der Task die Ausführung abschließt. Der Wartevorgang wird beendet, wenn ein Timeoutintervall abläuft oder ein Abbruchtoken abgebrochen wird, bevor die Aufgabe abgeschlossen ist.

(Geerbt von Task)
Wait(TimeSpan)

Wartet darauf, dass die Task innerhalb eines angegebenen Zeitintervalls vollständig ausgeführt wird.

(Geerbt von Task)
WaitAsync(CancellationToken)

Ruft einen ab, der Task<TResult> abgeschlossen wird, wenn Task<TResult> dieser abgeschlossen ist oder wenn der angegebene abbruch angefordert CancellationToken wurde.

WaitAsync(CancellationToken)

Ruft einen Task ab, der abgeschlossen wird, wenn dies abgeschlossen ist oder wenn für den Task CancellationToken angegebenen ein Abbruch angefordert wurde.

(Geerbt von Task)
WaitAsync(TimeSpan)

Ruft einen ab, der Task<TResult> abgeschlossen wird, wenn dieser Task<TResult> abgeschlossen wird oder wenn das angegebene Timeout abläuft.

WaitAsync(TimeSpan)

Ruft einen Task ab, der abgeschlossen wird, wenn dies abgeschlossen ist Task oder wenn das angegebene Timeout abläuft.

(Geerbt von Task)
WaitAsync(TimeSpan, CancellationToken)

Ruft einen ab, der Task<TResult> abgeschlossen wird, wenn dieser Task<TResult> abgeschlossen ist, wenn das angegebene Timeout abläuft oder wenn der angegebene CancellationToken abbruch angefordert wurde.

WaitAsync(TimeSpan, CancellationToken)

Ruft einen ab, der abgeschlossen wird, wenn dies abgeschlossen ist, wenn das angegebene Timeout abläuft oder wenn für den angegebenen Task Task ein CancellationToken Abbruch angefordert wurde.

(Geerbt von Task)

Explizite Schnittstellenimplementierungen

IAsyncResult.AsyncWaitHandle

Ruft ein WaitHandle ab, das verwendet werden kann, um auf den Abschluss der Aufgabe zu warten.

(Geerbt von Task)
IAsyncResult.CompletedSynchronously

Ruft einen Wert ab, der angibt, ob der Vorgang synchron abgeschlossen wurde.

(Geerbt von Task)

Erweiterungsmethoden

DispatcherOperationWait(Task)

Wartet, bis die zugrunde liegende DispatcherOperation abgeschlossen ist.

DispatcherOperationWait(Task, TimeSpan)

Wartet die angegebene Zeitdauer auf den Abschluss der zugrunde liegenden DispatcherOperation.

IsDispatcherOperationTask(Task)

Gibt einen Wert zurück, mit dem angegeben wird, ob eine Task mit einer DispatcherOperation verknüpft ist.

AsAsyncAction(Task)

Gibt eine asynchrone Windows-Runtime-Aktion zurück, die eine begonnene Aufgabe darstellt.

AsAsyncOperation<TResult>(Task<TResult>)

Gibt einen asynchronen Windows-Runtime-Vorgang zurück, der eine begonnene Aufgabe darstellt, die ein Ergebnis zurückgibt.

Gilt für

Threadsicherheit

Alle Member von Task<TResult> , mit Ausnahme von , sind threadsicher und können von mehreren Threads gleichzeitig verwendet Dispose() werden.

Siehe auch