Task Klasa

Definicja

Reprezentuje operację asynchroniczną.Represents an asynchronous operation.

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

TaskKlasa reprezentuje pojedynczą operację, która nie zwraca wartości i zazwyczaj wykonuje ją asynchronicznie.The Task class represents a single operation that does not return a value and that usually executes asynchronously. Task obiekty są jednym z centralnych składników wzorca asynchronicznego opartego na zadaniach , które zostały najpierw wprowadzone w .NET Framework 4.Task objects are one of the central components of the task-based asynchronous pattern first introduced in the .NET Framework 4. Ponieważ prace wykonywane przez Task obiekt zwykle są wykonywane asynchronicznie w wątku puli wątków zamiast synchronicznie w wątku aplikacji głównej, można użyć Status właściwości, a także właściwości,, IsCanceled IsCompleted i IsFaulted , aby określić stan zadania.Because the work performed by a Task object typically executes asynchronously on a thread pool thread rather than synchronously on the main application thread, you can use the Status property, as well as the IsCanceled, IsCompleted, and IsFaulted properties, to determine the state of a task. Najczęściej wyrażenie lambda służy do określenia pracy, którą zadanie ma wykonać.Most commonly, a lambda expression is used to specify the work that the task is to perform.

W przypadku operacji, które zwracają wartości, należy użyć Task<TResult> klasy.For operations that return values, you use the Task<TResult> class.

W tej sekcji:In this section:

Przykłady tworzenia wystąpień zadań Task instantiation examples
Tworzenie i wykonywanie zadania Creating and executing a task
Rozdzielanie tworzenia i wykonywania zadań Separating task creation and execution
Oczekiwanie na zakończenie jednego lub większej liczby zadań Waiting for one or more tasks to complete
Zadania i kultura Tasks and culture
Dla deweloperów debugeraFor debugger developers

Tworzenie wystąpienia zadaniaTask instantiation

Poniższy przykład tworzy i wykonuje cztery zadania.The following example creates and executes four tasks. Trzy zadania wykonują Action<T> delegata o nazwie action , który akceptuje argument typu Object .Three tasks execute an Action<T> delegate named action, which accepts an argument of type Object. Czwarte zadanie wykonuje wyrażenie lambda ( Action Delegat) zdefiniowane wewnętrznie w wywołaniu metody tworzenia zadania.A fourth task executes a lambda expression (an Action delegate) that is defined inline in the call to the task creation method. Każde zadanie jest tworzone i uruchamiane w inny sposób:Each task is instantiated and run in a different way:

  • Zadanie t1 jest tworzone przez wywołanie konstruktora klasy zadań, ale jest uruchamiane przez wywołanie jego Start() metody tylko po t2 rozpoczęciu zadania.Task t1 is instantiated by calling a Task class constructor, but is started by calling its Start() method only after task t2 has started.

  • Zadanie t2 jest tworzone i rozpoczęte w pojedynczym wywołaniu metody przez wywołanie TaskFactory.StartNew(Action<Object>, Object) metody.Task t2 is instantiated and started in a single method call by calling the TaskFactory.StartNew(Action<Object>, Object) method.

  • Zadanie t3 jest tworzone i rozpoczęte w pojedynczym wywołaniu metody przez wywołanie Run(Action) metody.Task t3 is instantiated and started in a single method call by calling the Run(Action) method.

  • Zadanie t4 jest wykonywane synchronicznie w głównym wątku przez wywołanie RunSynchronously() metody.Task t4 is executed synchronously on the main thread by calling the RunSynchronously() method.

Ponieważ zadanie t4 jest wykonywane synchronicznie, jest wykonywane na głównym wątku aplikacji.Because task t4 executes synchronously, it executes on the main application thread. Pozostałe zadania są wykonywane asynchronicznie zazwyczaj w co najmniej jednym wątku puli wątków.The remaining tasks execute asynchronously typically on one or more thread pool threads.

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 zadaniaCreating and executing a task

Task wystąpienia mogą być tworzone na różne sposoby.Task instances may be created in a variety of ways. Najbardziej typowym podejściem, które jest dostępne począwszy od .NET Framework 4,5, jest wywołanie metody statycznej Run .The most common approach, which is available starting with the .NET Framework 4.5, is to call the static Run method. RunMetoda zapewnia prosty sposób uruchamiania zadania przy użyciu wartości domyślnych i bez konieczności stosowania dodatkowych parametrów.The Run method provides a simple way to start a task using default values and without requiring additional parameters. W poniższym przykładzie zastosowano Run(Action) metodę, aby uruchomić zadanie, które tworzy pętlę, a następnie wyświetla liczbę iteracji pętli:The following example uses the Run(Action) method to start a task that loops and then displays the number of loop iterations:

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

