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処理は、通常、メイン アプリケーション スレッドではなくスレッド プール スレッドで非同期に実行されるため、プロパティIsCanceledIsCompletedIsFaultedプロパティを使用Statusして、タスクの状態を判断できます。 最も一般的には、ラムダ式を使用して、タスクが実行する作業を指定します。

値を返す操作では、クラスを使用します Task<TResult>

このセクションの内容:

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

タスクのインスタンス化

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

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

  • タスク 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 or TaskFactory.StartNew メソッドが推奨されるメカニズムですが、作成とスケジュールを分離する必要があるシナリオでは、コンストラクターを使用してからメソッドを呼び出 Task.Start して、後で実行するタスクをスケジュールできます。

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

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

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

次の例では、パラメーターなしの 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(TimeSpan)メソッドはWait(Int32)、タスクが完了するか、タイムアウト間隔が経過するまで呼び出し元のスレッドをブロックします。どちらか早い方です。 次の例では、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.

and Wait(Int32, CancellationToken) メソッドを呼び出してキャンセル トークンをWait(CancellationToken)指定することもできます。 トークンのプロパティがメソッドのIsCancellationRequested実行中または実行中になったtrueWait場合、メソッドOperationCanceledExceptiontrueは .

場合によっては、一連の実行中のタスクの最初の完了を待つ必要がある場合もありますが、どのタスクが完了するかは気にしないでください。 この目的のために、メソッドのいずれかのオーバーロードを 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 参照してください。

注意

Microsoft Storeアプリは、既定のカルチャの設定と取得の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 の実行が完了するまで、指定した時間間隔内の間、待機します。

Wait(TimeSpan, CancellationToken)

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 ランタイム非同期アクションを返します。

適用対象

スレッド セーフ

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

こちらもご覧ください