Windows-Apps
Inhaltsverzeichnis reduzieren
Inhaltsverzeichnis erweitern
Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch
Informationen
Das angeforderte Thema wird unten angezeigt. Es ist jedoch nicht in dieser Bibliothek vorhanden.

Task-Klasse

.NET Framework (current version)
 

Veröffentlicht: Oktober 2016

Stellt einen asynchronen Vorgang dar.

Um den .NET-Framework-Quellcode für diesen Typ zu durchsuchen, schauen Sie bei der Reference Source.

Namespace:   System.Threading.Tasks
Assembly:  mscorlib (in mscorlib.dll)

System.Object
  System.Threading.Tasks.Task
    System.Threading.Tasks.Task<TResult>

[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public class Task : IAsyncResult, IDisposable

NameBeschreibung
System_CAPS_pubmethodTask(Action)

Initialisiert eine neue Task mit der angegebenen Aktion.

System_CAPS_pubmethodTask(Action, CancellationToken)

Initialisiert eine neue Task mit den angegebenen Werten für Aktion und CancellationToken.

System_CAPS_pubmethodTask(Action, CancellationToken, TaskCreationOptions)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen.

System_CAPS_pubmethodTask(Action, TaskCreationOptions)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen.

System_CAPS_pubmethodTask(Action<Object>, Object)

Initialisiert eine neue Task mit den angegebenen Werten für Aktion und Zustand.

System_CAPS_pubmethodTask(Action<Object>, Object, CancellationToken)

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

System_CAPS_pubmethodTask(Action<Object>, Object, CancellationToken, TaskCreationOptions)

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

System_CAPS_pubmethodTask(Action<Object>, Object, TaskCreationOptions)

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

NameBeschreibung
System_CAPS_pubpropertyAsyncState

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

System_CAPS_pubpropertySystem_CAPS_staticCompletedTask

Ruft eine Aufgabe ab, die bereits erfolgreich abgeschlossen wurde.

System_CAPS_pubpropertyCreationOptions

Ruft die zum Erstellen dieser Aufgabe verwendeten TaskCreationOptions ab.

System_CAPS_pubpropertySystem_CAPS_staticCurrentId

Gibt die ID der momentan ausgeführten Task zurück.

System_CAPS_pubpropertyException

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

System_CAPS_pubpropertySystem_CAPS_staticFactory

Bietet Zugriff auf Factorymethoden zum Erstellen und Konfigurieren von Task- und Task<TResult>-Instanzen.

System_CAPS_pubpropertyId

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

System_CAPS_pubpropertyIsCanceled

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

System_CAPS_pubpropertyIsCompleted

Ruft einen Wert ab, der angibt, ob diese Task abgeschlossen wurde.

System_CAPS_pubpropertyIsFaulted

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

System_CAPS_pubpropertyStatus

Ruft den TaskStatus dieser Aufgabe ab.

NameBeschreibung
System_CAPS_pubmethodConfigureAwait(Boolean)

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

System_CAPS_pubmethodContinueWith(Action<Task, Object>, Object)

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

System_CAPS_pubmethodContinueWith(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.

System_CAPS_pubmethodContinueWith(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.

System_CAPS_pubmethodContinueWith(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.

System_CAPS_pubmethodContinueWith(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.

System_CAPS_pubmethodContinueWith(Action<Task>)

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

System_CAPS_pubmethodContinueWith(Action<Task>, CancellationToken)

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

System_CAPS_pubmethodContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)

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

System_CAPS_pubmethodContinueWith(Action<Task>, TaskContinuationOptions)

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

System_CAPS_pubmethodContinueWith(Action<Task>, TaskScheduler)

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

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<TResult>(Func<Task, TResult>, TaskContinuationOptions)

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

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<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.

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

Erstellt eine Fortsetzung, die entsprechend den angegebenen Taskfortsetzungsoptionen 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.

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

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

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodSystem_CAPS_staticDelay(Int32)

Erstellt eine Aufgabe, die nach einer Verzögerung abgeschlossen wird.

System_CAPS_pubmethodSystem_CAPS_staticDelay(Int32, CancellationToken)

Erstellt eine abzubrechende Aufgabe, die nach einer Verzögerung abgeschlossen wird.

System_CAPS_pubmethodSystem_CAPS_staticDelay(TimeSpan)

Erstellt eine Aufgabe, die nach Ablauf einer festgelegten Zeitspanne abgeschlossen wird.

System_CAPS_pubmethodSystem_CAPS_staticDelay(TimeSpan, CancellationToken)

Erstellt eine abzubrechende Aufgabe, die nach Ablauf einer festgelegten Zeitspanne abgeschlossen wird.

System_CAPS_pubmethodDispose()

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

System_CAPS_protmethodDispose(Boolean)

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

System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von „Object“.)

System_CAPS_protmethodFinalize()

Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Geerbt von „Object“.)

System_CAPS_pubmethodSystem_CAPS_staticFromCanceled(CancellationToken)

Erstellt eine durch Abbruch abgeschlossene Task mit einem angegebenen Abbruchtoken.

System_CAPS_pubmethodSystem_CAPS_staticFromCanceled<TResult>(CancellationToken)

Erstellt eine durch Abbruch abgeschlossene Task<TResult> mit einem angegebenen Abbruchtoken.

System_CAPS_pubmethodSystem_CAPS_staticFromException(Exception)

Erstellt eine durch eine angegebene Ausnahme abgeschlossene Task.

System_CAPS_pubmethodSystem_CAPS_staticFromException<TResult>(Exception)

Erstellt eine durch eine angegebene Ausnahme abgeschlossene Task<TResult>.

System_CAPS_pubmethodSystem_CAPS_staticFromResult<TResult>(TResult)

Erstellt eine Task<TResult>, die erfolgreich mit dem angegebenen Ergebnis abgeschlossen wurde.

System_CAPS_pubmethodGetAwaiter()

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

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von „Object“.)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_protmethodMemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.(Geerbt von „Object“.)

System_CAPS_pubmethodSystem_CAPS_staticRun(Action)

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschlange hinzu und gibt ein Task-Objekt zurück, das diese Aufgabe darstellt.

System_CAPS_pubmethodSystem_CAPS_staticRun(Action, CancellationToken)

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschlange hinzu und gibt ein Task-Objekt zurück, das diese Aufgabe darstellt. Ein Abbruchtoken ermöglicht den Abbruch der Arbeit.

System_CAPS_pubmethodSystem_CAPS_staticRun(Func<Task>)

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschleife hinzu und gibt einen Proxy für die Aufgabe zurück, die von function zurückgegeben wird.

System_CAPS_pubmethodSystem_CAPS_staticRun(Func<Task>, CancellationToken)

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschleife hinzu und gibt einen Proxy für die Aufgabe zurück, die von function zurückgegeben wird.

System_CAPS_pubmethodSystem_CAPS_staticRun<TResult>(Func<TResult>)

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschlange hinzu und gibt ein Task<TResult>-Objekt zurück, das diese Aufgabe darstellt.

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

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschlange hinzu und gibt ein Task(TResult)-Objekt zurück, das diese Aufgabe darstellt. Ein Abbruchtoken ermöglicht den Abbruch der Arbeit.

System_CAPS_pubmethodSystem_CAPS_staticRun<TResult>(Func<Task<TResult>>)

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschleife hinzu und gibt einen Proxy für die Task(TResult) zurück, die von function zurückgegeben wird.

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

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschleife hinzu und gibt einen Proxy für die Task(TResult) zurück, die von function zurückgegeben wird.

System_CAPS_pubmethodRunSynchronously()

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

System_CAPS_pubmethodRunSynchronously(TaskScheduler)

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

System_CAPS_pubmethodStart()

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

System_CAPS_pubmethodStart(TaskScheduler)

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

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von „Object“.)

