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 der .NET Framework 4 eingeführt wurde. Da die von einem Task<TResult> Objekt ausgeführte Arbeit in der Regel asynchron auf einem Threadpoolthread statt synchron im Hauptanwendungsthread ausgeführt wird, können Sie die Eigenschaft sowie die Status IsCanceledEigenschaften IsCompletedund IsFaulted Eigenschaften verwenden, um den Status einer Aufgabe zu bestimmen. Am häufigsten wird ein Lambda-Ausdruck verwendet, um die Auszuführende Arbeit anzugeben.

Task<TResult> Instanzen können auf verschiedene Arten erstellt werden. Der am häufigsten verwendete Ansatz, der ab dem .NET Framework 4.5 verfügbar ist, besteht darin, die statische Task.Run<TResult>(Func<TResult>) oder Task.Run<TResult>(Func<TResult>, CancellationToken) Methode aufzurufen. Diese Methoden bieten eine einfache Möglichkeit, einen Vorgang mithilfe von Standardwerten zu starten und ohne zusätzliche Parameter zu erwerben. Im folgenden Beispiel wird die Task.Run<TResult>(Func<TResult>) Methode verwendet, um eine Aufgabe zu starten, die schleift, und zeigt dann die Anzahl der Loop-Iterationen an:

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 am häufigsten verwendete Methode zum Starten einer Aufgabe in der .NET Framework 4 besteht darin, die statische TaskFactory.StartNew oder TaskFactory<TResult>.StartNew Methode aufzurufen. Die Task.Factory Eigenschaft gibt ein TaskFactory Objekt zurück, und die Task<TResult>.Factory Eigenschaft gibt ein TaskFactory<TResult> Objekt zurück. Überladungen ihrer StartNew Methode ermöglichen es Ihnen, Argumente zu übergeben, Aufgabenerstellungsoptionen zu definieren und einen Aufgabenplaner anzugeben. Im folgenden Beispiel wird die TaskFactory<TResult>.StartNew(Func<TResult>) Methode zum Starten einer Aufgabe verwendet. Sie entspricht 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 außerdem Konstruktoren bereit, die den Vorgang initialisieren, aber die Ausführung nicht planen. Aus Leistungsgründen sind die Task.Run Methoden Task.Factory.StartNew die bevorzugten Mechanismen zum Erstellen und Planen von Rechenvorgängen, aber für Szenarien, in denen die Vorgangserstellung und -planung getrennt sein müssen, können die Konstruktoren verwendet werden, und die Methode des Vorgangs Start kann dann verwendet werden, um den Vorgang zur Ausführung zu einem späteren Zeitpunkt zu planen.

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

Bei Vorgängen, die keinen Wert zurückgeben, verwenden Sie die Task Klasse. Verwenden Sie ab C# 7.0 für einen einfacheren Vorgang, der einen Werttyp anstelle eines Verweistyps ist, 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)
Wait(TimeSpan, CancellationToken)

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

(Geerbt von Task)
WaitAsync(CancellationToken)

Ruft ein Task<TResult> , das abgeschlossen wird, wenn dies Task<TResult> abgeschlossen ist oder wenn der angegebene CancellationToken Abbruch angefordert wurde.

WaitAsync(CancellationToken)

Ruft ein Task , das abgeschlossen wird, wenn dies Task abgeschlossen ist oder wenn die angegebene CancellationToken Abbruch angefordert wurde.

(Geerbt von Task)
WaitAsync(TimeSpan)

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

WaitAsync(TimeSpan)

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

(Geerbt von Task)
WaitAsync(TimeSpan, CancellationToken)

Ruft ab Task<TResult> , die abgeschlossen wird, wenn das Task<TResult> angegebene Timeout abläuft, oder wenn die angegebene CancellationToken Kündigung angefordert wurde.

WaitAsync(TimeSpan, CancellationToken)

Ruft ein Task Task , das abgeschlossen wird, wenn das angegebene Timeout abläuft, oder wenn die angegebene CancellationToken Kündigung 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>, außer für Dispose(), sind threadsicher und können gleichzeitig von mehreren Threads verwendet werden.

Siehe auch