Alternatywna metoda, a najczęściej, aby uruchomić zadanie w .NET Framework 4, jest metodą statyczną TaskFactory.StartNew .An alternative, and the most common method to start a task in .NET Framework 4, is the static TaskFactory.StartNew method. Task.FactoryWłaściwość zwraca TaskFactory obiekt.The Task.Factory property returns a TaskFactory object. Przeciążenia TaskFactory.StartNew metody pozwalają określić parametry do przekazania do opcji tworzenia zadania i harmonogramu zadań.Overloads of the TaskFactory.StartNew method let you specify parameters to pass to the task creation options and a task scheduler. Poniższy przykład używa TaskFactory.StartNew metody do uruchomienia zadania.The following example uses the TaskFactory.StartNew method to start a task. Jest ona funkcjonalnie równoważna z kodem w poprzednim przykładzie.It is functionally equivalent to the code in the previous example.

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 oparte na zadaniach programowanie asynchroniczne.For more complete examples, see Task-based Asynchronous Programming.

Rozdzielanie tworzenia i wykonywania zadańSeparating task creation and execution

TaskKlasa zawiera również konstruktory, które inicjują zadanie, ale nie Zaplanuj jego wykonywania.The Task class also provides constructors that initialize the task but that do not schedule it for execution. Ze względu na wydajność, Task.Run lub TaskFactory.StartNew Metoda jest preferowanym mechanizmem tworzenia i planowania zadań obliczeniowych, ale w przypadku scenariuszy, 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.For performance reasons, the Task.Run or TaskFactory.StartNew method is the preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation and scheduling must be separated, you can use the constructors and then call the Task.Start method to schedule the task for execution at a later time.

Oczekiwanie na zakończenie jednego lub większej liczby zadańWaiting for one or more tasks to complete

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.Because tasks typically run asynchronously on a thread pool thread, the thread that creates and starts the task continues execution as soon as the task has been instantiated. W niektórych przypadkach, gdy wątek wywołujący jest głównym wątkiem aplikacji, aplikacja może zostać przerwana przed rozpoczęciem wykonywania zadania.In some cases, when the calling thread is the main application thread, the app may terminate before the task actually begins execution. W innych przypadkach logika aplikacji może wymagać, aby wątek wywołujący kontynuował wykonywanie tylko wtedy, gdy co najmniej jedno zadanie zostało ukończone.In others, your application's logic may require that the calling thread continue execution only when one or more tasks have completed execution. Można synchronizować wykonywanie wątku wywołującego i wykonywanych przez niego zadań asynchronicznych, wywołując Wait metodę w celu oczekiwania na ukończenie jednego lub większej liczby zadań.You can synchronize the execution of the calling thread and the asynchronous tasks it launches by calling a Wait method to wait for one or more tasks to complete.

Aby poczekać na zakończenie jednego zadania, możesz wywołać jego Task.Wait metodę.To wait for a single task to complete, you can call its Task.Wait method. Wywołanie Wait metody blokuje wątek wywołujący do momentu zakończenia wykonywania wystąpienia pojedynczej klasy.A call to the Wait method blocks the calling thread until the single class instance has completed execution.

Poniższy przykład wywołuje metodę bez parametrów, Wait() Aby odczekać bezwarunkowo do momentu ukończenia zadania.The following example calls the parameterless Wait() method to wait unconditionally until a task completes. Zadanie symuluje działanie, wywołując Thread.Sleep metodę w stanie uśpienia przez dwa sekundy.The task simulates work by calling the Thread.Sleep method to sleep for two seconds.

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ż poczekać na ukończenie zadania.You can also conditionally wait for a task to complete. Wait(Int32)Metody i Wait(TimeSpan) blokują wątek wywołujący do momentu zakończenia zadania lub przekroczenia limitu czasu, zależnie od tego, co nastąpi wcześniej.The Wait(Int32) and Wait(TimeSpan) methods block the calling thread until the task finishes or a timeout interval elapses, whichever comes first. Ponieważ Poniższy przykład uruchamia zadanie, które jest w stanie uśpienia przez dwa sekundy, ale definiuje jedną sekundę wartość limitu czasu, wątek wywołujący jest blokowany do momentu wygaśnięcia limitu czasu i przed ukończeniem wykonywania zadania.Since the following example launches a task that sleeps for two seconds but defines a one-second timeout value, the calling thread blocks until the timeout expires and before the task has completed execution.

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.

