TaskStatus Wyliczenie

Definicja

Przedstawia bieżący etap cyklu życia Task .Represents the current stage in the lifecycle of a Task.

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

Pola

Canceled 6

Zadanie zostało potwierdzone przez wyrzucanie elementu OperationCanceledException z własnym CancellationToken, gdy token był w stanie zasygnalizować, lub CancellationToken zadania zostało już zasygnalizowane przed rozpoczęciem wykonywania zadania.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. Aby uzyskać więcej informacji, zobacz Anulowanie zadania.For more information, see Task Cancellation.

Created 0

Zadanie zostało zainicjowane, ale jeszcze nie zaplanowano.The task has been initialized but has not yet been scheduled.

Faulted 7

Zadanie zostało ukończone z powodu nieobsługiwanego wyjątku.The task completed due to an unhandled exception.

RanToCompletion 5

Zadanie zostało ukończone pomyślnie.The task completed execution successfully.

Running 3

Zadanie jest uruchomione, ale nie zostało jeszcze ukończone.The task is running but has not yet completed.

WaitingForActivation 1

Zadanie oczekuje na aktywowanie i zaplanowanie wewnętrznie przez infrastrukturę .NET.The task is waiting to be activated and scheduled internally by the .NET infrastructure.

WaitingForChildrenToComplete 4

Zadanie zostało zakończone i jest niejawnie oczekiwane na ukończenie dołączonych zadań podrzędnych.The task has finished executing and is implicitly waiting for attached child tasks to complete.

WaitingToRun 2

Zadanie zostało zaplanowane do wykonania, ale nie zostało jeszcze rozpoczęte.The task has been scheduled for execution but has not yet begun executing.

Przykłady

Poniższy przykład tworzy 20 zadań, które będą się powtarzać, dopóki licznik zostanie zwiększony do wartości 2 000 000.The following example creates 20 tasks that will loop until a counter is incremented to a value of 2 million. Gdy pierwsze 10 zadań osiągnie wartość 2 000 000, token anulowania zostanie anulowany, a wszystkie zadania, których liczniki nie osiągnęły 2 000 000, są anulowane.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. Przykład następnie analizuje Task.Status Właściwość każdego zadania, aby wskazać, czy zadanie zostało ukończone pomyślnie czy zostało anulowane.The example then examines the Task.Status property of each task to indicate whether the task has completed successfully or been cancelled. Dla tych, które ukończyły, wyświetla wartość zwracaną przez zadanie.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

Uwagi

Task.StatusWłaściwość zwraca element członkowski TaskStatus wyliczenia, aby wskazać bieżący stan zadania.The Task.Status property returns a member of the TaskStatus enumeration to indicate the task's current status.

Dotyczy

Zobacz też