Task クラス

定義

非同期操作を表します。

public ref class Task : IAsyncResult
public ref class Task : IAsyncResult, IDisposable
public class Task : IAsyncResult
public class Task : IAsyncResult, IDisposable
type Task = class
    interface IAsyncResult
type Task = class
    interface IAsyncResult
    interface IDisposable
Public Class Task
Implements IAsyncResult
Public Class Task
Implements IAsyncResult, IDisposable
継承
Task
派生
実装

注釈

クラスは、 Task 値を返さず、通常は非同期的に実行する1つの操作を表します。 Taskオブジェクトは、.NET Framework 4 で最初に導入されたタスクベースの非同期パターンの中心的なコンポーネントの1つです。 オブジェクトによって実行される作業は、 Task 通常、メインアプリケーションスレッドで同期的に実行されるのではなく、スレッドプールのスレッドで非同期的に実行されるため、プロパティ、、、およびの各プロパティを使用して、 Status IsCanceled IsCompleted IsFaulted タスクの状態を確認できます。 通常、ラムダ式を使用して、タスクが実行する作業を指定します。

値を返す操作の場合は、クラスを使用し Task<TResult> ます。

このセクションの内容は次のとおりです。

タスクのインスタンス化の例
タスクの作成と実行
タスクの作成と実行の分離
1つ以上のタスクが完了するのを待機しています
タスクとカルチャ
デバッガー開発者向け

タスクのインスタンス化

次の例では、4つのタスクを作成して実行します。 3つのタスクは Action<T> action 、型の引数を受け取るという名前のデリゲートを実行し Object ます。 4番目のタスクは、 Action タスク作成メソッドの呼び出しでインラインで定義されているラムダ式 (デリゲート) を実行します。 各タスクはインスタンス化され、別の方法で実行されます。

  • タスク t1 はタスククラスコンストラクターを呼び出すことによってインスタンス化されますが、タスクが開始された後にのみメソッドを呼び出すことによって開始され Start() t2 ます。

  • タスク t2 は、メソッドを呼び出すことによってインスタンス化され、1回のメソッド呼び出しで開始され TaskFactory.StartNew(Action<Object>, Object) ます。

  • タスク t3 は、メソッドを呼び出すことによってインスタンス化され、1回のメソッド呼び出しで開始され Run(Action) ます。

  • タスク t4 は、メソッドを呼び出すことによって、メインスレッドで同期的に実行され RunSynchronously() ます。

タスクは t4 同期的に実行されるため、メインアプリケーションスレッドで実行されます。 残りのタスクは、通常、1つ以上のスレッドプールのスレッドで非同期的に実行されます。

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

タスクの作成と実行

Task インスタンスは、さまざまな方法で作成できます。 .NET Framework 4.5 以降で使用できる最も一般的な方法は、静的メソッドを呼び出すことです Run 。 メソッドは、 Run 既定値を使用してタスクを開始する簡単な方法を提供し、追加のパラメーターを必要としません。 次の例では、メソッドを使用して、ループ Run(Action) するタスクを開始し、ループイテレーションの数を表示します。

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 でタスクを開始する最も一般的な方法は静的 TaskFactory.StartNew メソッドです。 プロパティは、 Task.Factory オブジェクトを返し TaskFactory ます。 メソッドのオーバーロードを TaskFactory.StartNew 使用すると、タスクの作成オプションとタスクスケジューラに渡すパラメーターを指定できます。 次の例では、メソッドを使用して TaskFactory.StartNew タスクを開始します。 これは、前の例のコードと機能的には同等です。

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 タスクを初期化するコンストラクターも用意されていますが、実行のスケジュールは設定されていません。 パフォーマンス上の理由から、 Task.Run または TaskFactory.StartNew メソッドは、計算タスクを作成およびスケジュール設定するための推奨メカニズムですが、作成とスケジュールを分離する必要があるシナリオでは、コンストラクターを使用して、メソッドを呼び出して、後で実行するよう Task.Start にタスクをスケジュールすることができます。

1つ以上のタスクが完了するのを待機しています

タスクは通常、スレッドプールのスレッドで非同期に実行されるため、タスクを作成して開始するスレッドは、タスクがインスタンス化されるとすぐに実行を継続します。 場合によっては、呼び出し元のスレッドがメインアプリケーションスレッドであると、タスクが実際に実行を開始する前にアプリが終了することがあります。 それ以外の場合、アプリケーションのロジックでは、1つ以上のタスクが実行を完了したときにのみ、呼び出し元のスレッドが実行を継続することが必要になる場合があります。 Wait1 つ以上のタスクが完了するまで待機するメソッドを呼び出すことによって、呼び出し元スレッドと起動する非同期タスクの実行を同期できます。