System_CAPS_pubmethodWait()

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

System_CAPS_pubmethodWait(CancellationToken)

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

System_CAPS_pubmethodWait(Int32)

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

System_CAPS_pubmethodWait(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.

System_CAPS_pubmethodWait(TimeSpan)

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

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[])

Wartet, bis alle bereitgestellten Task-Objekte die Ausführung abschließen.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], CancellationToken)

Wartet, bis alle bereitgestellten Task-Objekte die Ausführung abschließen oder bis der Wartevorgang abgebrochen wird.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], Int32)

Wartet darauf, dass alle bereitgestellten Task-Objekte innerhalb einer angegebenen Anzahl an Millisekunden vollständig ausgeführt werden.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], Int32, CancellationToken)

Wartet darauf, dass alle bereitgestellten Task-Objekte innerhalb einer angegebenen Anzahl an Millisekunden oder vollständig ausgeführt werden, oder bis zum Abbruch des Wartevorgangs.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], TimeSpan)

Wartet darauf, dass alle bereitgestellten Task-Objekte, die abgebrochen werden können, innerhalb eines angegebenen Zeitintervalls vollständig ausgeführt werden.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[])

Wartet, bis eines der bereitgestellten Task-Objekte die Ausführung abschließt.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], CancellationToken)

Wartet, bis bereitgestellte Task-Objekte die Ausführung abschließen oder bis der Wartevorgang abgebrochen wird.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], Int32)