Możesz również podać token anulowania, wywołując Wait(CancellationToken) Wait(Int32, CancellationToken) metody i.You can also supply a cancellation token by calling the Wait(CancellationToken) and Wait(Int32, CancellationToken) methods. Jeśli IsCancellationRequested właściwość tokenu jest true lub przyjmuje się true , gdy Wait Metoda jest wykonywana, metoda zgłasza OperationCanceledException .If the token's IsCancellationRequested property is true or becomes true while the Wait method is executing, the method throws an OperationCanceledException.

W niektórych przypadkach może być konieczne poczekanie na wykonanie pierwszej serii wykonywanych zadań, ale nie Zadbaj o to, jakie zadanie ma.In some cases, you may want to wait for the first of a series of executing tasks to complete, but don't care which task it is. W tym celu można wywołać jedno z przeciążeń Task.WaitAny metody.For this purpose, you can call one of the overloads of the Task.WaitAny method. Poniższy przykład tworzy trzy zadania, z których każde uśpienie dla interwału jest określane przez generator liczb losowych.The following example creates three tasks, each of which sleeps for an interval determined by a random number generator. WaitAny(Task[])Metoda czeka na zakończenie pierwszego zadania.The WaitAny(Task[]) method waits for the first task to complete. W tym przykładzie wyświetlane są informacje o stanie wszystkich trzech zadań.The example then displays information about the status of all three tasks.

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 WaitAll metodę.You can also wait for all of a series of tasks to complete by calling the WaitAll method. Poniższy przykład tworzy dziesięć zadań, czeka na zakończenie wszystkich dziesięciu, a następnie wyświetla ich stan.The following example creates ten tasks, waits for all ten to complete, and then displays their status.

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 po poczekaniu na zakończenie jednego lub większej liczby zadań wszystkie wyjątki zgłoszone w uruchomionych zadaniach są propagowane w wątku, który wywołuje Wait metodę, jak pokazano w poniższym przykładzie.Note that when you wait for one or more tasks to complete, any exceptions thrown in the running tasks are propagated on the thread that calls the Wait method, as the following example shows. Uruchamia 12 zadań, trzy z nich, które pełnią normalne i trzy z nich zgłasza wyjątek.It launches 12 tasks, three of which complete normally and three of which throw an exception. Z pozostałych sześciu zadań, trzy zostały anulowane przed rozpoczęciem, a trzy zostaną anulowane podczas wykonywania.Of the remaining six tasks, three are cancelled before they start, and three are cancelled while they are executing. Wyjątki są zgłaszane w WaitAll wywołaniu metody i są obsługiwane przez try / catch blok.Exceptions are thrown in the WaitAll method call and are handled by a 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
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.For more information on exception handling in task-based asynchronous operations, see Exception Handling.

Zadania i kulturaTasks and culture

Począwszy od aplikacji klasycznych, które są przeznaczone dla .NET Framework 4,6, kultura wątku, który tworzy i wywołuje zadanie, wchodzi w skład kontekstu wątku.Starting with desktop apps that target the .NET Framework 4.6, the culture of the thread that creates and invokes a task becomes part of the thread's context. Oznacza to, że niezależnie od bieżącej kultury wątku, w którym wykonywane jest zadanie, bieżąca kultura zadania jest kulturą wątku wywołującego.That is, regardless of the current culture of the thread on which the task executes, the current culture of the task is the culture of the calling thread. W przypadku aplikacji przeznaczonych dla wersji .NET Framework przed .NET Framework 4,6, kultura zadania jest kulturą wątku, w którym wykonywane jest zadanie.For apps that target versions of the .NET Framework prior to the .NET Framework 4.6, the culture of the task is the culture of the thread on which the task executes. Aby uzyskać więcej informacji, zapoznaj się z sekcją "kultury i operacje asynchroniczne oparte na zadaniach" w CultureInfo temacie.For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic.

Uwaga

Aplikacje ze sklepu wykonują środowisko wykonawcze systemu Windows w ustawieniu i pobierają kulturę domyślną.Store apps follow the Windows Runtime in setting and getting the default culture.

Dla deweloperów debugeraFor debugger developers

