Task クラス

定義

非同期操作を表します。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
継承
Task
派生
実装

注釈

Task クラスは、値を返さず、通常は非同期的に実行する1つの操作を表します。The Task class represents a single operation that does not return a value and that usually executes asynchronously. Task オブジェクトは、.NET Framework 4 で最初に導入されたタスクベースの非同期パターンの中心的なコンポーネントの1つです。Task objects are one of the central components of the task-based asynchronous pattern first introduced in the .NET Framework 4. Task オブジェクトによって実行される作業は通常、メインアプリケーションスレッド上で同期的に実行されるのではなく、スレッドプールのスレッドで非同期的に実行されるため、Status プロパティ、IsCanceledIsCompleted、および 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
1 つ以上のタスクが完了するのを待機してWaiting for one or more tasks to complete
タスクとカルチャの Tasks and culture
デバッガー開発者向けFor debugger developers

タスクのインスタンス化Task instantiation

次の例では、4つのタスクを作成して実行します。The following example creates and executes four tasks. 3つのタスクは、型 Objectの引数を受け取る actionという名前の Action<T> デリゲートを実行します。Three tasks execute an Action<T> delegate named action, which accepts an argument of type Object. 4番目のタスクは、タスク作成メソッドの呼び出しでインラインで定義されているラムダ式 (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 はタスククラスコンストラクターを呼び出すことによってインスタンス化されますが、タスク t2 が開始された後にのみ、Start() メソッドを呼び出すことによって開始されます。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) メソッドを呼び出すことによってインスタンス化され、1回のメソッド呼び出しで開始されます。Task t2 is instantiated and started in a single method call by calling the TaskFactory.StartNew(Action<Object>, Object) method.

  • タスク t3 は、Run(Action) メソッドを呼び出すことによってインスタンス化され、1回のメソッド呼び出しで開始されます。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. 残りのタスクは、通常、1つ以上のスレッドプールのスレッドで非同期的に実行されます。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.

1つ以上のタスクが完了するのを待機しています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. それ以外の場合、アプリケーションのロジックでは、1つ以上のタスクが実行を完了したときにのみ、呼び出し元のスレッドが実行を継続することが必要になる場合があります。In others, your application's logic may require that the calling thread continue execution only when one or more tasks has completed execution. 1つ以上のタスクが完了するのを待機するために 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.

1つのタスクが完了するまで待機するには、その 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 メソッドを呼び出して2秒間スリープ状態にすることで、作業をシミュレートします。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. 次の例では、2秒間スリープするタスクを起動しますが、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. Wait メソッドの実行中にトークンの IsCancellationRequested プロパティが true または true になると、メソッドは 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 メソッドのオーバーロードの1つを呼び出すことができます。For this purpose, you can call one of the overloads of the Task.WaitAny method. 次の例では、3つのタスクを作成します。各タスクは、ランダムな数値ジェネレーターによって決定された間隔でスリープします。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. この例では、3つのタスクすべての状態に関する情報が表示されます。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. 次の例では、10個のタスクを作成し、すべての10が完了するまで待機して、その状態を表示します。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