Wartet darauf, dass bereitgestellte Task-Objekte innerhalb einer angegebenen Anzahl an Millisekunden vollständig ausgeführt werden.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], Int32, CancellationToken)

Wartet darauf, dass bereitgestellte Task-Objekte innerhalb einer angegebenen Anzahl an Millisekunden oder vollständig ausgeführt werden, oder bis ein Abbruchtoken abgebrochen wird.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], TimeSpan)

Wartet darauf, dass bereitgestellte Task-Objekte, die abgebrochen werden können, innerhalb eines angegebenen Zeitintervalls vollständig ausgeführt werden.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll(IEnumerable<Task>)

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task-Objekte in einer aufzählbaren Auflistung abgeschlossen sind.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll(Task[])

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task-Objekte in einem Array abgeschlossen sind.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll<TResult>(IEnumerable<Task<TResult>>)

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult>-Objekte in einer aufzählbaren Auflistung abgeschlossen sind.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll<TResult>(Task<TResult>[])

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult>-Objekte in einem Array abgeschlossen sind.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny(IEnumerable<Task>)

Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny(Task[])

Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny<TResult>(IEnumerable<Task<TResult>>)

Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny<TResult>(Task<TResult>[])

Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist.

System_CAPS_pubmethodSystem_CAPS_staticYield()

Erstellt eine Awaitable-Aufgabe, die asynchron an den aktuellen Kontext liefert, wenn erwartet.

NameBeschreibung
System_CAPS_pubinterfaceSystem_CAPS_privpropertyIAsyncResult.AsyncWaitHandle

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

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIAsyncResult.CompletedSynchronously

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

NameBeschreibung
System_CAPS_pubmethodDispatcherOperationWait()

Überladen. Wartet unbegrenzt für das zugrunde liegende DispatcherOperation abgeschlossen.(Definiert durch TaskExtensions.)

System_CAPS_pubmethodDispatcherOperationWait(TimeSpan)

Überladen. Wartet, bis die angegebene Zeitspanne für das zugrunde liegende DispatcherOperation abgeschlossen.(Definiert durch TaskExtensions.)

System_CAPS_pubmethodIsDispatcherOperationTask()

Gibt einen Wert, der angibt, ob dies Task zugeordnet ist eine DispatcherOperation.(Definiert durch TaskExtensions.)

System_CAPS_noteHinweis

Die .NET Framework-Quellcodes für diesen Typ finden Sie unter der Reference Source. Sie können den Quellcode online Durchsuchen, Referenz für die Offlineanzeige herunterladen und schrittweise durchlaufen (inklusive Patches und Updates) während des Debuggens; see instructions.

Die Task -Klasse stellt ein einzelnen Vorgang, der einen Wert und die in der Regel zurückgegeben wird asynchron ausgeführt wird. Task Objekte sind eine zentrale Komponente für aufgabenbasierte asynchrone Muster, die durch das .NET Framework 4 eingeführt wurden. Da die Arbeit von durchgeführt ein Task Objekt in der Regel führt asynchron auf einem Threadpoolthread statt synchron auf den Hauptanwendungsthread verwenden Sie können die Status -Eigenschaft, als auch die IsCanceled, IsCompleted, und IsFaulted Eigenschaften, um den Status eines Vorgangs zu ermitteln. In den meisten Fällen wird ein Lambda-Ausdruck verwendet, die Arbeit an, die die Aufgabe ausführen.