Deweloperzy implementujący niestandardowe debugery mogą używać kilku wewnętrznych i prywatnych elementów członkowskich zadania (mogą one ulec zmianie w wersji Release to Release).For developers implementing custom debuggers, several internal and private members of task may be useful (these may change from release to release). m_taskIdPole służy jako magazyn zapasowy dla Id właściwości, ale dostęp do tego pola bezpośrednio z debugera może być bardziej wydajny niż dostęp do tej samej wartości za pomocą metody pobierającej właściwości ( s_taskIdCounter licznik jest używany do pobierania następnego dostępnego identyfikatora zadania).The m_taskId field serves as the backing store for the Id property, however accessing this field directly from a debugger may be more efficient than accessing the same value through the property's getter method (the s_taskIdCounter counter is used to retrieve the next available ID for a task). Analogicznie, w m_stateFlags polu są przechowywane informacje o bieżącym etapie cyklu życia zadania, a także informacje dostępne przez Status Właściwość.Similarly, the m_stateFlags field stores information about the current lifecycle stage of the task, information also accessible through the Status property. W m_action polu jest przechowywane odwołanie do delegata zadania, a w m_stateObject polu jest przechowywany stan asynchroniczny przesłany do zadania przez dewelopera.The m_action field stores a reference to the task's delegate, and the m_stateObject field stores the async state passed to the task by the developer. Na koniec w przypadku debugerów, które analizują ramki stosu, InternalWait Metoda służy do uzyskania potencjalnego znacznika, gdy zadanie przekroczy operację oczekiwania.Finally, for debuggers that parse stack frames, the InternalWait method serves a potential marker for when a task is entering a wait operation.

Konstruktory

Task(Action)

Inicjuje nową Task z określoną akcją.Initializes a new Task with the specified action.

Task(Action, CancellationToken)

Inicjuje nową Task z określoną akcją i CancellationToken .Initializes a new Task with the specified action and CancellationToken.

Task(Action, CancellationToken, TaskCreationOptions)

Inicjuje nową Task z określoną akcją i opcjami tworzenia.Initializes a new Task with the specified action and creation options.

Task(Action, TaskCreationOptions)

Inicjuje nową Task z określoną akcją i opcjami tworzenia.Initializes a new Task with the specified action and creation options.

Task(Action<Object>, Object)

Inicjuje nową Task z określoną akcją i stanem.Initializes a new Task with the specified action and state.

Task(Action<Object>, Object, CancellationToken)

Inicjuje nową Task z określoną akcją, stanem i opcjami.Initializes a new Task with the specified action, state, and options.

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

Inicjuje nową Task z określoną akcją, stanem i opcjami.Initializes a new Task with the specified action, state, and options.

Task(Action<Object>, Object, TaskCreationOptions)

Inicjuje nową Task z określoną akcją, stanem i opcjami.Initializes a new Task with the specified action, state, and options.

Właściwości

AsyncState

Pobiera obiekt stanu dostarczony Task , gdy został utworzony, lub wartość null, jeśli żaden nie został podany.Gets the state object supplied when the Task was created, or null if none was supplied.

CompletedTask

Pobiera zadanie, które zostało już wykonane pomyślnie.Gets a task that has already completed successfully.

CreationOptions

Pobiera TaskCreationOptions użyty do utworzenia tego zadania.Gets the TaskCreationOptions used to create this task.

CurrentId

Zwraca identyfikator aktualnie wykonywanego elementu Task .Returns the ID of the currently executing Task.

Exception

Pobiera AggregateException , który spowodował Task przedwcześnie zakończenie.Gets the AggregateException that caused the Task to end prematurely. Jeśli Task zakończyło się pomyślnie lub nie zgłoszono żadnych wyjątków, spowoduje to zwrócenie null .If the Task completed successfully or has not yet thrown any exceptions, this will return null.

Factory

Zapewnia dostęp do metod fabrycznych na potrzeby tworzenia i konfigurowania Task Task<TResult> wystąpień.Provides access to factory methods for creating and configuring Task and Task<TResult> instances.

Id

Pobiera identyfikator dla tego Task wystąpienia.Gets an ID for this Task instance.

IsCanceled

Określa, czy to Task wystąpienie zakończyło wykonywanie z powodu anulowania.Gets whether this Task instance has completed execution due to being canceled.

IsCompleted

Pobiera wartość wskazującą, czy zadanie zostało ukończone.Gets a value that indicates whether the task has completed.

IsCompletedSuccessfully

Określa, czy zadanie zostało wykonane w celu ukończenia.Gets whether the task ran to completion.

IsFaulted

Pobiera czy Task ukończono z powodu nieobsługiwanego wyjątku.Gets whether the Task completed due to an unhandled exception.

Status

Pobiera TaskStatus to zadanie.Gets the TaskStatus of this task.

Metody

ConfigureAwait(Boolean)

Konfiguruje obiekt oczekujący używany do tego oczekiwania Task .Configures an awaiter used to await this Task.

ContinueWith(Action<Task,Object>, Object)

Tworzy kontynuację, która odbiera informacje o stanie dostarczone przez obiekt wywołujący i wykonuje po Task zakończeniu działania obiektu docelowego.Creates a continuation that receives caller-supplied state information and executes when the target Task completes.

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

Tworzy kontynuację, która odbiera informacje o stanie dostarczone przez obiekt wywołujący i token anulowania, które są wykonywane asynchronicznie po Task zakończeniu celu.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes asynchronously when the target Task completes.

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

Tworzy kontynuację, która odbiera informacje o stanie dostarczone przez obiekt wywołujący i token anulowania, które są wykonywane po Task zakończeniu celu.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes when the target Task completes. Kontynuacja jest wykonywana na podstawie zestawu określonych warunków i używa określonego harmonogramu.The continuation executes based on a set of specified conditions and uses a specified scheduler.

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

Tworzy kontynuację, która odbiera informacje o stanie dostarczone przez obiekt wywołujący i wykonuje po Task zakończeniu działania obiektu docelowego.Creates a continuation that receives caller-supplied state information and executes when the target Task completes. Kontynuacja jest wykonywana na podstawie zestawu określonych warunków.The continuation executes based on a set of specified conditions.

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 elementu docelowego Task .Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. Kontynuacja używa określonego harmonogramu.The continuation uses a specified scheduler.

ContinueWith(Action<Task>)

Tworzy kontynuację, która jest wykonywana asynchronicznie po Task zakończeniu celu.Creates a continuation that executes asynchronously when the target Task completes.

ContinueWith(Action<Task>, CancellationToken)

Tworzy kontynuację, która odbiera token anulowania i wykonuje asynchronicznie po Task zakończeniu celu.Creates a continuation that receives a cancellation token and executes asynchronously when the target Task completes.

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

Tworzy kontynuację, która jest wykonywana, gdy zadanie docelowe konkuruje zgodnie z określonym TaskContinuationOptions .Creates a continuation that executes when the target task competes according to the specified TaskContinuationOptions. Kontynuacja odbiera token anulowania i używa określonego harmonogramu.The continuation receives a cancellation token and uses a specified scheduler.

ContinueWith(Action<Task>, TaskContinuationOptions)

Tworzy kontynuację, która jest wykonywana po zakończeniu zadania docelowego zgodnie z określonym TaskContinuationOptions .Creates a continuation that executes when the target task completes according to the specified TaskContinuationOptions.

ContinueWith(Action<Task>, TaskScheduler)

Tworzy kontynuację, która jest wykonywana asynchronicznie po Task zakończeniu celu.Creates a continuation that executes asynchronously when the target Task completes. Kontynuacja używa określonego harmonogramu.The continuation uses a specified scheduler.

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

Tworzy kontynuację, która odbiera informacje o stanie dostarczone przez obiekt wywołujący i wykonuje asynchronicznie po zakończeniu elementu docelowego Task i zwraca wartość.Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes and returns a value.

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

Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu elementu docelowego Task i zwraca wartość.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Kontynuacja odbiera informacje o stanie dostarczone przez obiekt wywołujący oraz token anulowania.The continuation receives caller-supplied state information and a cancellation token.

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

Tworzy kontynuację, która jest wykonywana na podstawie określonych opcji kontynuacji zadania, gdy cel Task kończy się i zwraca wartość.Creates a continuation that executes based on the specified task continuation options when the target Task completes and returns a value. Kontynuacja odbiera informacje o stanie dostarczone przez obiekt wywołujący oraz token anulowania i używa określonego harmonogramu.The continuation receives caller-supplied state information and a cancellation token and uses the specified scheduler.

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

Tworzy kontynuację, która jest wykonywana na podstawie określonych opcji kontynuacji zadania po Task zakończeniu elementu docelowego.Creates a continuation that executes based on the specified task continuation options when the target Task completes. Kontynuacja odbiera informacje o stanie dostarczone przez proces wywołujący.The continuation receives caller-supplied state information.

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