1つのタスクが完了するまで待機するには、そのメソッドを呼び出すことができ Task.Wait ます。 メソッドを呼び出すと、 Wait 単一クラスのインスタンスの実行が完了するまで、呼び出し元のスレッドがブロックされます。

次の例では、パラメーターなしのメソッドを呼び出して、 Wait() タスクが完了するまで無条件に待機します。 タスクは、メソッドを呼び出して Thread.Sleep 2 秒間スリープ状態にすることで、作業をシミュレートします。

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

タスクの完了を条件付きで待機することもできます。 Wait(Int32)メソッドと Wait(TimeSpan) メソッドは、タスクが終了するまで、またはタイムアウト間隔が経過するまで、呼び出し元のスレッドをブロックします。 次の例では、2秒間スリープするタスクを起動しますが、1秒間のタイムアウト値を定義するため、呼び出し元のスレッドはタイムアウトが経過するまでブロックされ、タスクの実行が完了するまでブロックされます。

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) ます。 IsCancellationRequestedメソッドの実行中にトークンのプロパティが true またはになった場合 true Wait 、メソッドはをスロー OperationCanceledException します。

場合によっては、一連の実行中の一連のタスクが完了するまで待機する必要がありますが、それがどのようなタスクであるかは気にしません。 このためには、メソッドのオーバーロードの1つを呼び出すことができ Task.WaitAny ます。 次の例では、3つのタスクを作成し、それぞれが乱数ジェネレーターによって決められた間隔でスリープします。 メソッドは、 WaitAny(Task[]) 最初のタスクが完了するまで待機します。 この例では、3つのタスクすべての状態に関する情報が表示されます。

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 ます。 次の例では、10個のタスクを作成し、すべての10が完了するまで待機して、その状態を表示します。

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 ください。 12個のタスクが起動され、そのうち3つは正常に完了し、そのうち3つは例外をスローします。 残りの6つのタスクのうち、3つは開始前にキャンセルされ、3つは実行中にキャンセルされます。 例外は、メソッドの呼び出しでスローされ、 WaitAll ブロックによって処理され try / catch ます。

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

タスクベースの非同期操作での例外処理の詳細については、「 例外処理」を参照してください。

タスクとカルチャ

.NET Framework 4.6 を対象とするデスクトップアプリ以降では、タスクを作成して呼び出すスレッドのカルチャがスレッドのコンテキストの一部になります。 つまり、タスクが実行されるスレッドの現在のカルチャに関係なく、タスクの現在のカルチャが呼び出し元スレッドのカルチャになります。 .NET Framework 4.6 より前のバージョンの .NET Framework を対象とするアプリの場合、タスクのカルチャは、タスクが実行されるスレッドのカルチャになります。 詳細については、「」トピックの「カルチャとタスクベースの非同期操作」セクションを参照してください CultureInfo

注意

ストアアプリは、設定の Windows ランタイムに従い、既定のカルチャを取得します。

デバッガー開発者向け

カスタムデバッガーを実装する開発者にとっては、タスクのいくつかの内部メンバーとプライベートメンバーが役に立つ場合があります (これらはリリースごとに変更される可能性があります)。 フィールドは、 m_taskId プロパティのバッキングストアとして機能します Id が、デバッガーから直接このフィールドにアクセスする方が、プロパティの getter メソッドを使用して同じ値にアクセスするよりも効率的な場合があります (カウンターを使用して、 s_taskIdCounter タスクの次に使用できる ID を取得します)。 同様に、このフィールドには、 m_stateFlags タスクの現在のライフサイクルステージに関する情報が格納されます。情報は、プロパティを介してアクセスすることもでき Status ます。 フィールドには、 m_action タスクのデリゲートへの参照が格納され m_stateObject ます。フィールドには、開発者によってタスクに渡される非同期状態が格納されます。 最後に、スタックフレームを解析するデバッガーの場合、 InternalWait メソッドはタスクが待機操作に入ったときのマーカーとして機能します。

コンストラクター

Task(Action)

指定したアクションで新しい Task を初期化します。

Task(Action, CancellationToken)

指定したアクションおよび Task で新しい CancellationToken を初期化します。

Task(Action, CancellationToken, TaskCreationOptions)

指定したアクションと作成オプションで新しい Task を初期化します。

Task(Action, TaskCreationOptions)

指定したアクションと作成オプションで新しい Task を初期化します。

Task(Action<Object>, Object)

指定したアクションと状態で新しい Task を初期化します。

Task(Action<Object>, Object, CancellationToken)

指定したアクション、状態、およびオプションで新しい Task を初期化します。

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

指定したアクション、状態、およびオプションで新しい Task を初期化します。

Task(Action<Object>, Object, TaskCreationOptions)

指定したアクション、状態、およびオプションで新しい Task を初期化します。

プロパティ

AsyncState

Task が作成されたときに渡される状態オブジェクトを取得します。渡されなかった場合は null。

CompletedTask

既に正常に完了したタスクを取得します。

CreationOptions

このタスクの作成に使用される TaskCreationOptions を取得します。

CurrentId

現在実行中の Task の ID を返します。

Exception

AggregateException が途中で終了する原因となった Task を取得します。 Task が正常に完了した場合、または例外がスローされていない場合は、null が返されます。

Factory

Task および Task<TResult> インスタンスを作成して構成するためのファクトリ メソッドへのアクセスを提供します。

Id

この Task インスタンスの ID を取得します。

IsCanceled

この Task インスタンスの実行が取り消されることによって完了したかどうかを示す値を取得します。

IsCompleted

タスクが完了したかどうかを示す値を取得します。

IsCompletedSuccessfully

タスクが完了まで実行されたかどうかを示す値を取得します。

IsFaulted

処理されない例外が発生したことが原因で Task が完了したかどうかを示す値を取得します。

Status

このタスクの TaskStatus を取得します。

メソッド

ConfigureAwait(Boolean)

この Task を待機するために使用する awaiter を構成します。

ContinueWith(Action<Task,Object>, Object)

呼び出し元が提供した状態情報を受け取り、対象の Task が完了したときに実行される継続タスクを作成します。

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

呼び出し元が提供した状態情報およびキャンセル トークンを受け取り、対象の Task の完了時に非同期的に実行される継続タスクを作成します。

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

呼び出し元が提供した状態情報およびキャンセル トークンを受け取り、対象の Task の完了時に実行される継続タスクを作成します。 継続タスクは、指定した一連の条件に基づいて実行され、指定したスケジューラが使用されます。

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

呼び出し元が提供した状態情報を受け取り、対象の Task が完了したときに実行される継続タスクを作成します。 継続タスクは、指定した一連の条件に基づいて実行されます。

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

呼び出し元が提供した状態情報を受け取り、対象の Task が完了したときに非同期的に実行される継続タスクを作成します。 継続タスクは、指定されたスケジューラを使用します。

ContinueWith(Action<Task>)

ターゲットの Task が完了したときに非同期に実行する継続タスクを作成します。

ContinueWith(Action<Task>, CancellationToken)

キャンセル トークンを受け取って、対象の Task が完了したときに非同期的に実行される継続タスクを作成します。

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

対象のタスクが完了したときに、指定した TaskContinuationOptions に従って実行される継続タスクを作成します。 この継続タスクは、キャンセル トークンを受け取り、指定されたスケジューラを使用します。

ContinueWith(Action<Task>, TaskContinuationOptions)

対象のタスクが完了したときに、指定した TaskContinuationOptions に従って実行される継続タスクを作成します。

ContinueWith(Action<Task>, TaskScheduler)

ターゲットの Task が完了したときに非同期に実行する継続タスクを作成します。 継続タスクは、指定されたスケジューラを使用します。

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

呼び出し元から提供される状態情報を受け取り、対象の Task が完了したときに非同期的に実行され、値を返す継続タスクを作成します。

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

対象の Task が完了して値を返したときに非同期的に実行される継続タスクを作成します。 この継続タスクは、呼び出し元が提供した状態情報とキャンセル トークンを受け取ります。

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

対象の Task が完了したときに、指定したタスク継続オプションに基づいて実行され、値を返す継続タスクを作成します。 この継続タスクは、呼び出し元が提供した状態情報とキャンセル トークンを受け取り、指定したスケジューラを使用します。

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

対象の Task が完了したときに、指定したタスク継続オプションに基づいて実行される継続タスクを作成します。 この継続タスクは、呼び出し元が提供した状態情報を受け取ります。

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

