Task Task Task Task Class

Определение

Представляет асинхронную операцию.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
Наследование
TaskTaskTaskTask
Производный
Реализации

Комментарии

Класс Task представляет отдельную операцию, которая не возвращает значение и обычно выполняется асинхронно.The Task class represents a single operation that does not return a value and that usually executes asynchronously. объекты Task являются одним из центральных компонентов асинхронной модели на основе задач , которые впервые появились в .NET Framework 4.Task objects are one of the central components of the task-based asynchronous pattern first introduced in the .NET Framework 4. Так как работа, выполняемая объектом Task, обычно выполняется асинхронно в потоке пула потоков, а не синхронно в основном потоке приложения, можно использовать свойство Status, а также свойства IsCanceled, IsCompleted и IsFaulted, чтобы Определение состояния задачи.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. Чаще всего лямбда-выражение используется для указания работы, которую должна выполнить задача.Most commonly, a lambda expression is used to specify the work that the task is to perform.

Для операций, возвращающих значения, используется класс Task<TResult>.For operations that return values, you use the Task<TResult> class.

СодержаниеIn this section:

Примеры создания экземпляра задачи Task instantiation examples
Создание и исполнение задачи Creating and executing a task
Отделение создания и выполнения задач Separating task creation and execution
Ожидание завершения одной или нескольких задач Waiting for one or more tasks to complete
Задачи и культура Tasks and culture
Для разработчиков отладчикаFor debugger developers

Создание экземпляра задачиTask instantiation

В следующем примере создаются и выполняются четыре задачи.The following example creates and executes four tasks. Три задачи выполняют делегат Action<T> с именем action, который принимает аргумент типа Object.Three tasks execute an Action<T> delegate named action, which accepts an argument of type Object. Четвертая задача выполняет лямбда-выражение (делегат Action), которое определяется встроенным в вызове метода создания задачи.A fourth task executes a lambda expression (an Action delegate) that is defined inline in the call to the task creation method. Каждая задача создается и выполняется по-разному:Each task is instantiated and run in a different way:

  • Задача t1 создается путем вызова конструктора класса задачи, но запускается с помощью вызова метода Start() только после запуска задачи t2.Task t1 is instantiated by calling a Task class constructor, but is started by calling its Start() method only after task t2 has started.

  • Задача t2 создается и запускается в одном вызове метода путем вызова метода 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.

  • Задача t3 создается и запускается в одном вызове метода путем вызова метода Run(Action).Task t3 is instantiated and started in a single method call by calling the Run(Action) method.

  • Задача t4 выполняется синхронно в основном потоке путем вызова метода RunSynchronously().Task t4 is executed synchronously on the main thread by calling the RunSynchronously() method.

Так как задача t4 выполняется синхронно, она выполняется в основном потоке приложения.Because task t4 executes synchronously, it executes on the main application thread. Оставшиеся задачи обычно выполняются асинхронно в одном или нескольких потоках пула потоков.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

Создание и исполнение задачиCreating and executing a task

экземпляры Task могут создаваться различными способами.Task instances may be created in a variety of ways. Наиболее распространенным подходом, который доступен, начиная с .NET Framework 4.5.NET Framework 4.5, является вызов статического метода 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. Метод Run предоставляет простой способ запуска задачи с использованием значений по умолчанию и не требует дополнительных параметров.The Run method provides a simple way to start a task using default values and without requiring additional parameters. В следующем примере используется метод Run(Action) для запуска задачи, которая циклически выполняет цикл, а затем отображает число итераций цикла: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

Альтернативой и наиболее распространенным способом запуска задачи в .NET Framework 4.NET Framework 4 является статический метод TaskFactory.StartNew.An alternative, and the most common method to start a task in .NET Framework 4.NET Framework 4, is the static TaskFactory.StartNew method. Свойство Task.Factory возвращает объект TaskFactory.The Task.Factory property returns a TaskFactory object. Перегрузки метода TaskFactory.StartNew позволяют указать параметры для передачи параметров создания задач и планировщика заданий.Overloads of the TaskFactory.StartNew method let you specify parameters to pass to the task creation options and a task scheduler. В следующем примере используется метод TaskFactory.StartNew для запуска задачи.The following example uses the TaskFactory.StartNew method to start a task. Он функционально эквивалентен коду в предыдущем примере.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

Более полные примеры см. в разделе Асинхронное программирование на основе задач.For more complete examples, see Task-based Asynchronous Programming.

Отделение создания и выполнения задачSeparating task creation and execution

Класс Task также предоставляет конструкторы, которые инициализируют задачу, но не запланируют ее выполнение.The Task class also provides constructors that initialize the task but that do not schedule it for execution. Для повышения производительности метод Task.Run или TaskFactory.StartNew является предпочтительным механизмом для создания и планирования вычислительных задач, но в сценариях, где создание и планирование должны быть разделены, можно использовать конструкторы, а затем вызвать метод Task.Start. чтобы запланировать выполнение задачи в более позднее время.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.

Ожидание завершения одной или нескольких задачWaiting for one or more tasks to complete

Так как задачи обычно выполняются асинхронно в потоке пула потоков, поток, создающий и запускающий задачу, возобновляет выполнение сразу после создания экземпляра задачи.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. В некоторых случаях, когда вызывающий поток является основным потоком приложения, приложение может завершиться до того, как начнется выполнение любой задачи.In some cases, when the calling thread is the main application thread, the app may terminate before any the task actually begins execution. В других случаях логика приложения может потребовать, чтобы вызывающий поток продолжал выполнение, только когда одна или несколько задач завершили выполнение.In others, your application's logic may require that the calling thread continue execution only when one or more tasks has completed execution. Вы можете синхронизировать выполнение вызывающего потока и асинхронных задач, которые он запускает, вызвав метод Wait, чтобы дождаться завершения одной или нескольких задач.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.

Чтобы дождаться завершения одной задачи, можно вызвать ее метод Task.Wait.To wait for a single task to complete, you can call its Task.Wait method. Вызов метода Wait блокирует вызывающий поток до завершения выполнения одного экземпляра класса.A call to the Wait method blocks the calling thread until the single class instance has completed execution.

В следующем примере вызывается метод без параметров Wait() для бесусловного ожидания до завершения задачи.The following example calls the parameterless Wait() method to wait unconditionally until a task completes. Задача имитирует работу, вызывая метод Thread.Sleep в спящий режим в течение двух секунд.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

Можно также условно ожидать завершения задачи.You can also conditionally wait for a task to complete. Методы Wait(Int32) и Wait(TimeSpan) блокируют вызывающий поток до тех пор, пока задача не завершится или не истечет интервал времени ожидания (в зависимости от того, какое из них происходит раньше)The Wait(Int32) and Wait(TimeSpan) methods block the calling thread until the task finishes or a timeout interval elapses, whichever comes first. Поскольку в следующем примере запускается задача, которая закладывается на две секунды, но определяет значение времени ожидания, равное 1 секунде, вызывающий поток блокируется до тех пор, пока не истечет время ожидания и до завершения выполнения задачи.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.

Можно также предоставить токен отмены, вызвав методы Wait(CancellationToken) и Wait(Int32, CancellationToken).You can also supply a cancellation token by calling the Wait(CancellationToken) and Wait(Int32, CancellationToken) methods. Если свойство IsCancellationRequested токена имеет значение true или преобразуется в true во время выполнения метода Wait, метод создает исключение OperationCanceledException.If the token's IsCancellationRequested property is true or becomes true while the Wait method is executing, the method throws an OperationCanceledException.

В некоторых случаях может потребоваться дождаться завершения первого ряда выполняемых задач, но не важно, какая задача она имеет.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. Для этой цели можно вызвать одну из перегрузок метода Task.WaitAny.For this purpose, you can call one of the overloads of the Task.WaitAny method. В следующем примере создаются три задачи, каждая из которых находится в режиме ожидания для интервала, определенного генератором случайных чисел.The following example creates three tasks, each of which sleeps for an interval determine by a random number generator. Метод WaitAny(Task[]) ожидает завершения первой задачи.The WaitAny(Task[]) method waits for the first task to complete. Затем в примере отображаются сведения о состоянии всех трех задач.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

Можно также дождаться завершения всех задач, вызвав метод WaitAll.You can also wait for all of a series of tasks to complete by calling the WaitAll method. В следующем примере создается десять задач, ожидается завершение всех десяти операций, а затем отображается их состояние.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