Tworzy kontynuację, która jest wykonywana asynchronicznie po Task zakończeniu celu.Creates a continuation that executes asynchronously when the target Task completes. Kontynuacja odbiera informacje o stanie dostarczone przez proces wywołujący i używa określonego harmonogramu.The continuation receives caller-supplied state information and uses a specified scheduler.

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

Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu elementu docelowego Task<TResult> i zwraca wartość.Creates a continuation that executes asynchronously when the target Task<TResult> completes and returns a value.

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

Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu elementu docelowego Task i zwraca wartość.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Kontynuacja odbiera token anulowania.The continuation receives a cancellation token.

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

Tworzy kontynuację, która jest wykonywana zgodnie z określonymi opcjami kontynuacji i zwraca wartość.Creates a continuation that executes according to the specified continuation options and returns a value. Kontynuacja powoduje przekazanie tokenu anulowania i użycie określonego harmonogramu.The continuation is passed a cancellation token and uses a specified scheduler.

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

Tworzy kontynuację, która jest wykonywana zgodnie z określonymi opcjami kontynuacji i zwraca wartość.Creates a continuation that executes according to the specified continuation options and returns a value.

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

Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu elementu docelowego Task i zwraca wartość.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Kontynuacja używa określonego harmonogramu.The continuation uses a specified scheduler.

Delay(Int32)

Tworzy zadanie, które kończy się po określonej liczbie milisekund.Creates a task that completes after a specified number of milliseconds.

Delay(Int32, CancellationToken)

Tworzy zadanie anulowania, które kończy się po określonej liczbie milisekund.Creates a cancellable task that completes after a specified number of milliseconds.

Delay(TimeSpan)

Tworzy zadanie, które kończy się po określonym interwale czasu.Creates a task that completes after a specified time interval.

Delay(TimeSpan, CancellationToken)

Tworzy zadanie, które kończy się po upływie określonego interwału czasu.Creates a cancellable task that completes after a specified time interval.

Dispose()

Zwalnia wszystkie zasoby używane przez bieżące wystąpienie klasy Task.Releases all resources used by the current instance of the Task class.

Dispose(Boolean)

Usuwa Task , zwalniając wszystkie niezarządzane zasoby.Disposes the Task, releasing all of its unmanaged resources.

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
FromCanceled(CancellationToken)

Tworzy element Task , który został ukończony z powodu anulowania z określonym tokenem anulowania.Creates a Task that's completed due to cancellation with a specified cancellation token.

FromCanceled<TResult>(CancellationToken)

Tworzy element Task<TResult> , który został ukończony z powodu anulowania z określonym tokenem anulowania.Creates a Task<TResult> that's completed due to cancellation with a specified cancellation token.

FromException(Exception)

Tworzy obiekt Task , który został ukończony z określonym wyjątkiem.Creates a Task that has completed with a specified exception.

FromException<TResult>(Exception)

Tworzy Task<TResult> zakończenie z określonym wyjątkiem.Creates a Task<TResult> that's completed with a specified exception.

FromResult<TResult>(TResult)

Tworzy element Task<TResult> , który został pomyślnie ukończony z określonym wynikiem.Creates a Task<TResult> that's completed successfully with the specified result.

GetAwaiter()

Pobiera obiekt oczekujący, który jest używany do oczekiwania na to Task .Gets an awaiter used to await this Task.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetType()

Pobiera Type bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy skróconą kopię bieżącego elementu Object .Creates a shallow copy of the current Object.

(Odziedziczone po Object)
Run(Action)

Kolejkuje określoną liczbę zadań do uruchomienia w puli wątków i zwraca Task obiekt, który reprezentuje tę działanie.Queues the specified work to run on the thread pool and returns a Task object that represents that work.

Run(Action, CancellationToken)

Kolejkuje określoną liczbę zadań do uruchomienia w puli wątków i zwraca Task obiekt, który reprezentuje tę działanie.Queues the specified work to run on the thread pool and returns a Task object that represents that work. Token anulowania umożliwia anulowanie pracy, jeśli nie została jeszcze uruchomiona.A cancellation token allows the work to be cancelled if it has not yet started.

Run(Func<Task>)

Kolejkuje określoną służbę do uruchomienia w puli wątków i zwraca serwer proxy dla zadania zwróconego przez function .Queues the specified work to run on the thread pool and returns a proxy for the task returned by function.

Run(Func<Task>, CancellationToken)

Kolejkuje określoną służbę do uruchomienia w puli wątków i zwraca serwer proxy dla zadania zwróconego przez function .Queues the specified work to run on the thread pool and returns a proxy for the task returned by function. Token anulowania umożliwia anulowanie pracy, jeśli nie została jeszcze uruchomiona.A cancellation token allows the work to be cancelled if it has not yet started.

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