1つ以上のタスクが完了するまで待機すると、次の例に示すように、実行中のタスクでスローされた例外は、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個のタスクが起動され、そのうち3つは正常に完了し、そのうち3つは例外をスローします。It launches 12 tasks, three of which complete normally and three of which throw an exception. 残りの6つのタスクのうち、3つは開始前にキャンセルされ、3つは実行中にキャンセルされます。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 4.6.NET Framework 4.6前に .NET Framework のバージョンを対象とするアプリの場合、タスクのカルチャは、タスクが実行されるスレッドのカルチャになります。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 プロパティのバッキングストアとして機能しますが、デバッガーから直接このフィールドにアクセスする方が、プロパティの getter メソッドを使用して同じ値にアクセスするよりも効率的な場合があります (s_taskIdCounter カウンターを使用して、タスクで使用可能な次の ID。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 を初期化します。Initializes a new Task with the specified action.

Task(Action, CancellationToken)

指定したアクションおよび Task で新しい CancellationToken を初期化します。Initializes a new Task with the specified action and CancellationToken.

Task(Action, CancellationToken, TaskCreationOptions)

指定したアクションと作成オプションで新しい Task を初期化します。Initializes a new Task with the specified action and creation options.

Task(Action, TaskCreationOptions)

指定したアクションと作成オプションで新しい Task を初期化します。Initializes a new Task with the specified action and creation options.

Task(Action<Object>, Object)

指定したアクションと状態で新しい Task を初期化します。Initializes a new Task with the specified action and state.

Task(Action<Object>, Object, CancellationToken)

指定したアクション、状態、およびオプションで新しい Task を初期化します。Initializes a new Task with the specified action, state, and options.

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

指定したアクション、状態、およびオプションで新しい Task を初期化します。Initializes a new Task with the specified action, state, and options.

Task(Action<Object>, Object, TaskCreationOptions)

指定したアクション、状態、およびオプションで新しい Task を初期化します。Initializes a new Task with the specified action, state, and options.

プロパティ

AsyncState

Task が作成されたときに渡される状態オブジェクトを取得します。渡されなかった場合は null。Gets the state object supplied when the Task was created, or null if none was supplied.

CompletedTask

既に正常に完了したタスクを取得します。Gets a task that has already completed successfully.

CreationOptions

このタスクの作成に使用される TaskCreationOptions を取得します。Gets the TaskCreationOptions used to create this task.

CurrentId

現在実行中の Task の ID を返します。Returns the ID of the currently executing Task.

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

Task および Task<TResult> インスタンスを作成して構成するためのファクトリ メソッドへのアクセスを提供します。Provides access to factory methods for creating and configuring Task and Task<TResult> instances.

Id

この Task インスタンスの ID を取得します。Gets an ID for this Task instance.

IsCanceled

この Task インスタンスの実行が取り消されることによって完了したかどうかを示す値を取得します。Gets whether this Task instance has completed execution due to being canceled.

IsCompleted

タスクが完了したかどうかを示す値を取得します。Gets a value that indicates whether the task has completed.

IsCompletedSuccessfully

タスクが完了まで実行されたかどうかを示す値を取得します。Gets whether the task ran to completion.

IsFaulted

処理されない例外が発生したことが原因で Task が完了したかどうかを示す値を取得します。Gets whether the Task completed due to an unhandled exception.

Status

このタスクの TaskStatus を取得します。Gets the TaskStatus of this task.

メソッド

ConfigureAwait(Boolean)

この Task を待機するために使用する awaiter を構成します。Configures an awaiter used to await this Task.

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)

呼び出し元が提供した状態情報およびキャンセル トークンを受け取り、対象の 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)

呼び出し元が提供した状態情報およびキャンセル トークンを受け取り、対象の 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)

呼び出し元が提供した状態情報を受け取り、対象の 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)

呼び出し元が提供した状態情報を受け取り、対象の 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>)

ターゲットの Task が完了したときに非同期に実行する継続タスクを作成します。Creates a continuation that executes asynchronously when the target Task completes.

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)

対象のタスクが完了したときに、指定した 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)

対象のタスクが完了したときに、指定した TaskContinuationOptions に従って実行される継続タスクを作成します。Creates a continuation that executes when the target task completes according to the specified TaskContinuationOptions.

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)

呼び出し元から提供される状態情報を受け取り、対象の 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)

対象の 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)

対象の 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)

対象の 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)

ターゲットの 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>)

対象の Task<TResult> が完了して値を返したときに非同期的に実行される継続タスクを作成します。Creates a continuation that executes asynchronously when the target Task<TResult> completes and returns a value.

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)

指定された継続のオプションに従って実行され、値を返す継続タスクを作成します。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)