Обратите внимание, что при ожидании выполнения одной или нескольких задач все исключения, возникшие в выполняющихся задачах, распространяются в поток, который вызывает метод Wait, как показано в следующем примере.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. Он запускает 12 задач, три из которых обычно и три из которых вызывают исключение.It launches 12 tasks, three of which complete normally and three of which throw an exception. Из оставшихся шести задач три отменяются до начала, а три — во время выполнения.Of the remaining six tasks, three are cancelled before they start, and three are cancelled while they are executing. Исключения вызываются в вызове метода WaitAll и обрабатываются блоком try @ no__t-2 @ no__t-3.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

Дополнительные сведения об обработке исключений в асинхронных операциях на основе задач см. в разделе обработка исключений.For more information on exception handling in task-based asynchronous operations, see Exception Handling.

Задачи и культураTasks and culture

Начиная с классических приложений, предназначенных для .NET Framework 4.6.NET Framework 4.6, язык и региональные параметры потока, который создает и вызывает задачу, становятся частью контекста потока.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. То есть вне зависимости от текущего языка и региональных параметров потока, в котором выполняется задача, текущим языком и региональными параметрами задачи является культура вызывающего потока.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. Для приложений, предназначенных для версий .NET Framework до .NET Framework 4.6.NET Framework 4.6, язык и региональные параметры задачи являются культурой потока, в котором выполняется задача.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. Дополнительные сведения см. в разделе "Культура и асинхронные операции на основе задач" статьи CultureInfo.For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic.

Примечание

Приложения Магазина следуют среда выполнения Windows в настройке и получении языка и региональных параметров по умолчанию.Store apps follow the Windows Runtime in setting and getting the default culture.

Для разработчиков отладчикаFor debugger developers

Для разработчиков, реализующих пользовательские отладчики, может быть полезным несколько внутренних и закрытых членов задачи (они могут изменяться от выпуска к выпуску).For developers implementing custom debuggers, several internal and private members of task may be useful (these may change from release to release). Поле m_taskId служит резервным хранилищем для свойства Id, однако доступ к этому полю напрямую из отладчика может оказаться более эффективным, чем доступ к тому же значению с помощью метода считывания свойства (счетчик s_taskIdCounter используется для получения следующего доступный идентификатор задачи).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). Аналогичным образом в поле m_stateFlags хранятся сведения о текущем этапе жизненного цикла задачи, а также сведения, доступные через свойство Status.Similarly, the m_stateFlags field stores information about the current lifecycle stage of the task, information also accessible through the Status property. В поле m_action хранится ссылка на делегат задачи, а в поле m_stateObject хранится асинхронное состояние, передаваемое задаче разработчиком.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. Наконец, для отладчиков, которые анализируют кадры стека, метод InternalWait выполняет потенциальный маркер, когда задача вводит операцию ожидания.Finally, for debuggers that parse stack frames, the InternalWait method serves a potential marker for when a task is entering a wait operation.

Конструкторы

Task(Action) Task(Action) Task(Action) Task(Action)

Инициализирует новую задачу Task с заданным действием.Initializes a new Task with the specified action.

Task(Action, CancellationToken) Task(Action, CancellationToken) Task(Action, CancellationToken) Task(Action, CancellationToken)

Инициализирует новую задачу Task с заданным действием и токеном CancellationToken.Initializes a new Task with the specified action and CancellationToken.

Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions)

Инициализирует новую задачу Task с заданными действием и параметрами создания.Initializes a new Task with the specified action and creation options.

Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions)

Инициализирует новую задачу Task с заданными действием и параметрами создания.Initializes a new Task with the specified action and creation options.

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

Инициализирует новую задачу Task с заданным действием и состоянием.Initializes a new Task with the specified action and state.

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

Инициализирует новую задачу Task с заданными действием, состоянием и параметрами.Initializes a new Task with the specified action, state, and options.

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

Инициализирует новую задачу Task с заданными действием, состоянием и параметрами.Initializes a new Task with the specified action, state, and options.

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

Инициализирует новую задачу Task с заданными действием, состоянием и параметрами.Initializes a new Task with the specified action, state, and options.

Свойства

AsyncState AsyncState AsyncState AsyncState

