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

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, finden Sie unter der Reference Source.

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


[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 von der aufgabenbasierte asynchrone Muster in .NET Framework 4 eingeführt. 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. Der Überladungen der TaskFactory.StartNew -Methode können Sie Parameter zur Übergabe an die Aufgabenerstellungsoptionen und einen Aufgabenplaner angeben. Im folgenden Beispiel wird die TaskFactory.StartNew Methode, um eine Aufgabe 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 sie für die Ausführung, bereit. Aus Gründen der Leistung der Task.Run oder TaskFactory.StartNew Methode ist der bevorzugte Mechanismus zum Erstellen und Planen von Berechnungsaufgaben, aber für Szenarien, wo Erstellung und Planung getrennt werden müssen, können Sie mithilfe der Konstruktoren und rufen Sie dann die Task.Start Methode, 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 die Ausführung des Threads, die erstellt und startet den Vorgang, sobald die Aufgabe instanziiert wurde fortgesetzt. In einigen Fällen, wenn der aufrufende Thread den Hauptanwendungsthread ist die app möglicherweise beendet vor die Aufgabe tatsächlich mit der Ausführung beginnt. In anderen Fällen möglicherweise die Logik Ihrer Anwendung, dass der aufrufende Thread die Ausführung fortsetzen, nur, wenn eine oder mehrere Aufgaben abgeschlossen werden. Sie können die Ausführung des aufrufenden Threads synchronisieren und die asynchrone Aufgaben es startet durch Aufrufen einer Wait Methode zu warten, bis eine oder mehrere Aufgaben abgeschlossen.

Warten Sie einen einzelnen Task abgeschlossen, rufen Sie die Task.Wait Methode. Ein Aufruf der Wait Methode blockiert den aufrufenden Thread, bis die einzelnen Klasseninstanz Ausführung abgeschlossen ist.

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 für zwei Sekunden in den Ruhezustand.

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 bedingte Abschluss einer Aufgabe warten. Die Wait(Int32) und Wait(TimeSpan) Methoden blockiert den aufrufenden Thread, bis die Aufgabe abgeschlossen ist oder ein Timeoutintervall abläuft, je nachdem, was zuerst eintritt. Da im folgenden Beispiel wird eine Aufgabe, die ruht für 2 Sekunden, aber definiert einen Timeoutwert von einer Sekunde, der aufrufende Thread blockiert startet, bis das Timeout abläuft, und bevor wurde die Aufgabe abgeschlossen.

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 des Tokens IsCancellationRequested Eigenschaft ist true, der Wartevorgang abgebrochen wird, und wenn es bei true wird die Wait Methode beendet.

In einigen Fällen möchten Sie möglicherweise warten, für die erste einer Reihe von Aufgaben ausführen, abgeschlossen, aber sorgfältig, dem diese Aufgabe ist. Zu diesem Zweck können Sie eine Überladung von Aufrufen der Task.WaitAll Methode. Das folgende Beispiel erstellt drei Aufgaben, von denen jede ruht für ein Intervall bestimmen, indem Sie einen Zufallszahlen-Generator. Die WaitAny(Task[]) Methode wartet, bis die erste Aufgabe abgeschlossen. 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 warten, für alle einer Reihe von Aufgaben abgeschlossen durch Aufrufen der WaitAll Methode. Im folgenden Beispiel werden zehn Aufgaben erstellt, wartet, bis alle zehn abgeschlossen ist, und anschließend deren Status angezeigt.

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 eine oder mehrere Aufgaben abgeschlossen warten, ausgeführten Aufgaben ausgelöste Ausnahmen für den Thread übermittelt werden, die Aufrufe der Wait Methode, wie im folgenden Beispiel gezeigt. Er startet 12 Aufgaben, von denen drei normal abgeschlossen und drei welche lösen eine Ausnahme. Der verbleibenden sechs Aufgaben drei werden vor dem Start abgebrochen, und drei werden abgebrochen, während sie ausgeführt. Ausnahmen werden ausgelöst, der WaitAll Methodenaufruf und werden anhand einer try/catch Block.

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 aufgabenbasierte asynchrone Vorgänge finden Sie unter Ausnahmebehandlung (Task Parallel Library).

Beginnend mit desktop-apps, die auf die .NET Framework 4.6, die Kultur des Threads, der erstellt, und ruft eine Aufgabe wird der Kontext des Threads. Unabhängig von der aktuellen Kultur des Threads, auf denen der Task ausgeführt wird, ist die aktuelle Kultur der Aufgabe, also die Kultur des aufrufenden Threads. Für apps, die Versionen von .NET Framework vor der .NET Framework 4.6, die Kultur des Vorgangs wird die Kultur des Threads, auf denen der Task ausgeführt wird. Weitere Informationen finden Sie im Abschnitt "Kultur und aufgabenbasierte asynchrone Vorgänge" in der CultureInfo Thema.

System_CAPS_noteHinweis

Store-apps führen Sie die Windows-Runtime festlegen und Abrufen der Standardkultur.

Für Entwickler, die benutzerdefinierte Debugger implementieren möglicherweise mehrere interne und private Member der Aufgabe 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: