Task Klasa

Definicja

Reprezentuje operację asynchroniczną.

public ref class Task : IAsyncResult
public ref class Task : IAsyncResult, IDisposable
public class Task : IAsyncResult
public class Task : IAsyncResult, IDisposable
type Task = class
    interface IAsyncResult
type Task = class
    interface IAsyncResult
    interface IDisposable
Public Class Task
Implements IAsyncResult
Public Class Task
Implements IAsyncResult, IDisposable
Dziedziczenie
Task
Pochodne
Implementuje

Uwagi

Klasa Task reprezentuje pojedynczą operację, która nie zwraca wartości i zwykle wykonuje asynchronicznie. Taskobiekty są jednym z głównych składników asynchronicznego wzorca opartego na zadaniach po raz pierwszy wprowadzonego w .NET Framework 4. Ponieważ praca wykonywana przez Task obiekt zwykle jest wykonywana asynchronicznie w wątku puli wątków, a nie synchronicznie w głównym wątku aplikacji, można użyć Status właściwości, a także IsCanceledwłaściwości , IsCompletedi IsFaulted w celu określenia stanu zadania. Najczęściej wyrażenie lambda służy do określania pracy, którą ma wykonać zadanie.

W przypadku operacji, które zwracają wartości, należy użyć Task<TResult> klasy .

W tej sekcji:

Przykłady wystąpień zadań
Tworzenie i wykonywanie zadania
Rozdzielenie tworzenia i wykonywania zadań
Oczekiwanie na ukończenie co najmniej jednego zadania
Zadania i kultura
Dla deweloperów debugera

Wystąpienie zadania

Poniższy przykład tworzy i wykonuje cztery zadania. Trzy zadania wykonują Action<T> delegata o nazwie action, który akceptuje argument typu Object. Czwarte zadanie wykonuje wyrażenie lambda ( Action delegat), które jest zdefiniowane w tekście w wywołaniu metody tworzenia zadania. Każde zadanie jest tworzone i uruchamiane w inny sposób:

  • Zadanie t1 jest tworzone przez wywołanie konstruktora klasy Task, ale jest uruchamiane przez wywołanie metody Start() dopiero po rozpoczęciu zadania t2 .

  • Zadanie t2 jest tworzone i uruchamiane w jednym wywołaniu metody przez wywołanie TaskFactory.StartNew(Action<Object>, Object) metody .

  • Zadanie t3 jest tworzone i uruchamiane w jednym wywołaniu metody przez wywołanie Run(Action) metody .

  • Zadanie t4 jest wykonywane synchronicznie w wątku głównym przez wywołanie RunSynchronously() metody .

Ponieważ zadanie t4 jest wykonywane synchronicznie, jest wykonywane w głównym wątku aplikacji. Pozostałe zadania są wykonywane asynchronicznie zwykle w co najmniej jednym wątku puli wątków.

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 demonstrate 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
Imports System.Threading
Imports System.Threading.Tasks

Module Example
    Public Sub Main()
        Dim action As Action(Of Object) = 
              Sub(obj As Object)
                 Console.WriteLine("Task={0}, obj={1}, Thread={2}", 
                 Task.CurrentId, obj,
                 Thread.CurrentThread.ManagedThreadId)
              End Sub

        ' Construct an unstarted task
        Dim t1 As New Task(action, "alpha")

        ' Construct a started task
        Dim t2 As Task = Task.Factory.StartNew(action, "beta")
        ' Block the main thread to demonstrate 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.
        Dim taskData As String = "delta"
        Dim t3 As Task = Task.Run(Sub()
                                     Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                     Task.CurrentId, taskData,
                                     Thread.CurrentThread.ManagedThreadId)
                                  End Sub)
        ' Wait for the task to finish.
        t3.Wait()
        
        ' Construct an unstarted task
        Dim t4 As 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()
    End Sub
End Module
' 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=3
'       Task=3, obj=delta, Thread=3
'       Task=4, obj=gamma, Thread=1

Tworzenie i wykonywanie zadania

Task wystąpienia mogą być tworzone na różne sposoby. Najbardziej typowym podejściem, które jest dostępne począwszy od .NET Framework 4.5, jest wywołanie metody statycznejRun. Metoda Run zapewnia prosty sposób uruchamiania zadania przy użyciu wartości domyślnych i bez konieczności stosowania dodatkowych parametrów. W poniższym przykładzie Run(Action) użyto metody , aby uruchomić pętlę zadania, a następnie wyświetlić liczbę iteracji pętli:

using System;
using System.Threading.Tasks;

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

Module Example
   Public Sub Main()
      Dim t As Task = Task.Run(Sub()
                                  ' Just loop.
                                  Dim ctr As Integer = 0
                                  For ctr = 0 to 1000000
                                  Next
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr)
                               End Sub)
      t.Wait()
   End Sub
End Module
' The example displays the following output:
'       Finished 1000001 loop iterations

Alternatywą i najczęstszą metodą uruchamiania zadania w .NET Framework 4 jest metoda statycznaTaskFactory.StartNew. Właściwość Task.Factory zwraca TaskFactory obiekt. Przeciążenia TaskFactory.StartNew metody umożliwiają określenie parametrów, które mają zostać przekazane do opcji tworzenia zadań i harmonogramu zadań. W poniższym przykładzie użyto TaskFactory.StartNew metody , aby uruchomić zadanie. Jest ona funkcjonalnie równoważna kodowi w poprzednim przykładzie.

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
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Factory.StartNew(Sub()
                                  ' Just loop.
                                  Dim ctr As Integer = 0
                                  For ctr = 0 to 1000000
                                  Next
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr)
                               End Sub)
      t.Wait()
   End Sub
End Module
' The example displays the following output:
'       Finished 1000001 loop iterations

Aby uzyskać więcej kompletnych przykładów, zobacz Programowanie asynchroniczne oparte na zadaniach.

Rozdzielenie tworzenia i wykonywania zadań

Klasa Task udostępnia również konstruktory, które inicjują zadanie, ale nie są zaplanowane do wykonania. Ze względów Task.Run wydajności metoda or TaskFactory.StartNew jest preferowanym mechanizmem tworzenia i planowania zadań obliczeniowych, ale w scenariuszach, w których tworzenie i planowanie musi być oddzielone, można użyć konstruktorów, a następnie wywołać Task.Start metodę, aby zaplanować zadanie do wykonania w późniejszym czasie.

Oczekiwanie na ukończenie co najmniej jednego zadania

Ponieważ zadania są zwykle uruchamiane asynchronicznie w wątku puli wątków, wątek, który tworzy i uruchamia zadanie, kontynuuje wykonywanie zaraz po utworzeniu wystąpienia zadania. W niektórych przypadkach, gdy wątek wywołujący jest głównym wątkiem aplikacji, aplikacja może zakończyć się przed rozpoczęciem wykonywania zadania. W innych przypadkach logika aplikacji może wymagać kontynuowania wykonywania wątku wywołującego tylko wtedy, gdy wykonano co najmniej jedno zadanie. Można zsynchronizować wykonywanie wątku wywołującego i zadań asynchronicznych uruchamianych przez wywołanie Wait metody, aby poczekać na ukończenie co najmniej jednego zadania.

Aby poczekać na ukończenie jednego zadania, możesz wywołać jego Task.Wait metodę. Wywołanie metody Wait blokuje wątek wywołujący do momentu ukończenia wykonywania wystąpienia pojedynczej klasy.

Poniższy przykład wywołuje metodę bez Wait() parametrów, aby oczekiwać bezwarunkowo do ukończenia zadania. Zadanie symuluje pracę przez wywołanie metody uśpienia Thread.Sleep przez dwie sekundy.

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
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait on a single task with no timeout specified.
      Dim taskA = Task.Run( Sub() Thread.Sleep(2000))
      Console.WriteLine("taskA Status: {0}", taskA.Status)
      Try
        taskA.Wait()
        Console.WriteLine("taskA Status: {0}", taskA.Status)
      Catch e As AggregateException
         Console.WriteLine("Exception in taskA.")
      End Try
   End Sub
End Module
' The example displays output like the following:
'     taskA Status: WaitingToRun
'     taskA Status: RanToCompletion

Możesz również warunkowo poczekać na ukończenie zadania. Metody Wait(Int32) i Wait(TimeSpan) blokują wątek wywołujący do momentu zakończenia zadania lub upływu interwału przekroczenia limitu czasu, w zależności od tego, co nastąpi wcześniej. Ponieważ w poniższym przykładzie uruchamia się zadanie, które śpi przez dwie sekundy, ale definiuje jednorazową wartość limitu czasu, bloki wątku wywołującego do momentu wygaśnięcia limitu czasu i przed ukończeniem wykonywania zadania.

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.
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait on a single task with a timeout specified.
      Dim taskA As Task = Task.Run( Sub() Thread.Sleep(2000))
      Try
         taskA.Wait(1000)        ' Wait for 1 second.
         Dim completed As Boolean = taskA.IsCompleted
         Console.WriteLine("Task.Completed: {0}, Status: {1}",
                           completed, taskA.Status)
         If Not completed Then 
            Console.WriteLine("Timed out before task A completed.")
         End If                     
      Catch e As AggregateException
         Console.WriteLine("Exception in taskA.")
      End Try
   End Sub
End Module
' The example displays the following output:
'     Task A completed: False, Status: Running
'     Timed out before task A completed.

Token anulowania można również podać, wywołując Wait(CancellationToken) metody i Wait(Int32, CancellationToken) . Jeśli właściwość tokenu IsCancellationRequested jest true lub staje się Wait true podczas wykonywania metody, metoda zgłasza OperationCanceledExceptionbłąd .

W niektórych przypadkach możesz poczekać na ukończenie pierwszej serii zadań, ale nie obchodzi tego, które zadanie jest. W tym celu można wywołać jedno z przeciążeń Task.WaitAny metody . Poniższy przykład tworzy trzy zadania, z których każdy śpi dla interwału określonego przez generator liczb losowych. Metoda WaitAny(Task[]) czeka na ukończenie pierwszego zadania. W przykładzie zostaną wyświetlone informacje o stanie wszystkich trzech zadań.

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
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks(2) As Task
      Dim rnd As New Random()
      For ctr As Integer = 0 To 2
         tasks(ctr) = Task.Run( Sub()  Thread.Sleep(rnd.Next(500, 3000)))
      Next
      
      Try 
         Dim index As Integer= Task.WaitAny(tasks)
         Console.WriteLine("Task #{0} completed first.", tasks(index).Id)
         Console.WriteLine()
         Console.WriteLine("Status of all tasks:")
         For Each t in tasks
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
         Next   
      Catch e As AggregateException
         Console.WriteLine("An exception occurred.")
      End Try
   End Sub
End Module
' The example displays output like the following:
'     Task #1 completed first.
'     
'     Status of all tasks:
'        Task #3: Running
'        Task #1: RanToCompletion
'        Task #4: Running

Możesz również poczekać na ukończenie wszystkich serii zadań, wywołując metodę WaitAll . Poniższy przykład tworzy dziesięć zadań, czeka na ukończenie wszystkich dziesięciu, a następnie wyświetla ich stan.

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
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait for all tasks to complete.
      Dim tasks(9) As Task
      For i As Integer = 0 To 9
          tasks(i) = Task.Run( Sub() Thread.Sleep(2000) )
      Next
      Try 
         Task.WaitAll(tasks)
      Catch ae As AggregateException
         Console.WriteLine("One or more exceptions occurred: ")
         For Each ex In ae.Flatten().InnerExceptions
            Console.WriteLine("   {0}", ex.Message)
         Next
      End Try   

      Console.WriteLine("Status of completed tasks:")
      For Each t in tasks
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
      Next   
   End Sub
End Module
' 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

Należy pamiętać, że w przypadku oczekiwania na ukończenie co najmniej jednego zadania wszelkie wyjątki zgłoszone w uruchomionych zadaniach są propagowane w wątku wywołującym metodę Wait , jak pokazano w poniższym przykładzie. Uruchamia 12 zadań, z których trzy są wykonywane normalnie i trzy z nich zgłaszają wyjątek. Z pozostałych sześciu zadań trzy są anulowane przed rozpoczęciem, a trzy są anulowane podczas ich wykonywania. Wyjątki są zgłaszane w wywołaniu WaitAll metody i są obsługiwane przez try/catch blok.

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
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Create a cancellation token and cancel it.
      Dim source1 As New CancellationTokenSource()
      Dim token1 As CancellationToken = source1.Token
      source1.Cancel()
      ' Create a cancellation token for later cancellation.
      Dim source2 As New CancellationTokenSource()
      Dim token2 As CancellationToken = source2.Token
       
      ' Create a series of tasks that will complete, be cancelled, 
      ' timeout, or throw an exception.
      Dim tasks(11) As Task
      For i As Integer = 0 To 11
          Select Case i Mod 4 
             ' Task should run to completion.
             Case 0
                tasks(i) = Task.Run( Sub() Thread.Sleep(2000))
             ' Task should be set to canceled state.
             Case 1   
                tasks(i) = Task.Run( Sub() Thread.Sleep(2000), token1)
             Case 2
                ' Task should throw an exception.
                tasks(i) = Task.Run( Sub() 
                                        Throw New NotSupportedException() 
                                     End Sub)
             Case 3
                ' Task should examine cancellation token.
                tasks(i) = Task.Run( Sub() 
                                        Thread.Sleep(2000) 
                                        If token2.IsCancellationRequested
                                           token2.ThrowIfCancellationRequested()
                                        End If
                                        Thread.Sleep(500) 
                                     End Sub, token2)   
          End Select
      Next
      Thread.Sleep(250)
      source2.Cancel()
       
      Try 
         Task.WaitAll(tasks)
      Catch ae As AggregateException
         Console.WriteLine("One or more exceptions occurred:")
         For Each ex in ae.InnerExceptions
             Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message)
         Next
      End Try   
      Console.WriteLine()
      
      Console.WriteLine("Status of tasks:")
      For Each t in tasks
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
         If t.Exception IsNot Nothing Then
            For Each ex in t.Exception.InnerExceptions
               Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                 ex.Message)
            Next
         End If
      Next
   End Sub
End Module
' 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

Aby uzyskać więcej informacji na temat obsługi wyjątków w operacjach asynchronicznych opartych na zadaniach, zobacz Obsługa wyjątków.

Zadania i kultura

Począwszy od aplikacji klasycznych, które są przeznaczone dla .NET Framework 4.6, kultura wątku, który tworzy i wywołuje zadanie staje się częścią kontekstu wątku. Oznacza to, że niezależnie od bieżącej kultury wątku, na którym wykonuje zadanie, bieżąca kultura zadania jest kulturą wątku wywołującego. W przypadku aplikacji przeznaczonych dla wersji .NET Framework przed .NET Framework 4.6 kultura zadania jest kulturą wątku, na którym jest wykonywane zadanie. Aby uzyskać więcej informacji, zobacz sekcję "Operacje asynchroniczne oparte na kulturze i zadaniach" w temacie CultureInfo .

Uwaga

Aplikacje ze sklepu są zgodne z środowisko wykonawcze systemu Windows w ustawieniu i uzyskiwaniu kultury domyślnej.

Dla deweloperów debugera

W przypadku deweloperów wdrażających niestandardowe debugery może być przydatnych kilku wewnętrznych i prywatnych członków zadania (mogą one ulec zmianie z wydania na wydanie). Pole m_taskId służy jako magazyn pomocniczy dla Id właściwości, jednak uzyskiwanie dostępu do tego pola bezpośrednio z debugera może być bardziej wydajne niż uzyskiwanie dostępu do tej samej wartości za pośrednictwem metody getter właściwości ( s_taskIdCounter licznik jest używany do pobierania następnego dostępnego identyfikatora zadania). m_stateFlags Podobnie pole przechowuje informacje o bieżącym etapie cyklu życia zadania. Informacje są również dostępne za pośrednictwem Status właściwości. Pole m_action przechowuje odwołanie do delegata zadania, a m_stateObject pole przechowuje stan asynchroniczny przekazany do zadania przez dewelopera. Na koniec w przypadku debugerów, które analizują ramki stosu, InternalWait metoda służy do potencjalnego znacznika, gdy zadanie wprowadza operację oczekiwania.

Konstruktory

Task(Action)

Inicjuje nową Task akcję przy użyciu określonej akcji.

Task(Action, CancellationToken)

Inicjuje nowy Task element z określoną akcją i CancellationToken.

Task(Action, CancellationToken, TaskCreationOptions)

Inicjuje nową Task z określoną akcją i opcjami tworzenia.

Task(Action, TaskCreationOptions)

Inicjuje nową Task z określoną akcją i opcjami tworzenia.

Task(Action<Object>, Object)

Inicjuje nową Task z określoną akcją i stanem.

Task(Action<Object>, Object, CancellationToken)

Inicjuje nową Task akcję, stan i opcje.

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

Inicjuje nową Task akcję, stan i opcje.

Task(Action<Object>, Object, TaskCreationOptions)

Inicjuje nową Task akcję, stan i opcje.

Właściwości

AsyncState

Pobiera obiekt stanu podany podczas Task tworzenia lub null, jeśli nie podano żadnego.

CompletedTask

Pobiera zadanie, które zostało już ukończone pomyślnie.

CreationOptions

Pobiera element użyty do utworzenia TaskCreationOptions tego zadania.

CurrentId

Zwraca identyfikator aktualnie wykonywanego elementu Task.

Exception

AggregateException Pobiera to, co spowodowało Task zakończenie przedwcześnie. Task Jeśli ukończono pomyślnie lub nie zgłosił jeszcze żadnych wyjątków, zwróci to polecenie null.

Factory

Zapewnia dostęp do metod fabrycznych do tworzenia i konfigurowania Task Task<TResult> wystąpień.

Id

Pobiera identyfikator dla tego Task wystąpienia.

IsCanceled

Pobiera informację, czy to Task wystąpienie zakończyło wykonywanie z powodu anulowania.

IsCompleted

Pobiera wartość wskazującą, czy zadanie zostało ukończone.

IsCompletedSuccessfully

Pobiera informacje o tym, czy zadanie było uruchamiane do ukończenia.

IsFaulted

Pobiera informację o zakończeniu Task z powodu nieobsługiwanego wyjątku.

Status

TaskStatus Pobiera to zadanie.

Metody

ConfigureAwait(Boolean)

Konfiguruje program awaiter używany do oczekiwania na ten Taskelement .

ContinueWith(Action<Task,Object>, Object)

Tworzy kontynuację, która odbiera informacje o stanie dostarczonego przez obiekt wywołujący i wykonuje je po zakończeniu działania obiektu docelowego Task .

ContinueWith(Action<Task,Object>, Object, CancellationToken)

Tworzy kontynuację, która odbiera informacje o stanie dostarczonym przez obiekt wywołujący oraz token anulowania, który jest wykonywany asynchronicznie po zakończeniu działania obiektu docelowego Task .

ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Tworzy kontynuację, która odbiera informacje o stanie dostarczonym przez obiekt wywołujący oraz token anulowania, który jest wykonywany po zakończeniu działania obiektu docelowego Task . Kontynuacja jest wykonywana na podstawie zestawu określonych warunków i używa określonego harmonogramu.

ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)

Tworzy kontynuację, która odbiera informacje o stanie dostarczone przez obiekt wywołujący i jest wykonywana po zakończeniu działania obiektu docelowego Task . Kontynuacja jest wykonywana na podstawie zestawu określonych warunków.

ContinueWith(Action<Task,Object>, Object, TaskScheduler)

Tworzy kontynuację, która odbiera informacje o stanie dostarczone przez obiekt wywołujący i wykonuje asynchronicznie po zakończeniu działania obiektu docelowego Task . Kontynuacja używa określonego harmonogramu.

ContinueWith(Action<Task>)

Tworzy kontynuację wykonywaną asynchronicznie po zakończeniu celu Task .

ContinueWith(Action<Task>, CancellationToken)

Tworzy kontynuację, która odbiera token anulowania i wykonuje asynchronicznie po zakończeniu elementu docelowego Task .

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