Kolejkuje określoną służbę do uruchomienia w puli wątków i zwraca serwer proxy dla Task(TResult) zwracanych przez function .Queues the specified work to run on the thread pool and returns a proxy for the Task(TResult) returned by function. Token anulowania umożliwia anulowanie pracy, jeśli nie została jeszcze uruchomiona.A cancellation token allows the work to be cancelled if it has not yet started.

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

Kolejkuje określoną służbę do uruchomienia w puli wątków i zwraca serwer proxy dla Task(TResult) zwracanych przez function .Queues the specified work to run on the thread pool and returns a proxy for the Task(TResult) returned by function.

Run<TResult>(Func<TResult>)

Kolejkuje określoną liczbę zadań do uruchomienia w puli wątków i zwraca Task<TResult> obiekt, który reprezentuje tę działanie.Queues the specified work to run on the thread pool and returns a Task<TResult> object that represents that work. Token anulowania umożliwia anulowanie pracy, jeśli nie została jeszcze uruchomiona.A cancellation token allows the work to be cancelled if it has not yet started.

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

Kolejkuje określoną liczbę zadań do uruchomienia w puli wątków i zwraca Task(TResult) obiekt, który reprezentuje tę działanie.Queues the specified work to run on the thread pool and returns a Task(TResult) object that represents that work.

RunSynchronously()

Uruchamia Task synchronicznie na bieżącym TaskScheduler .Runs the Task synchronously on the current TaskScheduler.

RunSynchronously(TaskScheduler)

Działa Task synchronicznie na TaskScheduler podanym.Runs the Task synchronously on the TaskScheduler provided.

Start()

Uruchamia Task program, planując go do wykonania w bieżącym TaskScheduler .Starts the Task, scheduling it for execution to the current TaskScheduler.

Start(TaskScheduler)

Uruchamia Task , aby zaplanować wykonanie do określonego TaskScheduler .Starts the Task, scheduling it for execution to the specified TaskScheduler.

ToString()

Zwraca ciąg reprezentujący bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)
Wait()

Czeka na Task zakończenie wykonywania.Waits for the Task to complete execution.

Wait(CancellationToken)

Czeka na Task zakończenie wykonywania.Waits for the Task to complete execution. Oczekiwanie kończy się, jeśli token anulowania zostanie anulowany przed ukończeniem zadania.The wait terminates if a cancellation token is canceled before the task completes.

Wait(Int32)

Czeka na Task zakończenie wykonywania w ciągu określonej liczby milisekund.Waits for the Task to complete execution within a specified number of milliseconds.

Wait(Int32, CancellationToken)

Czeka na Task zakończenie wykonywania.Waits for the Task to complete execution. Oczekiwanie kończy się, jeśli upłynie interwał limitu czasu lub token anulowania został anulowany przed ukończeniem zadania.The wait terminates if a timeout interval elapses or a cancellation token is canceled before the task completes.

Wait(TimeSpan)

Czeka na Task zakończenie wykonywania w określonym przedziale czasu.Waits for the Task to complete execution within a specified time interval.

WaitAll(Task[])

Czeka na wszystkie podane obiekty, Task Aby ukończyć wykonywanie.Waits for all of the provided Task objects to complete execution.

WaitAll(Task[], CancellationToken)

Czeka na ukończenie wszystkich podanych Task obiektów, chyba że oczekiwanie zostanie anulowane.Waits for all of the provided Task objects to complete execution unless the wait is cancelled.

WaitAll(Task[], Int32)

Czeka na wszystkie podane obiekty, Task Aby ukończyć wykonywanie w ciągu określonej liczby milisekund.Waits for all of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAll(Task[], Int32, CancellationToken)

Czeka na wszystkie podane obiekty, Task Aby ukończyć wykonywanie w ciągu określonej liczby milisekund lub do czasu anulowania oczekiwania.Waits for all of the provided Task objects to complete execution within a specified number of milliseconds or until the wait is cancelled.

WaitAll(Task[], TimeSpan)

Czeka na wszystkie poświadczone Task obiekty do wykonania w określonym przedziale czasu.Waits for all of the provided cancellable Task objects to complete execution within a specified time interval.

WaitAny(Task[])

Czeka na dowolne z podanych Task obiektów, aby ukończyć wykonywanie.Waits for any of the provided Task objects to complete execution.

WaitAny(Task[], CancellationToken)

