TaskStatus TaskStatus TaskStatus TaskStatus Enum

Definition

Stellt die aktuelle Phase im Lebenszyklus eines Task dar.Represents the current stage in the lifecycle of a Task.

public enum class TaskStatus
public enum TaskStatus
type TaskStatus = 
Public Enum TaskStatus
Vererbung

Felder

Canceled Canceled Canceled Canceled 6

Die Aufgabe hat den Abbruch durch Auslösen einer OperationCanceledException mit einem eigenen CancellationToken bestätigt, während das Token im Zustand "signalisiert" war, oder das CancellationToken der Aufgabe wurde bereits vor dem Start der Aufgabenausführung signalisiert.The task acknowledged cancellation by throwing an OperationCanceledException with its own CancellationToken while the token was in signaled state, or the task's CancellationToken was already signaled before the task started executing. Weitere Informationen finden Sie unter Aufgabenabbruch.For more information, see Task Cancellation.

Created Created Created Created 0

Die Aufgabe wurde initialisiert, aber noch nicht geplant.The task has been initialized but has not yet been scheduled.

Faulted Faulted Faulted Faulted 7

Die Aufgabe wurde aufgrund eines Ausnahmefehlers abgeschlossen.The task completed due to an unhandled exception.

RanToCompletion RanToCompletion RanToCompletion RanToCompletion 5

Die Ausführung der Aufgabe wurde erfolgreich abgeschlossen.The task completed execution successfully.

Running Running Running Running 3

Die Aufgabe wird ausgeführt, wurde aber noch nicht abgeschlossen.The task is running but has not yet completed.

WaitingForActivation WaitingForActivation WaitingForActivation WaitingForActivation 1

Die Aufgabe wartet auf ihre Aktivierung und interne Planung durch die .NET Framework-Infrastruktur.The task is waiting to be activated and scheduled internally by the .NET Framework infrastructure.

WaitingForChildrenToComplete WaitingForChildrenToComplete WaitingForChildrenToComplete WaitingForChildrenToComplete 4

Die Aufgabe hat die Ausführung beendet und wartet implizit auf den Abschluss angefügter untergeordneter Aufgaben.The task has finished executing and is implicitly waiting for attached child tasks to complete.

WaitingToRun WaitingToRun WaitingToRun WaitingToRun 2

Die Aufgabe wurde zur Ausführung geplant, aber noch nicht gestartet.The task has been scheduled for execution but has not yet begun executing.

Beispiele

Das folgende Beispiel erstellt 20 Aufgaben, die Schleife durchlaufen werden, bis auf einen Wert von 2 Millionen erhöht wird.The following example creates 20 tasks that will loop until a counter is incremented to a value of 2 million. Wenn die ersten 10 Aufgaben 2 Millionen erreichen, wird das Abbruchtoken abgebrochen wird, und alle Aufgaben, deren Leistungsindikatoren 2 Millionen nicht erreicht haben, werden abgebrochen.When the first 10 tasks reach 2 million, the cancellation token is cancelled, and any tasks whose counters have not reached 2 million are cancelled. Im Beispiel wird dann untersucht die Task.Status Eigenschaft der einzelnen Aufgaben an, ob der Task erfolgreich abgeschlossen wurde, oder wurde abgebrochen.The example then examines the Task.Status property of each task to indicate whether the task has completed successfully or been cancelled. Für diejenigen, die abgeschlossen wurden, wird die von der Aufgabe zurückgegebenen Werts angezeigt.For those that have completed, it displays the value returned by the task.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var tasks = new List<Task<int>>();
      var source = new CancellationTokenSource();
      var token = source.Token;
      int completedIterations = 0;

      for (int n = 0; n <= 19; n++)
         tasks.Add(Task.Run( () => { int iterations = 0;
                                     for (int ctr = 1; ctr <= 2000000; ctr++) {
                                         token.ThrowIfCancellationRequested();
                                         iterations++;
                                     }
                                     Interlocked.Increment(ref completedIterations);
                                     if (completedIterations >= 10)
                                        source.Cancel();
                                     return iterations; }, token));

      Console.WriteLine("Waiting for the first 10 tasks to complete...\n");
      try  {
         Task.WaitAll(tasks.ToArray());
      }
      catch (AggregateException) {
         Console.WriteLine("Status of tasks:\n");
         Console.WriteLine("{0,10} {1,20} {2,14:N0}", "Task Id",
                           "Status", "Iterations");
         foreach (var t in tasks)
            Console.WriteLine("{0,10} {1,20} {2,14}",
                              t.Id, t.Status,
                              t.Status != TaskStatus.Canceled ? t.Result.ToString("N0") : "n/a");
      }
   }
}
// The example displays output like the following:
//    Waiting for the first 10 tasks to complete...
//    Status of tasks:
//
//       Task Id               Status     Iterations
//             1      RanToCompletion      2,000,000
//             2      RanToCompletion      2,000,000
//             3      RanToCompletion      2,000,000
//             4      RanToCompletion      2,000,000
//             5      RanToCompletion      2,000,000
//             6      RanToCompletion      2,000,000
//             7      RanToCompletion      2,000,000
//             8      RanToCompletion      2,000,000
//             9      RanToCompletion      2,000,000
//            10             Canceled            n/a
//            11             Canceled            n/a
//            12             Canceled            n/a
//            13             Canceled            n/a
//            14             Canceled            n/a
//            15             Canceled            n/a
//            16      RanToCompletion      2,000,000
//            17             Canceled            n/a
//            18             Canceled            n/a
//            19             Canceled            n/a
//            20             Canceled            n/a
Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