Tworzy kontynuację wykonywaną, gdy zadanie docelowe konkuruje zgodnie z określonym TaskContinuationOptionselementem . Kontynuacja odbiera token anulowania i używa określonego harmonogramu.

ContinueWith(Action<Task>, TaskContinuationOptions)

Tworzy kontynuację wykonywaną po zakończeniu zadania docelowego zgodnie z określonym TaskContinuationOptionselementem .

ContinueWith(Action<Task>, TaskScheduler)

Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu elementu docelowego Task . Kontynuacja używa określonego harmonogramu.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object)

Tworzy kontynuację, która odbiera informacje o stanie dostarczone przez obiekt wywołujący i wykonuje asynchronicznie, gdy element docelowy Task zakończy działanie i zwróci wartość.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)

Tworzy kontynuację, która jest wykonywana asynchronicznie, gdy element docelowy Task zostanie ukończony i zwróci wartość. Kontynuacja odbiera informacje o stanie dostarczone przez obiekt wywołujący i token anulowania.

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

Tworzy kontynuację, która jest wykonywana na podstawie określonych opcji kontynuacji zadania, gdy element docelowy Task zostanie ukończony i zwróci wartość. Kontynuacja odbiera informacje o stanie dostarczone przez obiekt wywołujący i token anulowania i używa określonego harmonogramu.

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

Tworzy kontynuację, która jest wykonywana na podstawie określonych opcji kontynuacji zadania po zakończeniu elementu docelowego Task . Kontynuacja odbiera informacje o stanie dostarczone przez obiekt wywołujący.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)

Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu elementu docelowego Task . Kontynuacja odbiera informacje o stanie dostarczone przez obiekt wywołujący i używa określonego harmonogramu.

ContinueWith<TResult>(Func<Task,TResult>)

Tworzy kontynuację, która jest wykonywana asynchronicznie, gdy element docelowy Task<TResult> zostanie ukończony i zwróci wartość.

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

Tworzy kontynuację, która jest wykonywana asynchronicznie, gdy element docelowy Task zostanie ukończony i zwróci wartość. Kontynuacja otrzymuje token anulowania.

ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Tworzy kontynuację, która jest wykonywana zgodnie z określonymi opcjami kontynuacji i zwraca wartość. Kontynuacja jest przekazywana token anulowania i używa określonego harmonogramu.

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

Tworzy kontynuację, która jest wykonywana zgodnie z określonymi opcjami kontynuacji i zwraca wartość.

ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)

Tworzy kontynuację, która jest wykonywana asynchronicznie, gdy element docelowy Task zostanie ukończony i zwróci wartość. Kontynuacja używa określonego harmonogramu.

Delay(Int32)

Tworzy zadanie, które zostanie zakończone po określonej liczbie milisekund.

Delay(Int32, CancellationToken)

Tworzy zadanie, które można anulować, które zostanie zakończone po określonej liczbie milisekund.

Delay(TimeSpan)

Tworzy zadanie, które zostanie ukończone po określonym interwale czasu.

Delay(TimeSpan, CancellationToken)

Tworzy zadanie, które można anulować, które zostanie ukończone po określonym interwale czasu.

Dispose()

Zwalnia wszystkie zasoby używane przez bieżące wystąpienie klasy Task.

Dispose(Boolean)

Usuwa element Task, zwalniając wszystkie niezarządzane zasoby.

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.

(Odziedziczone po Object)
FromCanceled(CancellationToken)

Tworzy obiekt, który Task został ukończony z powodu anulowania z określonym tokenem anulowania.

FromCanceled<TResult>(CancellationToken)

Tworzy obiekt, który Task<TResult> został ukończony z powodu anulowania z określonym tokenem anulowania.

FromException(Exception)

Tworzy obiekt Task zakończony z określonym wyjątkiem.

FromException<TResult>(Exception)

Tworzy obiekt Task<TResult> zakończony z określonym wyjątkiem.

FromResult<TResult>(TResult)

Tworzy obiekt, który Task<TResult> został pomyślnie ukończony z określonym wynikiem.

GetAwaiter()

