Task<TResult> Klasse

Definition

Namespace:

System.Threading.Tasks

Assembly:

System.Runtime.dll

Quelle:

Future.cs

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

Object

Task

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 in .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 Hauptanwendungsthread ausgeführt wird, können Sie die Status-Eigenschaft sowie die eigenschaften IsCanceled, IsCompletedund IsFaulted verwenden, um den Status einer Aufgabe zu bestimmen. In der Regel wird ein Lambda-Ausdruck verwendet, um die Auszuführende Arbeit anzugeben.

Task<TResult> Instanzen können auf unterschiedliche Weise erstellt werden. Der am häufigsten verwendete Ansatz, der ab .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 zum Starten einer Aufgabe mithilfe von Standardwerten und ohne Abrufen zusätzlicher Parameter. 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 am häufigsten verwendete Methode zum Starten einer Aufgabe in .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 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 Vorgang initialisieren, aber nicht für die Ausführung planen. Aus Leistungsgründen sind die methoden Task.Run und Task.Factory.StartNew die bevorzugten Mechanismen zum Erstellen und Planen von Rechenvorgängen, aber für Szenarien, in denen die Erstellung und Planung von Vorgängen getrennt werden müssen, können die Konstruktoren verwendet werden, und die Start Methode des Vorgangs kann dann verwendet werden, um den Vorgang zu einem späteren Zeitpunkt für die Ausführung zu planen.

Beginnend mit Desktop-Apps, die auf .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, auf dem die Aufgabe ausgeführt wird, ist die aktuelle Kultur der Aufgabe die Kultur des aufrufenden Threads. Bei Apps, die auf Versionen von .NET Framework vor .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 thema CultureInfo. Beachten Sie, dass Store-Apps den Windows-Runtime-Einstellungen folgen und die Standardkultur abrufen.

Für Vorgänge, die keinen Wert zurückgeben, verwenden Sie die Task Klasse. Verwenden Sie ab C# 7.0 für einen einfacheren Vorgang, der einen Werttyp und nicht einen Verweistyp ist, die System.Threading.Tasks.ValueTask<TResult> Struktur.

Konstruktoren

Task<TResult>(Func<Object,TResult>, Object)	Initialisiert eine neue Task<TResult> mit der angegebenen Funktion und dem angegebenen Zustand.
Task<TResult>(Func<Object,TResult>, Object, CancellationToken)	Initialisiert eine neue Task<TResult> mit der angegebenen Aktion, dem Angegebenen Zustand und den Optionen.
Task<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions)	Initialisiert eine neue Task<TResult> mit der angegebenen Aktion, dem Angegebenen Zustand und den Optionen.
Task<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	Initialisiert eine neue Task<TResult> mit der angegebenen Aktion, dem Angegebenen Zustand und den Optionen.
Task<TResult>(Func<TResult>)	Initialisiert eine neue Task<TResult> mit der angegebenen Funktion.
Task<TResult>(Func<TResult>, CancellationToken)	Initialisiert eine neue Task<TResult> mit der angegebenen Funktion.
Task<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions)	Initialisiert eine neue Task<TResult> mit den angegebenen Funktionen und Erstellungsoptionen.
Task<TResult>(Func<TResult>, TaskCreationOptions)	Initialisiert eine neue Task<TResult> mit den angegebenen Funktionen und Erstellungsoptionen.

Eigenschaften