Получает объект состояния, предоставленный при создании задачи Task, или значение null, если объект не предоставлен.Gets the state object supplied when the Task was created, or null if none was supplied.

CompletedTask CompletedTask CompletedTask CompletedTask

Возвращает задачу, которая уже завершилась успешно.Gets a task that has already completed successfully.

CreationOptions CreationOptions CreationOptions CreationOptions

Возвращает объект TaskCreationOptions, используемый для создания данной задачи.Gets the TaskCreationOptions used to create this task.

CurrentId CurrentId CurrentId CurrentId

Возвращает идентификатор выполняющейся в настоящее время задачи Task.Returns the ID of the currently executing Task.

Exception Exception Exception Exception

Возвращает объект AggregateException, который привел к преждевременному завершению задачи Task.Gets the AggregateException that caused the Task to end prematurely. Если задача Task завершилась успешно или еще не создала ни одного исключения, возвращает значение null.If the Task completed successfully or has not yet thrown any exceptions, this will return null.

Factory Factory Factory Factory

Предоставляет доступ к фабричным методам для создания и настройки экземпляров Task и Task<TResult>.Provides access to factory methods for creating and configuring Task and Task<TResult> instances.

Id Id Id Id

Возвращает идентификатор указанного экземпляра Task.Gets an ID for this Task instance.

IsCanceled IsCanceled IsCanceled IsCanceled

Возвращает значение, указывающее, завершилось ли выполнение данного экземпляра Task из-за отмены.Gets whether this Task instance has completed execution due to being canceled.

IsCompleted IsCompleted IsCompleted IsCompleted

Получает значение, указывающее, завершена ли задача.Gets a value that indicates whether the task has completed.

IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully

Возвращает значение, указывающее, выполнена ли задача.Gets whether the task ran to completion.

IsFaulted IsFaulted IsFaulted IsFaulted

Возвращает значение, указывающее, завершилась ли задача Task из-за необработанного исключения.Gets whether the Task completed due to an unhandled exception.

Status Status Status Status

Получает состояние TaskStatus данной задачи.Gets the TaskStatus of this task.

Методы

ConfigureAwait(Boolean) ConfigureAwait(Boolean) ConfigureAwait(Boolean) ConfigureAwait(Boolean)

Настраивает объект типа awaiter, используемый для данного объекта Task.Configures an awaiter used to await this Task.

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

Создает продолжение, которое получает предоставленные вызывающей стороной сведения о состоянии и которое выполняется после завершения целевой задачи Task.Creates a continuation that receives caller-supplied state information and executes when the target Task completes.

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

Создает продолжение, которое получает предоставленные вызывающей стороной сведения о состоянии и маркер отмены и которое выполняется асинхронно после завершения целевой задачи Task.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) ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Создает продолжение, которое получает предоставленные вызывающей стороной сведения о состоянии и маркер отмены и которое выполняется после завершения целевой задачи Task.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes when the target Task completes. Продолжение выполняется на основе набора указанных условий и использует указанный планировщик.The continuation executes based on a set of specified conditions and uses a specified scheduler.

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

Создает продолжение, которое получает предоставленные вызывающей стороной сведения о состоянии и которое выполняется после завершения целевой задачи Task.Creates a continuation that receives caller-supplied state information and executes when the target Task completes. Продолжение выполняется на основе набора указанных условий.The continuation executes based on a set of specified conditions.

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

Создает продолжение, которое получает предоставленные вызывающей стороной сведения о состоянии и выполняется асинхронно после завершения целевой задачи Task.Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. Продолжение использует указанный планировщик.The continuation uses a specified scheduler.

ContinueWith(Action<Task>) ContinueWith(Action<Task>) ContinueWith(Action<Task>) ContinueWith(Action<Task>)

Создает продолжение, которое выполняется асинхронно после завершения выполнения целевой задачи Task.Creates a continuation that executes asynchronously when the target Task completes.

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

Создает продолжение, которое получает маркер отмены и которое выполняется асинхронно после завершения целевой задачи Task.Creates a continuation that receives a cancellation token and executes asynchronously when the target Task completes.

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