Czeka na dowolne z podanych Task obiektów do zakończenia wykonywania, chyba że oczekiwanie zostanie anulowane.Waits for any of the provided Task objects to complete execution unless the wait is cancelled.

WaitAny(Task[], Int32)

Czeka na dowolne z podanych Task obiektów, aby ukończyć wykonywanie w ciągu określonej liczby milisekund.Waits for any of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAny(Task[], Int32, CancellationToken)

Czeka na dowolne z podanych Task obiektów, aby zakończyć wykonywanie w ciągu określonej liczby milisekund lub do czasu anulowania tokenu anulowania.Waits for any of the provided Task objects to complete execution within a specified number of milliseconds or until a cancellation token is cancelled.

WaitAny(Task[], TimeSpan)

Czeka na dowolne z podanych Task obiektów, aby zakończyć wykonywanie w określonym przedziale czasu.Waits for any of the provided Task objects to complete execution within a specified time interval.

WhenAll(IEnumerable<Task>)

Tworzy zadanie, które zostanie ukończone, gdy wszystkie Task obiekty w wyliczalnej kolekcji zostaną zakończone.Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

WhenAll(Task[])

Tworzy zadanie, które zostanie ukończone po Task zakończeniu wszystkich obiektów w tablicy.Creates a task that will complete when all of the Task objects in an array have completed.

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

Tworzy zadanie, które zostanie ukończone, gdy wszystkie Task<TResult> obiekty w wyliczalnej kolekcji zostaną zakończone.Creates a task that will complete when all of the Task<TResult> objects in an enumerable collection have completed.

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

Tworzy zadanie, które zostanie ukończone po Task<TResult> zakończeniu wszystkich obiektów w tablicy.Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

WhenAny(IEnumerable<Task>)

Tworzy zadanie, które zostanie ukończone po zakończeniu dowolnego z podanych zadań.Creates a task that will complete when any of the supplied tasks have completed.

WhenAny(Task, Task)

Tworzy zadanie, które zostanie ukończone po zakończeniu jednego z podanych zadań.Creates a task that will complete when either of the supplied tasks have completed.

WhenAny(Task[])

Tworzy zadanie, które zostanie ukończone po zakończeniu dowolnego z podanych zadań.Creates a task that will complete when any of the supplied tasks have completed.

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

Tworzy zadanie, które zostanie ukończone po zakończeniu dowolnego z podanych zadań.Creates a task that will complete when any of the supplied tasks have completed.

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

Tworzy zadanie, które zostanie ukończone po zakończeniu jednego z podanych zadań.Creates a task that will complete when either of the supplied tasks have completed.

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

Tworzy zadanie, które zostanie ukończone po zakończeniu dowolnego z podanych zadań.Creates a task that will complete when any of the supplied tasks have completed.

Yield()

Tworzy zadanie oczekujące, które asynchronicznie zwraca do bieżącego kontekstu, gdy oczekiwano.Creates an awaitable task that asynchronously yields back to the current context when awaited.

Jawne implementacje interfejsu

IAsyncResult.AsyncWaitHandle

Pobiera WaitHandle , który może być używany do oczekiwania na ukończenie zadania.Gets a WaitHandle that can be used to wait for the task to complete.

IAsyncResult.CompletedSynchronously

Pobiera informację o tym, czy operacja została ukończona synchronicznie.Gets an indication of whether the operation completed synchronously.

Metody rozszerzania

DispatcherOperationWait(Task)

Czeka na zakończenie, aby bazować DispatcherOperation .Waits indefinitely for the underlying DispatcherOperation to complete.

DispatcherOperationWait(Task, TimeSpan)

Czeka na zakończenie określonego czasu DispatcherOperation .Waits for the specified amount of time for the underlying DispatcherOperation to complete.

IsDispatcherOperationTask(Task)

Zwraca wartość wskazującą, czy jest ona Task skojarzona z DispatcherOperation .Returns a value that indicates whether this Task is associated with a DispatcherOperation.

AsAsyncAction(Task)

Zwraca środowisko wykonawcze systemu Windows asynchronicznej akcji, która reprezentuje uruchomione zadanie.Returns a Windows Runtime asynchronous action that represents a started task.

Dotyczy

Bezpieczeństwo wątkowe

Wszystkie elementy członkowskie Task , z wyjątkiem Dispose() , są bezpieczne dla wątków i mogą być używane jednocześnie z wielu wątków.All members of Task, except for Dispose(), are thread-safe and may be used from multiple threads concurrently.

Zobacz też