Task Klasa

Definicja

Reprezentuje operację asynchroniczną.Represents an asynchronous operation.

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

Uwagi

Klasa Task 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. obiekty Task 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 obiekt Task zwykle są wykonywane asynchronicznie w wątku puli wątków zamiast synchronicznie w wątku aplikacji głównej, można użyć właściwości Status, a także właściwości IsCanceled, IsCompletedi 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ć klasy Task<TResult>.For operations that return values, you use the Task<TResult> class.

W tej sekcji:In this section:

Przykłady tworzenia wystąpienia zadania Task instantiation examples
Tworzenie i wykonywanie zadania Creating and executing a task
Rozdzielenie tworzenia zadań i wykonywaniaSeparating task creation and execution
Oczekiwanie na zakończenie co najmniej jednego zadania Waiting for one or more tasks to complete
zadań i kulturyTasks 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ą delegata Action<T> 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 metody Start() tylko po rozpoczęciu t2 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.

  • Utworzono wystąpienie t2 zadania i uruchomiono je w wywołaniu pojedynczej metody przez wywołanie metody TaskFactory.StartNew(Action<Object>, Object).Task t2 is instantiated and started in a single method call by calling the TaskFactory.StartNew(Action<Object>, Object) method.

  • Utworzono wystąpienie t3 zadania i uruchomiono je w wywołaniu pojedynczej metody przez wywołanie metody Run(Action).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 metody RunSynchronously().Task t4 is executed synchronously on the main thread by calling the RunSynchronously() method.

Ponieważ zadanie t4 wykonuje 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

wystąpienia Task 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 od .NET Framework 4.5.NET Framework 4.5, jest wywołanie metody statycznej Run.The most common approach, which is available starting with the .NET Framework 4.5.NET Framework 4.5, is to call the static Run method. Metoda Run 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 metodę Run(Action), aby uruchomić zadanie, które powoduje 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 najbardziej typowa, aby uruchomić zadanie w Program .NET Framework 4.NET Framework 4, jest metodą TaskFactory.StartNew statyczną.An alternative, and the most common method to start a task in Program .NET Framework 4.NET Framework 4, is the static TaskFactory.StartNew method. Właściwość Task.Factory zwraca obiekt TaskFactory.The Task.Factory property returns a TaskFactory object. Przeciążenia metody TaskFactory.StartNew umożliwiają określenie parametrów do przekazania do opcji tworzenia zadań i harmonogramu zadań.Overloads of the TaskFactory.StartNew method let you specify parameters to pass to the task creation options and a task scheduler. W poniższym przykładzie zastosowano metodę TaskFactory.StartNew, aby uruchomić zadanie.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