Создает продолжение, которое выполняется после завершения целевой задачи в соответствии с заданными параметрами TaskContinuationOptions.Creates a continuation that executes when the target task competes according to the specified TaskContinuationOptions. Продолжение получает маркер отмены и использует указанный планировщик.The continuation receives a cancellation token and uses a specified scheduler.

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

Создает продолжение, которое выполняется после завершения целевой задачи в соответствии с заданными параметрами TaskContinuationOptions.Creates a continuation that executes when the target task completes according to the specified TaskContinuationOptions.

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

Создает продолжение, которое выполняется асинхронно после завершения выполнения целевой задачи Task.Creates a continuation that executes asynchronously when the target Task completes. Продолжение использует указанный планировщик.The continuation uses a specified scheduler.

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

Создает продолжение, которое получает предоставленные вызывающей стороной сведения о состоянии, выполняется асинхронно после завершения целевой задачи Task и возвращает значение.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) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)

Создает продолжение, которое выполняется асинхронно после завершения целевой задачи Task и возвращает значение.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Продолжение получает предоставленные вызывающей стороной сведения и маркер отмены.The continuation receives caller-supplied state information and a cancellation token.

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

Создает продолжение, которое выполняется на основе указанных параметров продолжения задачи после завершения целевой задачи Task и которое возвращает значение.Creates a continuation that executes based on the specified task continuation options when the target Task completes and returns a value. Продолжение получает предоставленные вызывающей стороной сведения и маркер отмены, а также использует указанный планировщик.The continuation receives caller-supplied state information and a cancellation token and uses the specified scheduler.

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

Создает продолжение, которое выполняется на основе указанных параметров продолжения задачи после завершения целевой задачи Task.Creates a continuation that executes based on the specified task continuation options when the target Task completes. Продолжение получает предоставленные вызывающей стороной сведения.The continuation receives caller-supplied state information.

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

Создает продолжение, которое выполняется асинхронно после завершения выполнения целевой задачи Task.Creates a continuation that executes asynchronously when the target Task completes. Продолжение получает предоставленные вызывающей стороной сведения и использует указанный планировщик.The continuation receives caller-supplied state information and uses a specified scheduler.

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

Создает продолжение, которое выполняется асинхронно после завершения целевой задачи Task<TResult> и которое возвращает значение.Creates a continuation that executes asynchronously when the target Task<TResult> completes and returns a value.

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

Создает продолжение, которое выполняется асинхронно после завершения целевой задачи Task и возвращает значение.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Продолжение получает маркер отмены.The continuation receives a cancellation token.

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

Создает продолжение, которое выполняется в соответствии с заданными параметрами и которое возвращает значение.Creates a continuation that executes according to the specified continuation options and returns a value. Продолжение получает маркер отмены и использует указанный планировщик.The continuation is passed a cancellation token and uses a specified scheduler.

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

Создает продолжение, которое выполняется в соответствии с заданными параметрами и которое возвращает значение.Creates a continuation that executes according to the specified continuation options and returns a value.

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

Создает продолжение, которое выполняется асинхронно после завершения целевой задачи Task и возвращает значение.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Продолжение использует указанный планировщик.The continuation uses a specified scheduler.

Delay(Int32) Delay(Int32) Delay(Int32) Delay(Int32)

Создает задачу, которая завершается через заданное количество миллисекунд.Creates a task that completes after a specified number of milliseconds.

Delay(Int32, CancellationToken) Delay(Int32, CancellationToken) Delay(Int32, CancellationToken) Delay(Int32, CancellationToken)

Создает отменяемую задачу, которая завершается через заданное количество миллисекунд.Creates a cancellable task that completes after a specified number of milliseconds.

Delay(TimeSpan) Delay(TimeSpan) Delay(TimeSpan) Delay(TimeSpan)

Создает задачу, которая завершается через заданное время.Creates a task that completes after a specified time interval.

Delay(TimeSpan, CancellationToken) Delay(TimeSpan, CancellationToken) Delay(TimeSpan, CancellationToken) Delay(TimeSpan, CancellationToken)

Создает отменяемую задачу, которая завершается через заданное время.Creates a cancellable task that completes after a specified time interval.

Dispose() Dispose() Dispose() Dispose()