Module Example

   Public Sub Main()
      Dim tasks As New List(Of Task(Of Integer))()
      Dim source As New CancellationTokenSource
      Dim token As CancellationToken = source.Token
      Dim completedIterations As Integer = 0
      
      For n As Integer = 0 To 19
         tasks.Add(Task.Run( Function()
                                Dim iterations As Integer= 0
                                For ctr As Long = 1 To 2000000
                                   token.ThrowIfCancellationRequested()
                                   iterations += 1
                                Next
                                Interlocked.Increment(completedIterations)
                                If completedIterations >= 10 Then source.Cancel()
                                Return iterations
                             End Function, token))
      Next

      Console.WriteLine("Waiting for the first 10 tasks to complete... ")
      Try
         Task.WaitAll(tasks.ToArray())
      Catch e As AggregateException
         Console.WriteLine("Status of tasks:")
         Console.WriteLine()
         Console.WriteLine("{0,10} {1,20} {2,14}", "Task Id",
                           "Status", "Iterations")
         For Each t In tasks
            Console.WriteLine("{0,10} {1,20} {2,14}",
                              t.Id, t.Status,
                              If(t.Status <> TaskStatus.Canceled,
                                 t.Result.ToString("N0"), "n/a"))
         Next
      End Try
   End Sub
End Module
' The example displays output like the following:
'    Waiting for the first 10 tasks to complete...
'    Status of tasks:
'
'       Task Id               Status     Iterations
'             1      RanToCompletion      2,000,000
'             2      RanToCompletion      2,000,000
'             3      RanToCompletion      2,000,000
'             4      RanToCompletion      2,000,000
'             5      RanToCompletion      2,000,000
'             6      RanToCompletion      2,000,000
'             7      RanToCompletion      2,000,000
'             8      RanToCompletion      2,000,000
'             9      RanToCompletion      2,000,000
'            10             Canceled            n/a
'            11             Canceled            n/a
'            12             Canceled            n/a
'            13             Canceled            n/a
'            14             Canceled            n/a
'            15             Canceled            n/a
'            16      RanToCompletion      2,000,000
'            17             Canceled            n/a
'            18             Canceled            n/a
'            19             Canceled            n/a
'            20             Canceled            n/a

Hinweise

Der Task.Status Eigenschaft gibt ein Mitglied der TaskStatus Enumeration, um den aktuellen Status des Vorgangs anzugeben.The Task.Status property returns a member of the TaskStatus enumeration to indicate the task's current status.

Gilt für:

Siehe auch