AsyncState	Ruft das Zustandsobjekt ab, das beim Erstellen der Task angegeben wurde, oder null, wenn keine angegeben wurde. (Geerbt von Task)
CreationOptions	Ruft die zum Erstellen dieser Aufgabe verwendete TaskCreationOptions ab. (Geerbt von Task)
Exception	Ruft die AggregateException, die dazu führte, dass die Task vorzeitig beendet wurde. Wenn die Task erfolgreich abgeschlossen wurde oder noch keine Ausnahmen ausgelöst hat, gibt dies nullzurück. (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 ab, ob diese Task Instanz die Ausführung abgeschlossen hat, da sie abgebrochen wurde. (Geerbt von Task)
IsCompleted	Ruft einen Wert ab, der angibt, ob die Aufgabe abgeschlossen wurde. (Geerbt von Task)
IsCompletedSuccessfully	Ruft ab, ob die Aufgabe abgeschlossen wurde. (Geerbt von Task)
IsFaulted	Ruft ab, ob die Task aufgrund einer unbehandelten Ausnahme abgeschlossen wurde. (Geerbt von Task)
Result	Ruft den Ergebniswert dieser Task<TResult>ab.
Status	Ruft die TaskStatus dieser Aufgabe ab. (Geerbt von Task)

Methoden

ConfigureAwait(Boolean)	Konfiguriert einen Awaiter, der für dieses Task<TResult>verwendet wird.
ConfigureAwait(ConfigureAwaitOptions)	Konfiguriert einen Awaiter, der für dieses Taskverwendet wird.
ContinueWith(Action<Task,Object>, Object)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Statusinformationen empfängt und ausgeführt wird, wenn das Ziel abgeschlossen Task. (Geerbt von Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Statusinformationen und ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task. (Geerbt von Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Statusinformationen und ein Abbruchtoken empfängt und ausgeführt wird, wenn das Ziel abgeschlossen Task. Die Fortsetzung wird basierend auf einer Reihe von angegebenen Bedingungen ausgeführt und verwendet einen angegebenen Zeitplan. (Geerbt von Task)
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Statusinformationen empfängt und ausgeführt wird, wenn das Ziel abgeschlossen Task. Die Fortsetzung wird basierend auf einer Reihe von angegebenen Bedingungen ausgeführt. (Geerbt von Task)
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Statusinformationen empfängt und asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task. Die Fortsetzung verwendet einen angegebenen Zeitplan. (Geerbt von Task)
ContinueWith(Action<Task<TResult>,Object>, Object)	Erstellt eine Fortsetzung, die Zustandsinformationen übergeben wird und ausgeführt wird, wenn das Ziel abgeschlossen Task<TResult>.
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken)	Erstellt eine Fortsetzung, die ausgeführt wird, wenn das Ziel abgeschlossen Task<TResult>.
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die ausgeführt wird, wenn das Ziel abgeschlossen Task<TResult>.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions)	Erstellt eine Fortsetzung, die ausgeführt wird, wenn das Ziel abgeschlossen Task<TResult>.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler)	Erstellt eine Fortsetzung, die ausgeführt wird, wenn das Ziel abgeschlossen Task<TResult>.
ContinueWith(Action<Task<TResult>>)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn die Zielaufgabe abgeschlossen ist.
ContinueWith(Action<Task<TResult>>, CancellationToken)	Erstellt eine abbruchfähige Fortsetzung, die asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task<TResult>.
ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die gemäß der in continuationOptionsangegebenen Bedingung ausgeführt wird.
ContinueWith(Action<Task<TResult>>, TaskContinuationOptions)	Erstellt eine Fortsetzung, die gemäß der in continuationOptionsangegebenen Bedingung ausgeführt wird.
ContinueWith(Action<Task<TResult>>, TaskScheduler)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task<TResult>.
ContinueWith(Action<Task>)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task. (Geerbt von Task)
ContinueWith(Action<Task>, CancellationToken)	Erstellt eine Fortsetzung, die ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task. (Geerbt von Task)
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Zielaufgabe gemäß der angegebenen TaskContinuationOptionskonkurriert. Die Fortsetzung empfängt ein Abbruchtoken und verwendet einen angegebenen Zeitplan. (Geerbt von Task)
ContinueWith(Action<Task>, TaskContinuationOptions)	Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Zielaufgabe gemäß der angegebenen TaskContinuationOptionsabgeschlossen wird. (Geerbt von Task)
ContinueWith(Action<Task>, TaskScheduler)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task. 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 das Ziel abgeschlossen Task<TResult>.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken)	Erstellt eine Fortsetzung, die ausgeführt wird, wenn das Ziel abgeschlossen Task<TResult>.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die ausgeführt wird, wenn das Ziel abgeschlossen Task<TResult>.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions)	Erstellt eine Fortsetzung, die ausgeführt wird, wenn das Ziel abgeschlossen Task<TResult>.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler)	Erstellt eine Fortsetzung, die ausgeführt wird, wenn das Ziel abgeschlossen Task<TResult>.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task<TResult>.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task<TResult>.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die gemäß der in continuationOptionsangegebenen Bedingung ausgeführt wird.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions)	Erstellt eine Fortsetzung, die gemäß der in continuationOptionsangegebenen Bedingung ausgeführt wird.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskScheduler)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task<TResult>.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Statusinformationen empfängt und asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task und einen Wert zurückgibt. (Geerbt von Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task und einen Wert zurückgibt. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Statusinformationen und ein Abbruchtoken. (Geerbt von Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die basierend auf den angegebenen Vorgangsfortsetzungsoptionen ausgeführt wird, wenn das Ziel abgeschlossen Task und einen Wert zurückgibt. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Statusinformationen und ein Abbruchtoken und verwendet den angegebenen Zeitplan. (Geerbt von Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	Erstellt eine Fortsetzung, die basierend auf den angegebenen Vorgangsfortsetzungsoptionen ausgeführt wird, wenn das Ziel abgeschlossen Task. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Statusinformationen. (Geerbt von Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Statusinformationen und verwendet einen angegebenen Zeitplan. (Geerbt von Task)
ContinueWith<TResult>(Func<Task,TResult>)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task<TResult> und einen Wert zurückgibt. (Geerbt von Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task und einen Wert zurückgibt. Die Fortsetzung empfängt ein Abbruchtoken. (Geerbt von Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die gemäß den angegebenen Fortsetzungsoptionen ausgeführt wird und einen Wert zurückgibt. Die Fortsetzung wird ein Abbruchtoken übergeben und verwendet einen angegebenen Zeitplan. (Geerbt von Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)	Erstellt eine Fortsetzung, die gemäß den angegebenen Fortsetzungsoptionen ausgeführt wird und einen Wert zurückgibt. (Geerbt von Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn das Ziel abgeschlossen Task und einen Wert zurückgibt. Die Fortsetzung verwendet einen angegebenen Zeitplan. (Geerbt von Task)
Dispose()	Gibt alle Ressourcen frei, die von der aktuellen Instanz der Task Klasse verwendet werden. (Geerbt von Task)
Dispose(Boolean)	Entfernt die Task, wobei alle nicht verwalteten Ressourcen freigegeben werden. (Geerbt von Task)
Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object)
GetAwaiter()	Ruft einen Awaiter ab, der für dieses Task<TResult>verwendet wird.
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)
RunSynchronously()	Führt die Task synchron auf dem aktuellen TaskScheduleraus. (Geerbt von Task)
RunSynchronously(TaskScheduler)	Führt die Task synchron auf dem bereitgestellten TaskScheduler aus. (Geerbt von Task)
Start()	Startet die Taskund plant sie für die Ausführung bis zur aktuellen TaskScheduler. (Geerbt von Task)
Start(TaskScheduler)	Startet die Task, und plant sie für die Ausführung an der angegebenen TaskScheduler. (Geerbt von Task)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
Wait()	Wartet auf den Abschluss der Ausführung des Task. (Geerbt von Task)
Wait(CancellationToken)	Wartet auf den Abschluss der Ausführung des Task. Die Wartezeit wird beendet, wenn ein Abbruchtoken abgebrochen wird, bevor die Aufgabe abgeschlossen ist. (Geerbt von Task)
Wait(Int32)	Wartet, bis die Task die Ausführung innerhalb einer angegebenen Anzahl von Millisekunden abgeschlossen hat. (Geerbt von Task)
Wait(Int32, CancellationToken)	Wartet auf den Abschluss der Ausführung des Task. Die Wartezeit wird beendet, wenn ein Timeoutintervall verstrichen ist oder ein Abbruchtoken abgebrochen wird, bevor die Aufgabe abgeschlossen wird. (Geerbt von Task)
Wait(TimeSpan)	Wartet, bis die Task die Ausführung innerhalb eines angegebenen Zeitintervalls abgeschlossen hat. (Geerbt von Task)
Wait(TimeSpan, CancellationToken)	Wartet auf den Abschluss der Ausführung des Task. (Geerbt von Task)
WaitAsync(CancellationToken)	Ruft eine Task<TResult> ab, die abgeschlossen wird, wenn diese Task<TResult> abgeschlossen ist oder wenn die angegebene CancellationToken den Abbruch angefordert hat.
WaitAsync(TimeSpan)	Ruft eine Task<TResult> ab, die abgeschlossen wird, wenn diese Task<TResult> abgeschlossen ist oder wenn das angegebene Timeout abläuft.
WaitAsync(TimeSpan, CancellationToken)	Ruft eine Task<TResult> ab, die abgeschlossen wird, wenn diese Task<TResult> abgeschlossen ist, wann das angegebene Timeout abläuft oder wenn die angegebene CancellationToken den Abbruch angefordert hat.
WaitAsync(TimeSpan, TimeProvider)	Ruft eine Task<TResult> ab, die abgeschlossen wird, wenn diese Task<TResult> abgeschlossen ist oder wenn das angegebene Timeout abläuft.
WaitAsync(TimeSpan, TimeProvider, CancellationToken)	Ruft eine Task<TResult> ab, die abgeschlossen wird, wenn diese Task<TResult> abgeschlossen ist, wann das angegebene Timeout abläuft oder wenn die angegebene CancellationToken den Abbruch angefordert hat.

Explizite Schnittstellenimplementierungen

IAsyncResult.AsyncWaitHandle	Ruft eine WaitHandle ab, die verwendet werden kann, um auf den Abschluss der Aufgabe zu warten. (Geerbt von Task)
IAsyncResult.CompletedSynchronously	Ruft einen Hinweis darauf ab, ob der Vorgang synchron abgeschlossen wurde. (Geerbt von Task)

Erweiterungsmethoden

AsyncWait<TException>(Task)	Stellt einen asynchronen Vorgang dar, der einen Wert zurückgeben kann.
AwaitWithTimeout(Task, TimeSpan)	Stellt einen asynchronen Vorgang dar, der einen Wert zurückgeben kann.
ToApm(Task, AsyncCallback, Object)	Stellt einen asynchronen Vorgang dar, der einen Wert zurückgeben kann.
ToApm<TResult>(Task<TResult>, AsyncCallback, Object)	Stellt einen asynchronen Vorgang dar, der einen Wert zurückgeben kann.
ToApmEnd(IAsyncResult)	Stellt einen asynchronen Vorgang dar, der einen Wert zurückgeben kann.
ToApmEnd<TResult>(IAsyncResult)	Stellt einen asynchronen Vorgang dar, der einen Wert zurückgeben kann.
Wait(Task, TimeSpan, Action<Exception,TimeSpan,String>, String)	Stellt einen asynchronen Vorgang dar, der einen Wert zurückgeben kann.
WaitForCompletion(Task)	Stellt einen asynchronen Vorgang dar, der einen Wert zurückgeben kann.
WaitForCompletion<TResult>(Task<TResult>)	Stellt einen asynchronen Vorgang dar, der einen Wert zurückgeben kann.
WaitForCompletionNoSpin(Task)	Stellt einen asynchronen Vorgang dar, der einen Wert zurückgeben kann.
WaitForCompletionNoSpin(Task, TimeSpan)	Stellt einen asynchronen Vorgang dar, der einen Wert zurückgeben kann.
WaitForCompletionNoSpin<TResult>(Task<TResult>)	Stellt einen asynchronen Vorgang dar, der einen Wert zurückgeben kann.
WaitAsync(Task, TimeSpan, TimeProvider, CancellationToken)	Ruft eine Task ab, die abgeschlossen wird, wenn diese Task abgeschlossen ist, wann das angegebene Timeout abläuft oder wenn die angegebene CancellationToken den Abbruch angefordert hat.
WaitAsync<TResult>(Task<TResult>, TimeSpan, TimeProvider, CancellationToken)	Ruft eine Task ab, die abgeschlossen wird, wenn diese Task abgeschlossen ist, wann das angegebene Timeout abläuft oder wenn die angegebene CancellationToken den Abbruch angefordert hat.

Threadsicherheit

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

Weitere Informationen

• Task
• Task Parallel Library (TPL)
• aufgabenbasierte asynchrone Programmierung
• Beispiele für parallele Programmierung mit .NET Core und .NET Standard