Освобождает все ресурсы, используемые текущим экземпляром класса Task.Releases all resources used by the current instance of the Task class.

Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Удаляет задачуTask, освобождая все используемые ею неуправляемые ресурсы.Disposes the Task, releasing all of its unmanaged resources.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Определяет, равен ли заданный объект текущему объекту.Determines whether the specified object is equal to the current object.

(Inherited from Object)
FromCanceled(CancellationToken) FromCanceled(CancellationToken) FromCanceled(CancellationToken) FromCanceled(CancellationToken)

Создает задачу Task, которая завершилась из-за отмены с помощью указанного маркера отмены.Creates a Task that's completed due to cancellation with a specified cancellation token.

FromCanceled<TResult>(CancellationToken) FromCanceled<TResult>(CancellationToken) FromCanceled<TResult>(CancellationToken) FromCanceled<TResult>(CancellationToken)

Создает задачу Task<TResult>, которая завершилась из-за отмены с помощью указанного маркера отмены.Creates a Task<TResult> that's completed due to cancellation with a specified cancellation token.

FromException(Exception) FromException(Exception) FromException(Exception) FromException(Exception)

Создает задачу Task, которая завершилась с указанным исключением.Creates a Task that has completed with a specified exception.

FromException<TResult>(Exception) FromException<TResult>(Exception) FromException<TResult>(Exception) FromException<TResult>(Exception)

Создает задачу Task<TResult>, которая завершилась с указанным исключением.Creates a Task<TResult> that's completed with a specified exception.

FromResult<TResult>(TResult) FromResult<TResult>(TResult) FromResult<TResult>(TResult) FromResult<TResult>(TResult)

Создает Task<TResult>, которая завершается удачно с указанным результатом.Creates a Task<TResult> that's completed successfully with the specified result.

GetAwaiter() GetAwaiter() GetAwaiter() GetAwaiter()

Получает объект типа awaiter, используемый для данного объекта Task.Gets an awaiter used to await this Task.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Служит хэш-функцией по умолчанию.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Возвращает объект Type для текущего экземпляра.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Создает неполную копию текущего объекта Object.Creates a shallow copy of the current Object.

(Inherited from Object)
Run(Action) Run(Action) Run(Action) Run(Action)

Ставит в очередь заданную работу для запуска в пуле потоков и возвращает объект Task, представляющий эту работу.Queues the specified work to run on the thread pool and returns a Task object that represents that work.

Run(Action, CancellationToken) Run(Action, CancellationToken) Run(Action, CancellationToken) Run(Action, CancellationToken)

Ставит в очередь заданную работу для запуска в пуле потоков и возвращает объект Task, представляющий эту работу.Queues the specified work to run on the thread pool and returns a Task object that represents that work. Маркер отмены позволяет отменить работу.A cancellation token allows the work to be cancelled.

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

Ставит в очередь указанную работу для запуска в пуле потоков и возвращает прокси для задачи, возвращаемой функцией 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) Run(Func<Task>, CancellationToken) Run(Func<Task>, CancellationToken) Run(Func<Task>, CancellationToken)

Ставит в очередь указанную работу для запуска в пуле потоков и возвращает прокси для задачи, возвращаемой функцией 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>>) Run<TResult>(Func<Task<TResult>>) Run<TResult>(Func<Task<TResult>>) Run<TResult>(Func<Task<TResult>>)

Ставит в очередь заданную работу для запуска в пуле потоков и возвращает прокси для задачи Task(TResult), возвращаемой 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) Run<TResult>(Func<Task<TResult>>, CancellationToken) Run<TResult>(Func<Task<TResult>>, CancellationToken) Run<TResult>(Func<Task<TResult>>, CancellationToken)

Ставит в очередь заданную работу для запуска в пуле потоков и возвращает прокси для задачи Task(TResult), возвращаемой 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>) Run<TResult>(Func<TResult>) Run<TResult>(Func<TResult>) Run<TResult>(Func<TResult>)

Ставит в очередь заданную работу для запуска в пуле потоков и возвращает объект Task<TResult>, представляющий эту работу.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) Run<TResult>(Func<TResult>, CancellationToken) Run<TResult>(Func<TResult>, CancellationToken) Run<TResult>(Func<TResult>, CancellationToken)

Ставит в очередь заданную работу для запуска в пуле потоков и возвращает объект Task(TResult), представляющий эту работу.Queues the specified work to run on the thread pool and returns a Task(TResult) object that represents that work. Маркер отмены позволяет отменить работу.A cancellation token allows the work to be cancelled.