Klasa Task udostępnia również konstruktory, które inicjują zadanie, ale nie planują wykonywania operacji.The Task class also provides constructors that initialize the task but that do not schedule it for execution. Ze względów wydajności 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ć metodę Task.Start, 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 zakończyć się przed rozpoczęciem wykonywania zadania.In some cases, when the calling thread is the main application thread, the app may terminate before any 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 has completed execution. Można synchronizować wykonywanie wątku wywołującego i wykonywanych przez niego zadań asynchronicznych, wywołując metodę Wait, aby poczekać 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 metodę Task.Wait.To wait for a single task to complete, you can call its Task.Wait method. Wywołanie metody Wait 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ę Wait() bez parametrów, aby czekać 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 metodę Thread.Sleep 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. Metody Wait(Int32) 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 metody Wait(CancellationToken) i Wait(Int32, CancellationToken).You can also supply a cancellation token by calling the Wait(CancellationToken) and Wait(Int32, CancellationToken) methods. Jeśli właściwość IsCancellationRequested tokenu jest true lub zostanie true podczas wykonywania metody Wait, 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ć jeden z przeciążeń metody Task.WaitAny.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żdy uśpienie dla interwału określa generator liczb losowych.The following example creates three tasks, each of which sleeps for an interval determine by a random number generator. Metoda WaitAny(Task[]) czeka na ukoń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 metodę WaitAll.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 kilku zadań wszystkie wyjątki zgłoszone w uruchomionych zadaniach są propagowane w wątku, który wywołuje metodę Wait, 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 wywołaniu metody WaitAll i są obsługiwane przez blok try/catch.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.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.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, które są przeznaczone dla wersji .NET Framework przed .NET Framework 4.6.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.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 temacie CultureInfo.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_taskId pole służy jako magazyn zapasowy dla właściwości Id, jednak 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 (licznik s_taskIdCounter 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 polu m_stateFlags są przechowywane informacje o bieżącym etapie cyklu życia zadania, a także informacje dostępne za pomocą właściwości Status.Similarly, the m_stateFlags field stores information about the current lifecycle stage of the task, information also accessible through the Status property. W polu m_action jest przechowywane odwołanie do delegata zadania, a w polu m_stateObject 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, Metoda InternalWait 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 nowe Task z określoną akcją.Initializes a new Task with the specified action.

Task(Action, CancellationToken)

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

Task(Action, CancellationToken, TaskCreationOptions)

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

Task(Action, TaskCreationOptions)

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

Task(Action<Object>, Object)

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

Task(Action<Object>, Object, CancellationToken)

Inicjuje nowe 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 nowe 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 nowe 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 podczas tworzenia Task 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żywany do tworzenia tego zadania.Gets the TaskCreationOptions used to create this task.

CurrentId

Zwraca identyfikator aktualnie wykonywanej Task.Returns the ID of the currently executing Task.

Exception

Pobiera AggregateException, które spowodowały przedwczesne zakończenie Task.Gets the AggregateException that caused the Task to end prematurely. Jeśli Task zakończyła się pomyślnie lub nie zgłosił jeszcze ż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 wystąpień Task i Task<TResult>.Provides access to factory methods for creating and configuring Task and Task<TResult> instances.

Id

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

IsCanceled

Pobiera czy to wystąpienie Task zostało ukończone 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 zostało wykonane z powodu nieobsługiwanego wyjątku.Gets whether the Task completed due to an unhandled exception.

Status

Pobiera TaskStatus tego zadania.Gets the TaskStatus of this task.

Metody

ConfigureAwait(Boolean)

Konfiguruje obiekt oczekujący używany do oczekiwania na tę 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 zakończeniu Task 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 zakończeniu Task docelowej.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 zakończeniu Task docelowego.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 zakończeniu Task 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 Task docelowej.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 zakończeniu Task docelowej.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 zakończeniu Task docelowej.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 według określonego 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śloną 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 zakończeniu Task docelowej.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 Task docelowej 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 Task docelowej 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 po zakończeniu Task docelowej 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 zakończeniu Task docelowej.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 zakończeniu Task docelowej.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 Task<TResult> docelowej 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 Task docelowej 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 Task docelowej 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 określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
FromCanceled(CancellationToken)

Tworzy Task, która została ukończona 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 Task<TResult>, która została ukończona 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 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>, który został ukończony z określonym wyjątkiem.Creates a Task<TResult> that's completed with a specified exception.

FromResult<TResult>(TResult)

Tworzy 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 używany do oczekiwania na tę 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żącego wystąpienia.Gets the Type of the current instance.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy skróconą kopię bieżącego 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 obiekt Task, 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 obiekt Task, 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.A cancellation token allows the work to be cancelled.

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.

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) zwrócone 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<Task<TResult>>, CancellationToken)

Kolejkuje określoną służbę do uruchomienia w puli wątków i zwraca serwer proxy dla Task(TResult) zwrócone 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 obiekt Task<TResult>, 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.

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

Kolejkuje określoną liczbę zadań do uruchomienia w puli wątków i zwraca obiekt Task(TResult), 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.A cancellation token allows the work to be cancelled.

RunSynchronously()

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

RunSynchronously(TaskScheduler)

Uruchamia Task synchronicznie dla podanego TaskScheduler.Runs the Task synchronously on the TaskScheduler provided.

Start()

Uruchamia Task, planując jego wykonywanie do bieżącego TaskScheduler.Starts the Task, scheduling it for execution to the current TaskScheduler.

Start(TaskScheduler)

Uruchamia Task, planując go pod kątem wykonania do określonego TaskScheduler.Starts the Task, scheduling it for execution to the specified TaskScheduler.

ToString()

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)
Wait()

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

Wait(CancellationToken)

Czeka na zakończenie wykonywania Task.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 zakończenie wykonywania przez Task 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 zakończenie wykonywania Task.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 zakończenie wykonywania Task w określonym przedziale czasu.Waits for the Task to complete execution within a specified time interval.

WaitAll(Task[])

Czeka na wszystkie podane Task obiektów, aby ukończyć wykonywanie.Waits for all of the provided Task objects to complete execution.

WaitAll(Task[], CancellationToken)

Czeka na wszystkie podane Task obiektów do zakończenia wykonywania, 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 Task obiektów, 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 Task obiektów, aby zakoń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 dostarczone Task obiektów 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 zakoń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 obiekty Task 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 zakończeniu wszystkich Task 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 obiekty Task<TResult> 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 zakończeniu wszystkich Task<TResult> 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[])

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>[])

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órych można użyć, aby poczekać 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 DispatcherOperationz.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 z wielu wątków jednocześnie.All members of Task, except for Dispose(), are thread-safe and may be used from multiple threads concurrently.

Zobacz też