Pobiera obiekt awaiter używany do oczekiwania na ten Taskelement .

GetHashCode()

Służy jako domyślna funkcja skrótu.

(Odziedziczone po Object)
GetType()

Type Pobiera wartość bieżącego wystąpienia.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
Run(Action)

Kolejkuje określoną pracę do uruchomienia w puli wątków i zwraca Task obiekt, który reprezentuje to działanie.

Run(Action, CancellationToken)

Kolejkuje określoną pracę do uruchomienia w puli wątków i zwraca Task obiekt, który reprezentuje to działanie. Token anulowania umożliwia anulowanie pracy, jeśli jeszcze nie została uruchomiona.

Run(Func<Task>)

Kolejkuje określoną pracę do uruchomienia w puli wątków i zwraca serwer proxy dla zadania zwróconego przez functionpolecenie .

Run(Func<Task>, CancellationToken)

Kolejkuje określoną pracę do uruchomienia w puli wątków i zwraca serwer proxy dla zadania zwróconego przez functionpolecenie . Token anulowania umożliwia anulowanie pracy, jeśli jeszcze nie została uruchomiona.

Run<TResult>(Func<Task<TResult>>)

Kolejkuje określoną pracę do uruchomienia w puli wątków i zwraca serwer proxy dla Task(TResult) zwracanego przez function. Token anulowania umożliwia anulowanie pracy, jeśli jeszcze nie została uruchomiona.

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

Kolejkuje określoną pracę do uruchomienia w puli wątków i zwraca serwer proxy dla Task(TResult) zwracanego przez function.

Run<TResult>(Func<TResult>)

Kolejkuje określoną pracę do uruchomienia w puli wątków i zwraca Task<TResult> obiekt, który reprezentuje to działanie. Token anulowania umożliwia anulowanie pracy, jeśli jeszcze nie została uruchomiona.

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

Kolejkuje określoną pracę do uruchomienia w puli wątków i zwraca Task(TResult) obiekt, który reprezentuje to działanie.

RunSynchronously()

Task Uruchamia synchronicznie TaskSchedulerbieżący element .

RunSynchronously(TaskScheduler)

Task Uruchamia synchronicznie podany TaskScheduler element.

Start()

Uruchamia element Task, planując wykonanie do bieżącego TaskSchedulerelementu .

Start(TaskScheduler)

Uruchamia obiekt Task, planując wykonanie do określonego TaskSchedulerelementu .

ToString()

Zwraca ciąg reprezentujący bieżący obiekt.

(Odziedziczone po Object)
Wait()

Czeka na Task zakończenie wykonywania.

Wait(CancellationToken)

Czeka na Task zakończenie wykonywania. Oczekiwanie kończy się, jeśli token anulowania zostanie anulowany przed ukończeniem zadania.

Wait(Int32)

Czeka na Task ukończenie wykonywania w ramach określonej liczby milisekund.

Wait(Int32, CancellationToken)

Czeka na Task zakończenie wykonywania. Oczekiwanie kończy się, jeśli upłynie interwał limitu czasu lub token anulowania zostanie anulowany przed zakończeniem zadania.

Wait(TimeSpan)

Oczekuje na Task ukończenie wykonywania w określonym przedziale czasu.

Wait(TimeSpan, CancellationToken)

Czeka na Task zakończenie wykonywania.

WaitAll(Task[])

Czeka na ukończenie wykonywania wszystkich podanych Task obiektów.

WaitAll(Task[], CancellationToken)

Czeka na zakończenie wykonywania wszystkich podanych Task obiektów, chyba że oczekiwanie zostanie anulowane.

WaitAll(Task[], Int32)

Czeka na ukończenie wykonywania wszystkich podanych Task obiektów w ramach określonej liczby milisekund.

WaitAll(Task[], Int32, CancellationToken)

Czeka na ukończenie wykonywania wszystkich podanych Task obiektów w określonej liczbie milisekund lub do momentu anulowania oczekiwania.

WaitAll(Task[], TimeSpan)

Czeka na ukończenie wykonywania wszystkich udostępnionych obiektów, które można Task anulować w określonym przedziale czasu.