Für Vorgänge, die Werte zurückgeben, verwenden Sie die Task<TResult> Klasse.

In diesem Abschnitt

Erstellen und Ausführen einer Aufgabe
Trennung von Erstellung und Ausführung
Warten auf eine oder mehrere Aufgaben abgeschlossen
Aufgaben und Kultur
Debugger-Entwickler

Task Instanzen können auf verschiedene Arten erstellt werden. Die am häufigsten verwendete Ansatz, nämlich verfügbar, beginnend mit der .NET Framework 4.5, ist das Aufrufen der statischen Run Methode. Die Run Methode bietet eine einfache Möglichkeit, eine Aufgabe mit Standardwerten zu starten und ohne zusätzliche Parameter. Im folgenden Beispiel wird die Run(Action) Methode, um eine Aufgabe zu starten, die in einer Schleife und zeigt dann die Anzahl der Schleifeniterationen:

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Run( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
      t.Wait();
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations

Eine Alternative und die am häufigsten verwendete Methode zum Starten von einer Aufgabe in .NET Framework 4, ist die statische TaskFactory.StartNew Methode. Die Task.Factory-Eigenschaft gibt ein TaskFactory Objekt zurück. Überladungen der TaskFactory.StartNew-Methode erlauben ihnen Übergabeparameter an die Aufgabenerstellungsoptionen und den Aufgabenplaner zu übergeben. Das folgende Beispiel nutzt die TaskFactory.StartNew Methode, um eine Task zu starten. Es ist funktionell gleichwertig mit dem Code im vorherigen Beispiel.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Factory.StartNew( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
      t.Wait();
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations

Ausführlichere Beispiele finden Sie unter Task Parallelism (Task Parallel Library).

Die Task -Klasse stellt auch Konstruktoren, die die Aufgabe initialisieren, aber nicht planen, für die Ausführung bereit. Aus Gründen der Leistung ist die Task.Run oder TaskFactory.StartNew Methode der bevorzugte Mechanismus zum Erstellen und Planen von Berechnungsaufgaben, aber für Szenarien, wo Erstellung und Planung getrennt werden müssen, können Sie die Konstruktoren verwenden und rufen dann die Task.Start Methode auf, um die Aufgabe für die Ausführung zu einem späteren Zeitpunkt zu planen.

Da Aufgaben in der Regel asynchron auf einem Threadpool-Thread ausgeführt werden, wird der Thread, der die Aufgabe erstellt und startet, fortgesetzt, sobald die Aufgabe instanziiert wurde. In einigen Fällen, wenn der aufrufende Thread der Hauptanwendungsthread ist, wird die Anwendung möglicherweise beendet bevor die Aufgabe tatsächlich mit der Ausführung beginnt. In anderen Fällen erfordert möglicherweise die Logik Ihrer Anwendung, dass der aufrufende Thread die Ausführung nur fortsetzt, wenn eine oder mehrere Aufgaben abgeschlossen wurden. Sie können die Ausführung des aufrufenden Threads synchronisieren mit den asynchronen Aufgaben, die es startet durch Aufrufen einer Wait Methode, um zu warten, bis eine oder mehrere Aufgaben abgeschlossen sind.

Um zu warten, bis ein einzelner Task abgeschlossen ist, rufen Sie die Task.Wait Methode auf. Ein Aufruf der Wait Methode blockiert den aufrufenden Thread, bis die einzelne Klasseninstanz die Ausführung abgeschlossen hat.

Im folgenden Beispiel wird die parameterlose Wait() Methode bedingungslos warten, bis eine Aufgabe abgeschlossen ist. Die Aufgabe simuliert Arbeit durch Aufrufen der Thread.Sleep-Methode um den Threads für zwei Sekunden anzuhalten.

using System;   
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static Random rand = new Random();

    static void Main()
    {
        // Wait on a single task with no timeout specified.
        Task taskA = Task.Run( () => Thread.Sleep(2000));
        Console.WriteLine("taskA Status: {0}", taskA.Status);
        try {
          taskA.Wait();
          Console.WriteLine("taskA Status: {0}", taskA.Status);
       } 
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }   
    }    
}
// The example displays output like the following:
//     taskA Status: WaitingToRun
//     taskA Status: RanToCompletion