ターゲットの Task が完了したときに非同期に実行する継続タスクを作成します。 この継続タスクは、呼び出し元が提供した状態情報を受け取り、指定したスケジューラを使用します。

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

対象の Task<TResult> が完了して値を返したときに非同期的に実行される継続タスクを作成します。

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

対象の Task が完了して値を返したときに非同期的に実行される継続タスクを作成します。 この継続タスクは、キャンセル トークンを受け取ります。

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

指定された継続のオプションに従って実行され、値を返す継続タスクを作成します。 継続タスクは、キャンセル トークンを渡され、指定されたスケジューラを使用します。

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

指定された継続のオプションに従って実行され、値を返す継続タスクを作成します。

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

対象の Task が完了して値を返したときに非同期的に実行される継続タスクを作成します。 継続タスクは、指定されたスケジューラを使用します。

Delay(Int32)

指定したミリ秒後に完了するタスクを作成します。

Delay(Int32, CancellationToken)

指定したミリ秒後に完了するキャンセル可能なタスクを作成します。

Delay(TimeSpan)

指定した期間の後に完了するタスクを作成します。

Delay(TimeSpan, CancellationToken)

指定した期間の後に完了するキャンセル可能タスクを作成します。

Dispose()

Task クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。

Dispose(Boolean)

Task を破棄し、そのすべてのアンマネージ リソースを解放します。

Equals(Object)

指定されたオブジェクトが現在のオブジェクトと等しいかどうかを判断します。

(継承元 Object)
FromCanceled(CancellationToken)

指定したキャンセル トークンを使ったキャンセルにより完了した Task を作成します。

FromCanceled<TResult>(CancellationToken)

指定したキャンセル トークンを使ったキャンセルにより完了した Task<TResult> を作成します。

FromException(Exception)

指定した例外で完了した Task を作成します。

FromException<TResult>(Exception)

指定した例外で完了した Task<TResult> を作成します。

FromResult<TResult>(TResult)

指定した結果で成功した Task<TResult> を作成します。

GetAwaiter()

この Task を待機するために使用する awaiter を取得します。

GetHashCode()

既定のハッシュ関数として機能します。

(継承元 Object)
GetType()

現在のインスタンスの Type を取得します。

(継承元 Object)
MemberwiseClone()

現在の Object の簡易コピーを作成します。

(継承元 Object)
Run(Action)

スレッド プール上で実行する指定された作業をキューに配置し、その作業を表す Task オブジェクトを戻します。

Run(Action, CancellationToken)

スレッド プール上で実行する指定された作業をキューに配置し、その作業を表す Task オブジェクトを戻します。 まだ開始されていない場合、キャンセル トークンで処理をキャンセルできます。

Run(Func<Task>)

スレッド プール上で実行する作業を指定してキューに配置し、function によって返されるタスクのプロキシを返します。

Run(Func<Task>, CancellationToken)

スレッド プール上で実行する作業を指定してキューに配置し、function によって返されるタスクのプロキシを返します。 まだ開始されていない場合、キャンセル トークンで処理をキャンセルできます。

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

スレッド プール上で実行する指定された作業をキューに配置し、function によって返される Task(TResult) のプロキシを返します。 まだ開始されていない場合、キャンセル トークンで処理をキャンセルできます。

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

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

Run<TResult>(Func<TResult>)

スレッド プール上で実行する指定された作業をキューに配置し、その作業を表す Task<TResult> オブジェクトを戻します。 まだ開始されていない場合、キャンセル トークンで処理をキャンセルできます。

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

スレッド プール上で実行する指定された作業をキューに配置し、その作業を表す Task(TResult) オブジェクトを戻します。

RunSynchronously()

現在の TaskTaskScheduler を同期的に実行します。

RunSynchronously(TaskScheduler)

指定された TaskTaskScheduler を同期的に実行します。

Start()

現在の TaskTaskScheduler の実行をスケジュールし、それを開始します。

Start(TaskScheduler)

指定された TaskTaskScheduler の実行をスケジュールし、それを開始します。

ToString()

現在のオブジェクトを表す文字列を返します。

(継承元 Object)
Wait()

Task の実行が完了するまで待機します。

Wait(CancellationToken)

Task の実行が完了するまで待機します。 タスクの完了前にキャンセル トークンが取り消される場合は、待機が終了します。

Wait(Int32)