WaitAny(Task[])

Czeka na ukończenie wykonywania dowolnego z podanych Task obiektów.

WaitAny(Task[], CancellationToken)

Czeka na ukończenie wykonywania dowolnego z podanych Task obiektów, chyba że oczekiwanie zostanie anulowane.

WaitAny(Task[], Int32)

Czeka na ukończenie wykonywania dowolnego z podanych Task obiektów w ramach określonej liczby milisekund.

WaitAny(Task[], Int32, CancellationToken)

Czeka na ukończenie wykonywania dowolnego z podanych Task obiektów w określonej liczbie milisekund lub do momentu anulowania tokenu anulowania.

WaitAny(Task[], TimeSpan)

Czeka na ukończenie wykonywania dowolnego z podanych Task obiektów w określonym przedziale czasu.

WaitAsync(CancellationToken)

Pobiera element Task , który zostanie ukończony po Task zakończeniu lub po żądaniu anulowania określonego CancellationToken .

WaitAsync(TimeSpan)

Pobiera element Task , który zostanie ukończony po Task zakończeniu lub upływie określonego limitu czasu.

WaitAsync(TimeSpan, CancellationToken)

Pobiera element Task , który zostanie ukończony po Task zakończeniu, po upływie określonego limitu czasu lub po żądaniu anulowania określonego CancellationToken limitu czasu.

WhenAll(IEnumerable<Task>)

Tworzy zadanie, które zostanie ukończone po zakończeniu Task wszystkich obiektów w kolekcji wyliczalnej.

WhenAll(Task[])

Tworzy zadanie, które zostanie ukończone po zakończeniu wszystkich Task obiektów w tablicy.

WhenAll<TResult>(IEnumerable<Task<TResult>>)

Tworzy zadanie, które zostanie ukończone po zakończeniu Task<TResult> wszystkich obiektów w kolekcji wyliczalnej.

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

Tworzy zadanie, które zostanie ukończone po zakończeniu wszystkich Task<TResult> obiektów w tablicy.

WhenAny(IEnumerable<Task>)

Tworzy zadanie, które zostanie wykonane po zakończeniu któregokolwiek z dostarczonych zadań.

WhenAny(Task, Task)

Tworzy zadanie, które zostanie ukończone po zakończeniu jednego z podanych zadań.

WhenAny(Task[])

Tworzy zadanie, które zostanie ukończone po zakończeniu któregokolwiek z dostarczonych zadań.

WhenAny<TResult>(IEnumerable<Task<TResult>>)

Tworzy zadanie, które zostanie ukończone po zakończeniu któregokolwiek z dostarczonych zadań.

WhenAny<TResult>(Task<TResult>, Task<TResult>)

Tworzy zadanie, które zostanie ukończone po zakończeniu jednego z podanych zadań.

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

Tworzy zadanie, które zostanie ukończone po zakończeniu któregokolwiek z dostarczonych zadań.

Yield()

Tworzy oczekujące zadanie, które asynchronicznie zwraca bieżący kontekst w oczekiwanym czasie.

Jawne implementacje interfejsu

IAsyncResult.AsyncWaitHandle

Pobiera element WaitHandle , który może służyć do oczekiwania na ukończenie zadania.

IAsyncResult.CompletedSynchronously

Pobiera wskazanie, czy operacja została ukończona synchronicznie.

Metody rozszerzania

DispatcherOperationWait(Task)

Czas oczekiwania na ukończenie bazowego DispatcherOperation .

DispatcherOperationWait(Task, TimeSpan)

Czeka na określoną ilość czasu na ukończenie bazowego DispatcherOperation .

IsDispatcherOperationTask(Task)

Zwraca wartość wskazującą, czy jest to Task skojarzone z elementem DispatcherOperation.

AsAsyncAction(Task)

Zwraca akcję asynchroniczną Windows runtime, która reprezentuje uruchomione zadanie.

Dotyczy

Bezpieczeństwo wątkowe

Wszystkie elementy członkowskie , Taskz wyjątkiem Dispose(), są bezpieczne wątkowo i mogą być używane z wielu wątków jednocześnie.

Zobacz też