Sie können auch mit Bedingungen auf den Abschluss einer Aufgabe warten. Die Wait(Int32) und Wait(TimeSpan) Methoden blockieren den aufrufenden Thread, bis die Aufgabe abgeschlossen ist oder ein Timeoutintervall abläuft, je nachdem, was zuerst eintritt. Weil das folgende Beispiel eine Aufgabe startet, welche für 2 Sekunden angehalten wird, aber einen Timeoutwert von einer Sekunde definiert, blockiert der aufrufende Thread bis dieses Timeout abläuft und noch bevor die Aufgabe abgeschlossen wurde.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Wait on a single task with a timeout specified.
      Task taskA = Task.Run( () => Thread.Sleep(2000));
      try {
        taskA.Wait(1000);       // Wait for 1 second.
        bool completed = taskA.IsCompleted;
        Console.WriteLine("Task A completed: {0}, Status: {1}",
                         completed, taskA.Status);
        if (! completed)
           Console.WriteLine("Timed out before task A completed.");                 
       }
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }   
   }
}
// The example displays output like the following:
//     Task A completed: False, Status: Running
//     Timed out before task A completed.

Sie können auch ein Abbruchtoken angeben, durch Aufrufen der Wait(CancellationToken) und Wait(Int32, CancellationToken) Methoden. Wenn die IsCancellationRequested Eigenschaft des Tokens true ist, wird der Wartevorgang abgebrochen; wenn es true wird, während die Wait Methode beendet wird.

In einigen Fällen möchten Sie möglicherweise auf den Abschluss der ersten Aufgabe einer Reihe von sich in Ausführung befindlichen Aufgaben warten, aber Ihnen ist es egal, welche Aufgabe es ist. Zu diesem Zweck können Sie eine Überladung von Aufrufen der Task.WaitAll Methode aufrufen. Das folgende Beispiel erstellt drei Aufgaben, von denen jede für ein Intervall anhält, welches jeweils von einem Zufallszahlen-Generator bestimmt wird. Die WaitAny(Task[]) Methode wartet, bis die erste Aufgabe abgeschlossen ist. Das Beispiel zeigt anschließend Informationen über den Status aller drei Aufgaben.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var tasks = new Task[3];
      var rnd = new Random();
      for (int ctr = 0; ctr <= 2; ctr++)
         tasks[ctr] = Task.Run( () => Thread.Sleep(rnd.Next(500, 3000)));

      try {
         int index = Task.WaitAny(tasks);
         Console.WriteLine("Task #{0} completed first.\n", tasks[index].Id);
         Console.WriteLine("Status of all tasks:");
         foreach (var t in tasks)
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
      }
      catch (AggregateException) {
         Console.WriteLine("An exception occurred.");
      }
   }
}
// The example displays output like the following:
//     Task #1 completed first.
//     
//     Status of all tasks:
//        Task #3: Running
//        Task #1: RanToCompletion
//        Task #4: Running

Sie können auch auf den Abschluss aller Tasks einer Reihe warten durch Aufrufen der WaitAll Methode. Das folgende Beispiel erstellt zehn Tasks, wartet bis alle zehn abgeschlossen sind und zeigt anschließend deren Status an.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Wait for all tasks to complete.
      Task[] tasks = new Task[10];
      for (int i = 0; i < 10; i++)
      {
          tasks[i] = Task.Run(() => Thread.Sleep(2000));
      }
      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
         Console.WriteLine("One or more exceptions occurred: ");
         foreach (var ex in ae.Flatten().InnerExceptions)
            Console.WriteLine("   {0}", ex.Message);
      }   

      Console.WriteLine("Status of completed tasks:");
      foreach (var t in tasks)
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
   }
}
// The example displays the following output:
//     Status of completed tasks:
//        Task #2: RanToCompletion
//        Task #1: RanToCompletion
//        Task #3: RanToCompletion
//        Task #4: RanToCompletion
//        Task #6: RanToCompletion
//        Task #5: RanToCompletion
//        Task #7: RanToCompletion
//        Task #8: RanToCompletion
//        Task #9: RanToCompletion
//        Task #10: RanToCompletion