RunSynchronously() RunSynchronously() RunSynchronously() RunSynchronously()

Синхронно выполняет задачу Task в текущем планировщике TaskScheduler.Runs the Task synchronously on the current TaskScheduler.

RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler)

Синхронно выполняет задачу Task в предоставленном планировщике TaskScheduler.Runs the Task synchronously on the TaskScheduler provided.

Start() Start() Start() Start()

Запускает задачу Task, планируя ее выполнение в текущем планировщике TaskScheduler.Starts the Task, scheduling it for execution to the current TaskScheduler.

Start(TaskScheduler) Start(TaskScheduler) Start(TaskScheduler) Start(TaskScheduler)

Запускает задачу Task, планируя ее выполнение в заданном планировщике TaskScheduler.Starts the Task, scheduling it for execution to the specified TaskScheduler.

ToString() ToString() ToString() ToString()

Возвращает строку, представляющую текущий объект.Returns a string that represents the current object.

(Inherited from Object)
Wait() Wait() Wait() Wait()

Ожидает завершения выполнения задачи Task.Waits for the Task to complete execution.

Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken)

Ожидает завершения выполнения задачи Task.Waits for the Task to complete execution. Ожидание завершается, если токен отмены отменяется до завершения задачи.The wait terminates if a cancellation token is canceled before the task completes.

Wait(Int32) Wait(Int32) Wait(Int32) Wait(Int32)

Ожидает завершения задачи Task в течение указанного числа миллисекунд.Waits for the Task to complete execution within a specified number of milliseconds.

Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken)

Ожидает завершения выполнения задачи Task.Waits for the Task to complete execution. Ожидание завершается, если время ожидания истекает или токен отмены отменяется до завершения задачи.The wait terminates if a timeout interval elapses or a cancellation token is canceled before the task completes.

Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan)

Ожидает завершения выполнения задач Task в течение указанного временного периода.Waits for the Task to complete execution within a specified time interval.

WaitAll(Task[]) WaitAll(Task[]) WaitAll(Task[]) WaitAll(Task[])

Ожидает завершения выполнения всех указанных объектов Task.Waits for all of the provided Task objects to complete execution.

WaitAll(Task[], CancellationToken) WaitAll(Task[], CancellationToken) WaitAll(Task[], CancellationToken) WaitAll(Task[], CancellationToken)

Ожидает завершения выполнения всех указанных объектов Task, пока ожидание не будет отменено.Waits for all of the provided Task objects to complete execution unless the wait is cancelled.

WaitAll(Task[], Int32) WaitAll(Task[], Int32) WaitAll(Task[], Int32) WaitAll(Task[], Int32)

Ожидает завершения выполнения всех указанных объектов Task в течение указанного числа миллисекунд.Waits for all of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAll(Task[], Int32, CancellationToken) WaitAll(Task[], Int32, CancellationToken) WaitAll(Task[], Int32, CancellationToken) WaitAll(Task[], Int32, CancellationToken)

Ожидает завершения выполнения всех указанных объектов Task в течение указанного числа миллисекунд или до отмены ожидания.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) WaitAll(Task[], TimeSpan) WaitAll(Task[], TimeSpan) WaitAll(Task[], TimeSpan)

Ожидает завершения выполнения всех указанных отменяемых объектов Task в течение указанного временного интервала.Waits for all of the provided cancellable Task objects to complete execution within a specified time interval.

WaitAny(Task[]) WaitAny(Task[]) WaitAny(Task[]) WaitAny(Task[])

Ожидает завершения выполнения любого из указанных объектов Task.Waits for any of the provided Task objects to complete execution.

WaitAny(Task[], CancellationToken) WaitAny(Task[], CancellationToken) WaitAny(Task[], CancellationToken) WaitAny(Task[], CancellationToken)

Ожидает завершения выполнения всех указанных объектов Task, пока ожидание не будет отменено.Waits for any of the provided Task objects to complete execution unless the wait is cancelled.

WaitAny(Task[], Int32) WaitAny(Task[], Int32) WaitAny(Task[], Int32) WaitAny(Task[], Int32)

