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 normalerweise asynchron ausgeführt wird. Task<TResult>-Objekte sind eine der zentralen Komponenten des aufgabenbasierten asynchronen Musters, das erstmals im .NET Framework 4 eingeführt wurde. Da die von einem Task<TResult> -Objekt ausgeführte Arbeit in der Regel asynchron in einem Threadpoolthread und nicht synchron im Standard Anwendungsthreads ausgeführt wird, können Sie die Status -Eigenschaft sowie die IsCanceledEigenschaften , IsCompletedund IsFaulted verwenden, um den Status einer Aufgabe zu bestimmen. In der Regel wird ein Lambdaausdruck verwendet, um die Arbeit anzugeben, die die Aufgabe ausführen soll.

Task<TResult> -Instanzen können auf verschiedene Arten erstellt werden. Der gebräuchlichste Ansatz, der ab dem .NET Framework 4.5 verfügbar ist, ist das Aufrufen der statischen Task.Run<TResult>(Func<TResult>) Oder Task.Run<TResult>(Func<TResult>, CancellationToken) -Methode. Diese Methoden bieten eine einfache Möglichkeit, eine Aufgabe mithilfe von Standardwerten zu starten, ohne zusätzliche Parameter zu erhalten. Im folgenden Beispiel wird die Task.Run<TResult>(Func<TResult>) -Methode verwendet, um eine Aufgabe zu starten, die schleift und dann die 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 häufigste Methode zum Starten einer Aufgabe im .NET Framework 4 ist das Aufrufen der statischen TaskFactory.StartNew Oder TaskFactory<TResult>.StartNew -Methode. Die Task.Factory -Eigenschaft gibt ein TaskFactory -Objekt zurück, und die Task<TResult>.Factory -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

Ausführlichere Beispiele finden Sie unter Aufgabenbasierte asynchrone Programmierung.

Die Task<TResult> -Klasse stellt auch Konstruktoren bereit, die den Task initialisieren, aber die Ausführung nicht planen. Aus Leistungsgründen sind die Task.Run Methoden und Task.Factory.StartNew die Methoden die bevorzugten Mechanismen zum Erstellen und Planen von Rechenaufgaben, aber in Szenarien, in denen die Vorgangserstellung und -planung getrennt werden müssen, können die Konstruktoren verwendet werden, und die -Methode des Vorgangs kann dann verwendet werden, um die Ausführung des Vorgangs Start zu einem späteren Zeitpunkt zu planen.

Ab Desktop-Apps, die auf die .NET Framework 4.6 abzielen, 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. Für Apps, die Versionen der .NET Framework vor dem .NET Framework 4.6 als Ziel verwenden, 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 Themas CultureInfo . Beachten Sie, dass Store-Apps den Windows-Runtime unter Einstellung und Abrufen der Standardkultur folgen.

Für Vorgänge, die keinen Wert zurückgeben, verwenden Sie die Task -Klasse. Ab C# 7.0 verwenden Sie für eine einfachere 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)
ConfigureAwait(ConfigureAwaitOptions)

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

ConfigureAwait(ConfigureAwaitOptions)

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)
Wait(TimeSpan, CancellationToken)

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

(Geerbt von Task)
WaitAsync(CancellationToken)

Ruft eine Task<TResult> ab, die abgeschlossen wird, wenn dies Task<TResult> abgeschlossen ist oder wenn der angegebene CancellationToken Abbruch angefordert wurde.

WaitAsync(CancellationToken)

Ruft eine Task ab, die abgeschlossen wird, wenn dies Task abgeschlossen ist oder wenn der angegebene CancellationToken Abbruch angefordert wurde.

(Geerbt von Task)
WaitAsync(TimeSpan)

Ruft eine Task<TResult> ab, die abgeschlossen wird, wenn dies Task<TResult> abgeschlossen ist oder das angegebene Timeout abläuft.

WaitAsync(TimeSpan)

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

(Geerbt von Task)
WaitAsync(TimeSpan, CancellationToken)

Ruft eine Task<TResult> ab, die abgeschlossen wird, wenn dies Task<TResult> abgeschlossen ist, wenn das angegebene Timeout abläuft oder wenn der angegebene CancellationToken Abbruch angefordert wurde.

WaitAsync(TimeSpan, CancellationToken)

Ruft eine Task ab, die abgeschlossen wird, wenn dies Task abgeschlossen ist, wenn das angegebene Timeout abläuft oder wenn der angegebene CancellationToken Abbruch angefordert wurde.

(Geerbt von Task)
WaitAsync(TimeSpan, TimeProvider)

Ruft eine Task<TResult> ab, die abgeschlossen wird, wenn dies Task<TResult> abgeschlossen ist oder das angegebene Timeout abläuft.

WaitAsync(TimeSpan, TimeProvider)

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

(Geerbt von Task)
WaitAsync(TimeSpan, TimeProvider, CancellationToken)

Ruft eine Task<TResult> ab, die abgeschlossen wird, wenn dies Task<TResult> abgeschlossen ist, wenn das angegebene Timeout abläuft oder wenn der angegebene CancellationToken Abbruch angefordert wurde.

WaitAsync(TimeSpan, TimeProvider, CancellationToken)

Ruft eine Task ab, die abgeschlossen wird, wenn dies Task abgeschlossen ist, wenn das angegebene Timeout abläuft oder wenn der angegebene 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 sind mit Ausnahme Dispose()von Task<TResult>threadsicher und können von mehreren Threads gleichzeitig verwendet werden.

Weitere Informationen