Beachten Sie, dass wenn Sie auf den Abschluss einer oder mehrere Tasks warten, alle in den ausgeführten Tasks ausgelöste Ausnahmen an den Thread übermittelt werden, der die Wait Methode aufruft, wie im folgenden Beispiel gezeigt. Es werden 12 Tasks gestartet, von denen drei normal abgeschlossen werden und drei lösen eine Ausnahme aus. Von den verbleibenden sechs Tasks werden drei vor dem Start abgebrochen und drei werden abgebrochen, während sie ausgeführt werden. Ausnahmen werden im WaitAll Methodenaufruf ausgelöst und in einem try/catch Block behandelt.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Create a cancellation token and cancel it.
      var source1 = new CancellationTokenSource();
      var token1 = source1.Token;
      source1.Cancel();
      // Create a cancellation token for later cancellation.
      var source2 = new CancellationTokenSource();
      var token2 = source2.Token;

      // Create a series of tasks that will complete, be cancelled, 
      // timeout, or throw an exception.
      Task[] tasks = new Task[12];
      for (int i = 0; i < 12; i++)
      {
          switch (i % 4) 
          {
             // Task should run to completion.
             case 0:
                tasks[i] = Task.Run(() => Thread.Sleep(2000));
                break;
             // Task should be set to canceled state.
             case 1:   
                tasks[i] = Task.Run( () => Thread.Sleep(2000),
                         token1);
                break;         
             case 2:
                // Task should throw an exception.
                tasks[i] = Task.Run( () => { throw new NotSupportedException(); } );
                break;
             case 3:
                // Task should examine cancellation token.
                tasks[i] = Task.Run( () => { Thread.Sleep(2000); 
                                             if (token2.IsCancellationRequested)
                                                token2.ThrowIfCancellationRequested();
                                             Thread.Sleep(500); }, token2);   
                break;
          }
      }
      Thread.Sleep(250);
      source2.Cancel();

      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
          Console.WriteLine("One or more exceptions occurred:");
          foreach (var ex in ae.InnerExceptions)
             Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message);
       }   

      Console.WriteLine("\nStatus of tasks:");
      foreach (var t in tasks) {
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
         if (t.Exception != null) {
            foreach (var ex in t.Exception.InnerExceptions)
               Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                 ex.Message);
         }
      }
   }
}
// The example displays output like the following:
//   One or more exceptions occurred:
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//   
//   Status of tasks:
//      Task #13: RanToCompletion
//      Task #1: Canceled
//      Task #3: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #8: Canceled
//      Task #14: RanToCompletion
//      Task #4: Canceled
//      Task #6: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #7: Canceled
//      Task #15: RanToCompletion
//      Task #9: Canceled
//      Task #11: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #12: Canceled

Weitere Informationen zur Ausnahmebehandlung in aufgabenbasierten asynchronen Vorgängen finden Sie unter Ausnahmebehandlung (Task Parallel Library).

Beginnend mit Desktopanwendungen, die für das .NET Framework 4.6 erstellt werden, wird die Kultur des Threads, der eine Task erstellt und aufruft, Teil des Kontexts des Threads. Unabhängig von der aktuellen Kultur des Threads, auf denen der Task ausgeführt wird, ist die aktuelle Kultur der Aufgabe die Kultur des aufrufenden Threads. Für Anwendungen, die für Versionen von .NET Framework vor der .NET Framework 4.6 erstellt werden, ist die Kultur der Aufgaben die Kultur des Threads, auf denen der Task ausgeführt wird. Weitere Informationen finden Sie im Abschnitt "Kultur und aufgabenbasierte asynchrone Vorgänge" im CultureInfo Thema.

System_CAPS_noteHinweis

Store-Apps nutzen die Einstellungen der Windows-Runtime und erhalten die Standardkultur.