Ожидает завершения выполнения любого из указанных объектов Task в течение указанного числа миллисекунд.Waits for any of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAny(Task[], Int32, CancellationToken) WaitAny(Task[], Int32, CancellationToken) WaitAny(Task[], Int32, CancellationToken) WaitAny(Task[], Int32, CancellationToken)

Ожидает завершения выполнения всех указанных объектов Task в течение указанного числа миллисекунд или до отмены токена отмены.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) WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan)

Ожидает завершения выполнения любого из указанных отменяемых объектов Task в течение указанного временного интервала.Waits for any of the provided Task objects to complete execution within a specified time interval.

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

Создает задачу, которая будет выполнена, когда все объекты Task в перечисляемой коллекции будут завершены.Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[])

Создает задачу, которая будет выполнена, когда все Task объекты в массиве будут завершены.Creates a task that will complete when all of the Task objects in an array have completed.

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

Создает задачу, которая будет выполнена, когда все объекты Task<TResult> в перечисляемой коллекции будут завершены.Creates a task that will complete when all of the Task<TResult> objects in an enumerable collection have completed.

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

Создает задачу, которая будет выполнена, когда все Task<TResult> объекты в массиве будут завершены.Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

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

Создает задачу, которая будет выполнена после выполнения любой из предоставленных задач.Creates a task that will complete when any of the supplied tasks have completed.

WhenAny(Task[]) WhenAny(Task[]) WhenAny(Task[]) WhenAny(Task[])

Создает задачу, которая будет выполнена после выполнения любой из предоставленных задач.Creates a task that will complete when any of the supplied tasks have completed.

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

Создает задачу, которая будет выполнена после выполнения любой из предоставленных задач.Creates a task that will complete when any of the supplied tasks have completed.

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

Создает задачу, которая будет выполнена после выполнения любой из предоставленных задач.Creates a task that will complete when any of the supplied tasks have completed.

Yield() Yield() Yield() Yield()

Создает поддерживающий ожидание объект задачи, который асинхронным образом выдает возврат текущему контексту, когда его ожидают.Creates an awaitable task that asynchronously yields back to the current context when awaited.

Явные реализации интерфейса

IAsyncResult.AsyncWaitHandle IAsyncResult.AsyncWaitHandle IAsyncResult.AsyncWaitHandle IAsyncResult.AsyncWaitHandle

Возвращает дескриптор WaitHandle, который можно использовать для ожидания завершения задачи.Gets a WaitHandle that can be used to wait for the task to complete.

IAsyncResult.CompletedSynchronously IAsyncResult.CompletedSynchronously IAsyncResult.CompletedSynchronously IAsyncResult.CompletedSynchronously

Получает значение, указывающее, синхронно ли выполнена операция.Gets an indication of whether the operation completed synchronously.

Методы расширения

DispatcherOperationWait(Task) DispatcherOperationWait(Task) DispatcherOperationWait(Task) DispatcherOperationWait(Task)

Ожидает завершения базовой операции DispatcherOperation в течение неограниченного времени.Waits indefinitely for the underlying DispatcherOperation to complete.

DispatcherOperationWait(Task, TimeSpan) DispatcherOperationWait(Task, TimeSpan) DispatcherOperationWait(Task, TimeSpan) DispatcherOperationWait(Task, TimeSpan)

Ожидает истечения заданного количества времени для базового DispatcherOperation.Waits for the specified amount of time for the underlying DispatcherOperation to complete.

IsDispatcherOperationTask(Task) IsDispatcherOperationTask(Task) IsDispatcherOperationTask(Task) IsDispatcherOperationTask(Task)

Возвращает значение, указывающее, связан ли данный Task с DispatcherOperation.Returns a value that indicates whether this Task is associated with a DispatcherOperation.

AsAsyncAction(Task) AsAsyncAction(Task) AsAsyncAction(Task) AsAsyncAction(Task)

Возвращает асинхронное действие среды выполнения Windows, представляющее запущенную задачу.Returns a Windows Runtime asynchronous action that represents a started task.

Применяется к

Потокобезопасность

Все члены Task, за исключением Dispose(), являются потокобезопасными и могут использоваться из нескольких потоков одновременно.All members of Task, except for Dispose(), are thread-safe and may be used from multiple threads concurrently.

Дополнительно