提供された Task の実行が完了するまで、指定したミリ秒数以内の間、待機します。

Wait(Int32, CancellationToken)

Task の実行が完了するまで待機します。 タスクの完了前に、タイムアウト期間が経過するか、キャンセル トークンが取り消される場合には、待機が終了します。

Wait(TimeSpan)

提供された Task の実行が完了するまで、指定した時間間隔内の間、待機します。

WaitAll(Task[])

指定したすべての Task オブジェクトの実行が完了するまで待機します。

WaitAll(Task[], CancellationToken)

待機が取り消されない限り、指定したすべての Task オブジェクトの実行が完了するまで待機します。

WaitAll(Task[], Int32)

提供されたすべての Task オブジェクトの実行が完了するまで、指定したミリ秒数以内の間、待機します。

WaitAll(Task[], Int32, CancellationToken)

指定したミリ秒数まで、または待機が取り消されるまで、提供されたすべての Task オブジェクトの実行が完了するのを待機します。

WaitAll(Task[], TimeSpan)

提供されたすべてのキャンセル可能な Task オブジェクトの実行が完了するまで、指定した時間間隔の間、待機します。

WaitAny(Task[])

指定したいずれかの Task オブジェクトの実行が完了するまで待機します。

WaitAny(Task[], CancellationToken)

待機が取り消されない限り、指定したいずれかの Task オブジェクトの実行が完了するまで待機します。

WaitAny(Task[], Int32)

提供されたいずれかの Task オブジェクトの実行が完了するまで、指定したミリ秒数以内の間、待機します。

WaitAny(Task[], Int32, CancellationToken)

指定したミリ秒数まで、または待機トークンが取り消されるまで、提供されたいずれかの Task オブジェクトの実行が完了するのを待機します。

WaitAny(Task[], TimeSpan)

提供されたいずれかの Task オブジェクトの実行が完了するまで、指定した時間間隔内の間、待機します。

WaitAsync(CancellationToken)

これが完了するか、指定した が取り消し Task Task 要求を受け取った場合に CancellationToken 完了する を取得します。

WaitAsync(TimeSpan)

これが完了 Task するか、指定したタイムアウトが期限切れ Task になったときに完了する を取得します。

WaitAsync(TimeSpan, CancellationToken)

これが完了した場合、指定したタイムアウトが期限切れになった場合、または指定したが取り消し要求を行った場合に完了 Task Task する CancellationToken を取得します。

WhenAll(IEnumerable<Task>)

列挙可能なコレクション内のすべての Task オブジェクトが完了したときに完了するタスクを作成します。

WhenAll(Task[])

配列内のすべての Task オブジェクトが完了したときに完了するタスクを作成します。

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

列挙可能なコレクション内のすべての Task<TResult> オブジェクトが完了したときに完了するタスクを作成します。

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

配列内のすべての Task<TResult> オブジェクトが完了したときに完了するタスクを作成します。

WhenAny(IEnumerable<Task>)

指定されたタスクのいずれかが完了してから完了するタスクを作成します。

WhenAny(Task, Task)

指定されたいずれかのタスクが完了してから完了するタスクを作成します。

WhenAny(Task[])

指定されたタスクのいずれかが完了してから完了するタスクを作成します。

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

指定されたタスクのいずれかが完了してから完了するタスクを作成します。

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

指定されたいずれかのタスクが完了してから完了するタスクを作成します。

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

指定されたタスクのいずれかが完了してから完了するタスクを作成します。

Yield()

待機されたときに現在のコンテキストに非同期的に処理を譲る awaitable タスクを作成します。

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

IAsyncResult.AsyncWaitHandle

タスクの完了を待機するために使用できる WaitHandle を取得します。

IAsyncResult.CompletedSynchronously

操作が同期的に完了したかどうかを示す値を取得します。

拡張メソッド

DispatcherOperationWait(Task)

基になる DispatcherOperation が完了するまで無期限に待機します。

DispatcherOperationWait(Task, TimeSpan)

基になる DispatcherOperation が完了するまで、指定された時間待機します。

IsDispatcherOperationTask(Task)

この TaskDispatcherOperation に関連付けられているかどうかを示す値を返します。

AsAsyncAction(Task)

開始されたタスクを表す Windows ランタイム非同期アクションを返します。

適用対象

スレッド セーフ

を除くのすべてのメンバー Task Dispose() はスレッドセーフであり、複数のスレッドから同時に使用することができます。

こちらもご覧ください