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

Более полные примеры см. в разделе Task-based асинхронное программирование.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. Так, как следующий пример запускает задачу, которая определяет значение времени ожидания одну секунду, а вызывающий поток блокируется, пока не истечет время ожидания, но бездействует в течение двух секунд и до завершения выполнения задачи.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 / 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

Дополнительные сведения об обработке исключений в асинхронных операций на основе задач, см. в разделе обработка исключений.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.

Примечание

Приложения Store придерживаются среды выполнения 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
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.

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