Für Entwickler, die benutzerdefinierte Debugger implementieren, sind mehrere interne und private Member einer Aufgabe möglicherweise nützlich (diese können sich von Version zu Version ändern). Die m_taskId -Feld dient als Sicherungsspeicher für die Id -Eigenschaft, jedoch den Zugriff auf dieses Feld direkt von einem Debugger effizienter Zugriff auf den gleichen Wert über die Eigenschaft Getter-Methode werden kann (die s_taskIdCounter Zähler wird verwendet, um die nächste verfügbare ID für eine Aufgabe abzurufen). Auf ähnliche Weise die m_stateFlags Feld speichert Informationen zur aktuellen Lebenszyklusphase der Aufgabe, Informationen, die auch über die Status Eigenschaft. Die m_action Feld speichert einen Verweis auf den Delegaten der Aufgabe, und die m_stateObject Feld speichert den Zustand der asynchronen vom Entwickler an die Aufgabe übergeben. Schließlich für den Debugger, die Stapelrahmen analysieren die InternalWait Methode dient als potenziellen Marker für Wenn eine Aufgabe einen Wartevorgang eingibt.

Das folgende Beispiel erstellt und vier Aufgaben ausführt. Führen Sie drei Aufgaben ein Action<T> Delegaten mit dem Namen action, die akzeptiert ein Argument vom Typ Object. Eine vierte Aufgabe führt einen Lambda-Ausdruck (ein Action Delegieren), Inline definiert im Aufruf der Methode zum Erstellen von Tasks. Jede Aufgabe wird instanziiert und auf andere Weise ausführen:

  • Aufgabe t1 instanziiert, indem ein Task-Klassenkonstruktor aufgerufen, jedoch wird durch den Aufruf gestartet seine Start() Methode nur nach Aufgabe t2 wurde gestartet.

  • Aufgabe t2 instanziiert und Schritte in einem einzelnen Methodenaufruf durch Aufrufen der TaskFactory.StartNew(Action<Object>, Object) Methode.

  • Aufgabe t3 instanziiert und Schritte in einem einzelnen Methodenaufruf durch Aufrufen der Run(Action) Methode.

  • Aufgabe t4 wird synchron im Hauptthread ausgeführt, durch Aufrufen der RunSynchronously() Methode.

Da Aufgabe t4 synchron, führt er auf den Hauptanwendungsthread ausgeführt wird. Die verbleibenden Vorgänge asynchron in der Regel auf einen oder mehrere Threads im Threadpool.

using System;
using System.Threading;
using System.Threading.Tasks;

class Example
{
    static void Main()
    {
        Action<object> action = (object obj) =>
                                {
                                   Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                   Task.CurrentId, obj,
                                   Thread.CurrentThread.ManagedThreadId);
                                };

        // Create a task but do not start it.
        Task t1 = new Task(action, "alpha");

        // Construct a started task
        Task t2 = Task.Factory.StartNew(action, "beta");
        // Block the main thread to demonstate that t2 is executing
        t2.Wait();

        // Launch t1 
        t1.Start();
        Console.WriteLine("t1 has been launched. (Main Thread={0})",
                          Thread.CurrentThread.ManagedThreadId);
        // Wait for the task to finish.
        t1.Wait();

        // Construct a started task using Task.Run.
        String taskData = "delta";
        Task t3 = Task.Run( () => {Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                                     Task.CurrentId, taskData,
                                                      Thread.CurrentThread.ManagedThreadId);
                                   });
        // Wait for the task to finish.
        t3.Wait();

        // Construct an unstarted task
        Task t4 = new Task(action, "gamma");
        // Run it synchronously
        t4.RunSynchronously();
        // Although the task was run synchronously, it is a good practice
        // to wait for it in the event exceptions were thrown by the task.
        t4.Wait();
    }
}
// The example displays output like the following:
//       Task=1, obj=beta, Thread=3
//       t1 has been launched. (Main Thread=1)
//       Task=2, obj=alpha, Thread=4
//       Task=3, obj=delta, Thread=3
//       Task=4, obj=gamma, Thread=1

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 4.0
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 5.0
Windows Phone Silverlight
Verfügbar seit 8.0
Windows Phone
Verfügbar seit 8.1

Alle Mitglieder von Task, mit Ausnahme von Dispose, sind threadsicher und können von mehreren Threads gleichzeitig verwendet werden.

Zurück zum Anfang
Anzeigen:
© 2018 Microsoft