指定された継続のオプションに従って実行され、値を返す継続タスクを作成します。Creates a continuation that executes according to the specified continuation options and returns a value.

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)

指定したミリ秒後に完了するタスクを作成します。Creates a task that completes after a specified number of milliseconds.

Delay(Int32, CancellationToken)

指定したミリ秒後に完了するキャンセル可能なタスクを作成します。Creates a cancellable task that completes after a specified number of milliseconds.

Delay(TimeSpan)

指定した期間の後に完了するタスクを作成します。Creates a task that completes after a specified time interval.

Delay(TimeSpan, CancellationToken)

指定した期間の後に完了するキャンセル可能タスクを作成します。Creates a cancellable task that completes after a specified time interval.

Dispose()

Task クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。Releases all resources used by the current instance of the Task class.

Dispose(Boolean)

Task を破棄し、そのすべてのアンマネージ リソースを解放します。Disposes the Task, releasing all of its unmanaged resources.

Equals(Object)

指定されたオブジェクトが現在のオブジェクトと等しいかどうかを判定します。Determines whether the specified object is equal to the current object.

(継承元 Object)
FromCanceled(CancellationToken)

指定したキャンセル トークンを使ったキャンセルにより完了した Task を作成します。Creates a Task that's completed due to cancellation with a specified cancellation token.

FromCanceled<TResult>(CancellationToken)

指定したキャンセル トークンを使ったキャンセルにより完了した Task<TResult> を作成します。Creates a Task<TResult> that's completed due to cancellation with a specified cancellation token.

FromException(Exception)

指定した例外で完了した Task を作成します。Creates a Task that has completed with a specified exception.

FromException<TResult>(Exception)

指定した例外で完了した Task<TResult> を作成します。Creates a Task<TResult> that's completed with a specified exception.

FromResult<TResult>(TResult)

指定した結果で成功した Task<TResult> を作成します。Creates a Task<TResult> that's completed successfully with the specified result.

GetAwaiter()

この Task を待機するために使用する awaiter を取得します。Gets an awaiter used to await this Task.

GetHashCode()

既定のハッシュ関数として機能します。Serves as the default hash function.

(継承元 Object)
GetType()

現在のインスタンスの Type を取得します。Gets the Type of the current instance.

(継承元 Object)
MemberwiseClone()

現在の Object の簡易コピーを作成します。Creates a shallow copy of the current Object.

(継承元 Object)
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)

スレッド プール上で実行する指定された作業をキューに配置し、その作業を表す 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>)

スレッド プール上で実行する作業を指定してキューに配置し、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)

スレッド プール上で実行する作業を指定してキューに配置し、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>>)

スレッド プール上で実行する指定された作業をキューに配置し、function によって返される Task(TResult) のプロキシを返します。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)

スレッド プール上で実行する指定された作業をキューに配置し、function によって返される Task(TResult) のプロキシを返します。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>)

スレッド プール上で実行する指定された作業をキューに配置し、その作業を表す 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)

スレッド プール上で実行する指定された作業をキューに配置し、その作業を表す 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()

現在の TaskTaskScheduler を同期的に実行します。Runs the Task synchronously on the current TaskScheduler.

RunSynchronously(TaskScheduler)

指定された TaskTaskScheduler を同期的に実行します。Runs the Task synchronously on the TaskScheduler provided.

Start()

現在の TaskTaskScheduler の実行をスケジュールし、それを開始します。Starts the Task, scheduling it for execution to the current TaskScheduler.

Start(TaskScheduler)

指定された TaskTaskScheduler の実行をスケジュールし、それを開始します。Starts the Task, scheduling it for execution to the specified TaskScheduler.

ToString()

現在のオブジェクトを表す string を返します。Returns a string that represents the current object.

(継承元 Object)
Wait()

Task の実行が完了するまで待機します。Waits for the Task to complete execution.

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)

提供された Task の実行が完了するまで、指定したミリ秒数以内の間、待機します。Waits for the Task to complete execution within a specified number of milliseconds.

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)

提供された Task の実行が完了するまで、指定した時間間隔内の間、待機します。Waits for the Task to complete execution within a specified time interval.

WaitAll(Task[])

指定したすべての Task オブジェクトの実行が完了するまで待機します。Waits for all of the provided Task objects to complete execution.

WaitAll(Task[], CancellationToken)

待機が取り消されない限り、指定したすべての Task オブジェクトの実行が完了するまで待機します。Waits for all of the provided Task objects to complete execution unless the wait is cancelled.

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)

指定したミリ秒数まで、または待機が取り消されるまで、提供されたすべての 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)

提供されたすべてのキャンセル可能な Task オブジェクトの実行が完了するまで、指定した時間間隔の間、待機します。Waits for all of the provided cancellable Task objects to complete execution within a specified time interval.

WaitAny(Task[])

指定したいずれかの Task オブジェクトの実行が完了するまで待機します。Waits for any of the provided Task objects to complete execution.

WaitAny(Task[], CancellationToken)

待機が取り消されない限り、指定したいずれかの Task オブジェクトの実行が完了するまで待機します。Waits for any of the provided Task objects to complete execution unless the wait is cancelled.

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)

指定したミリ秒数まで、または待機トークンが取り消されるまで、提供されたいずれかの 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)

提供されたいずれかの Task オブジェクトの実行が完了するまで、指定した時間間隔内の間、待機します。Waits for any of the provided Task objects to complete execution within a specified time interval.

WhenAll(IEnumerable<Task>)

列挙可能なコレクション内のすべての Task オブジェクトが完了したときに完了するタスクを作成します。Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

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

列挙可能なコレクション内のすべての 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>[])

配列内のすべての Task<TResult> オブジェクトが完了したときに完了するタスクを作成します。Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

WhenAny(IEnumerable<Task>)

指定されたタスクのいずれかが完了してから完了するタスクを作成します。Creates a task that will complete when any of the supplied tasks have completed.

WhenAny(Task[])

指定されたタスクのいずれかが完了してから完了するタスクを作成します。Creates a task that will complete when any of the supplied tasks have completed.

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

指定されたタスクのいずれかが完了してから完了するタスクを作成します。Creates a task that will complete when any of the supplied tasks have completed.

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

指定されたタスクのいずれかが完了してから完了するタスクを作成します。Creates a task that will complete when any of the supplied tasks have completed.

Yield()

待機されたときに現在のコンテキストに非同期的に処理を譲る awaitable タスクを作成します。Creates an awaitable task that asynchronously yields back to the current context when awaited.

明示的なインターフェイスの実装

IAsyncResult.AsyncWaitHandle

タスクの完了を待機するために使用できる WaitHandle を取得します。Gets a WaitHandle that can be used to wait for the task to complete.

IAsyncResult.CompletedSynchronously

操作が同期的に完了したかどうかを示す値を取得します。Gets an indication of whether the operation completed synchronously.

拡張メソッド

DispatcherOperationWait(Task)

基になる DispatcherOperation が完了するまで無期限に待機します。Waits indefinitely for the underlying DispatcherOperation to complete.

DispatcherOperationWait(Task, TimeSpan)

基になる DispatcherOperation が完了するまで、指定された時間待機します。Waits for the specified amount of time for the underlying DispatcherOperation to complete.

IsDispatcherOperationTask(Task)

この TaskDispatcherOperation に関連付けられているかどうかを示す値を返します。Returns a value that indicates whether this Task is associated with a DispatcherOperation.

AsAsyncAction(Task)

開始されたタスクを表す Windows ランタイム非同期アクションを返します。Returns a Windows Runtime asynchronous action that represents a started task.

適用対象

スレッド セーフ

Dispose()を除く Taskのすべてのメンバーはスレッドセーフであり、複数のスレッドから同時に使用することができます。All members of Task, except for Dispose(), are thread-safe and may be used from multiple threads concurrently.

こちらもご覧ください