Task Task Task Task Class

定義

非同期操作を表します。Represents an asynchronous operation.

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

注釈

Taskクラスを返さない値を通常は 1 回の操作が非同期的に実行を表します。The Task class represents a single operation that does not return a value and that usually executes asynchronously. Task オブジェクトは、中央のコンポーネントの 1 つ、タスクベースの非同期パターン.NET Framework 4 で初めて導入されました。Task objects are one of the central components of the task-based asynchronous pattern first introduced in the .NET Framework 4. によって、作業が実行されるため、Taskオブジェクト通常は非同期的に実行スレッド プールのスレッドで同期的に、メイン アプリケーション スレッドで使用できますではなく、StatusプロパティだけでなくIsCanceledIsCompletedIsFaultedプロパティ、タスクの状態を判断します。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 つのタスクの実行、Action<T>という名前のデリゲートaction、型の引数を受け入れるObjectします。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タスク クラスのコンス トラクターを呼び出すことによってインスタンス化されますが、呼び出しによって開始されたが、Start()タスクの後にのみメソッドt2が開始します。Task t1 is instantiated by calling a Task class constructor, but is started by calling its Start() method only after task t2 has started.

  • タスクt2がインスタンス化され、1 つのメソッド呼び出しの呼び出しによって開始された、TaskFactory.StartNew(Action<Object>, Object)メソッド。Task t2 is instantiated and started in a single method call by calling the TaskFactory.StartNew(Action<Object>, Object) method.

  • タスクt3がインスタンス化され、1 つのメソッド呼び出しの呼び出しによって開始された、Run(Action)メソッド。Task t3 is instantiated and started in a single method call by calling the Run(Action) method.

  • タスクt4を呼び出して、メイン スレッドで同期的に実行が、RunSynchronously()メソッド。Task t4 is executed synchronously on the main thread by calling the RunSynchronously() method.

タスクt4同期的に、実行、アプリケーションのメイン スレッドで実行します。Because task t4 executes synchronously, it executes on the main application thread. 残りのタスク実行非同期的に通常 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. 呼び出し元のスレッドの実行を同期して、非同期タスクが起動を呼び出して、Waitメソッドを 1 つまたは複数のタスクが完了するまで待ちます。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メソッドは、1 つのクラス インスタンスの実行が完了するまで、呼び出し元のスレッドをブロックします。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. 場合、トークンのIsCancellationRequestedプロパティはtrueなったりtrue中に、Waitメソッドを実行して、メソッドはスロー、OperationCanceledExceptionします。If the token's IsCancellationRequested property is true or becomes true while the Wait method is executing, the method throws an OperationCanceledException.

場合によっては、待機することがあります、タスクが注意が完了するがない、一連のタスクを実行して、最初の。In some cases, you may want to wait for the first of a series of executing tasks to complete, but don't care which task it is. この目的で、いずれかのオーバー ロードを呼び出すことができます、Task.WaitAllメソッド。For this purpose, you can call one of the overloads of the Task.WaitAll 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 the start, and three are cancelled while they executing. 例外がスローされた、WaitAllによって処理されるメソッドの呼び出しとは、 try / catchブロックします。Exceptions are thrown in the WaitAll method call and are handled by a try/catch block.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Create a cancellation token and cancel it.
      var source1 = new CancellationTokenSource();
      var token1 = source1.Token;
      source1.Cancel();
      // Create a cancellation token for later cancellation.
      var source2 = new CancellationTokenSource();
      var token2 = source2.Token;
       
      // Create a series of tasks that will complete, be cancelled, 
      // timeout, or throw an exception.
      Task[] tasks = new Task[12];
      for (int i = 0; i < 12; i++)
      {
          switch (i % 4) 
          {
             // Task should run to completion.
             case 0:
                tasks[i] = Task.Run(() => Thread.Sleep(2000));
                break;
             // Task should be set to canceled state.
             case 1:   
                tasks[i] = Task.Run( () => Thread.Sleep(2000),
                         token1);
                break;         
             case 2:
                // Task should throw an exception.
                tasks[i] = Task.Run( () => { throw new NotSupportedException(); } );
                break;
             case 3:
                // Task should examine cancellation token.
                tasks[i] = Task.Run( () => { Thread.Sleep(2000); 
                                             if (token2.IsCancellationRequested)
                                                token2.ThrowIfCancellationRequested();
                                             Thread.Sleep(500); }, token2);   
                break;
          }
      }
      Thread.Sleep(250);
      source2.Cancel();
       
      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
          Console.WriteLine("One or more exceptions occurred:");
          foreach (var ex in ae.InnerExceptions)
             Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message);
       }   

      Console.WriteLine("\nStatus of tasks:");
      foreach (var t in tasks) {
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
         if (t.Exception != null) {
            foreach (var ex in t.Exception.InnerExceptions)
               Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                 ex.Message);
         }
      }
   }
}
// The example displays output like the following:
//   One or more exceptions occurred:
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//   
//   Status of tasks:
//      Task #13: RanToCompletion
//      Task #1: Canceled
//      Task #3: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #8: Canceled
//      Task #14: RanToCompletion
//      Task #4: Canceled
//      Task #6: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #7: Canceled
//      Task #15: RanToCompletion
//      Task #9: Canceled
//      Task #11: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #12: Canceled
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Create a cancellation token and cancel it.
      Dim source1 As New CancellationTokenSource()
      Dim token1 As CancellationToken = source1.Token
      source1.Cancel()
      ' Create a cancellation token for later cancellation.
      Dim source2 As New CancellationTokenSource()
      Dim token2 As CancellationToken = source2.Token
       
      ' Create a series of tasks that will complete, be cancelled, 
      ' timeout, or throw an exception.
      Dim tasks(11) As Task
      For i As Integer = 0 To 11
          Select Case i Mod 4 
             ' Task should run to completion.
             Case 0
                tasks(i) = Task.Run( Sub() Thread.Sleep(2000))
             ' Task should be set to canceled state.
             Case 1   
                tasks(i) = Task.Run( Sub() Thread.Sleep(2000), token1)
             Case 2
                ' Task should throw an exception.
                tasks(i) = Task.Run( Sub() 
                                        Throw New NotSupportedException() 
                                     End Sub)
             Case 3
                ' Task should examine cancellation token.
                tasks(i) = Task.Run( Sub() 
                                        Thread.Sleep(2000) 
                                        If token2.IsCancellationRequested
                                           token2.ThrowIfCancellationRequested()
                                        End If
                                        Thread.Sleep(500) 
                                     End Sub, token2)   
          End Select
      Next
      Thread.Sleep(250)
      source2.Cancel()
       
      Try 
         Task.WaitAll(tasks)
      Catch ae As AggregateException
         Console.WriteLine("One or more exceptions occurred:")
         For Each ex in ae.InnerExceptions
             Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message)
         Next
      End Try   
      Console.WriteLine()
      
      Console.WriteLine("Status of tasks:")
      For Each t in tasks
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
         If t.Exception IsNot Nothing Then
            For Each ex in t.Exception.InnerExceptions
               Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                 ex.Message)
            Next
         End If
      Next
   End Sub
End Module
' The example displays output like the following:
'   One or more exceptions occurred:
'      TaskCanceledException: A task was canceled.
'      NotSupportedException: Specified method is not supported.
'      TaskCanceledException: A task was canceled.
'      TaskCanceledException: A task was canceled.
'      NotSupportedException: Specified method is not supported.
'      TaskCanceledException: A task was canceled.
'      TaskCanceledException: A task was canceled.
'      NotSupportedException: Specified method is not supported.
'      TaskCanceledException: A task was canceled.
'   
'   Status of tasks:
'      Task #13: RanToCompletion
'      Task #1: Canceled
'      Task #3: Faulted
'         NotSupportedException: Specified method is not supported.
'      Task #8: Canceled
'      Task #14: RanToCompletion
'      Task #4: Canceled
'      Task #6: Faulted
'         NotSupportedException: Specified method is not supported.
'      Task #7: Canceled
'      Task #15: RanToCompletion
'      Task #9: Canceled
'      Task #11: Faulted
'         NotSupportedException: Specified method is not supported.
'      Task #12: Canceled

タスク ベースの非同期操作での例外処理の詳細については、次を参照してください。例外処理します。For more information on exception handling in task-based asynchronous operations, see Exception Handling.

タスクとカルチャTasks and culture

対象に、デスクトップ アプリ以降、.NET Framework 4.6.NET Framework 4.6を作成し、タスクを呼び出すスレッドのカルチャがスレッドのコンテキストの一部になります。Starting with desktop apps that target the .NET Framework 4.6.NET Framework 4.6, the culture of the thread that creates and invokes a task becomes part of the thread's context. つまり、タスクが実行されるスレッドの現在のカルチャに関係なく、タスクの現在のカルチャは、呼び出し元スレッドのカルチャです。That is, regardless of the current culture of the thread on which the task executes, the current culture of the task is the culture of the calling thread. 前のバージョンの .NET Framework のバージョンを対象とするアプリを.NET Framework 4.6.NET Framework 4.6タスクのカルチャは、タスクが実行されるスレッドのカルチャ。For apps that target versions of the .NET Framework prior to the .NET Framework 4.6.NET Framework 4.6, the culture of the task is the culture of the thread on which the task executes. 詳細については、の「カルチャとタスク ベースの非同期操作」セクションを参照してください、CultureInfoトピック。For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic.

注意

ストア アプリでは、設定と既定のカルチャの取得での 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(Action) Task(Action) Task(Action)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

プロパティ

AsyncState AsyncState AsyncState AsyncState

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

CompletedTask CompletedTask CompletedTask CompletedTask

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

CreationOptions CreationOptions CreationOptions CreationOptions

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

CurrentId CurrentId CurrentId CurrentId

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

Exception Exception Exception Exception

AggregateException が途中で終了する原因となった Task を取得します。Gets the AggregateException that caused the Task to end prematurely. Task が正常に完了した場合、または例外がスローされていない場合は、null が戻ります。If the Task completed successfully or has not yet thrown any exceptions, this will return null.

Factory Factory Factory Factory

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

Id Id Id Id

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

IsCanceled IsCanceled IsCanceled IsCanceled

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

IsCompleted IsCompleted IsCompleted IsCompleted

この Task が完了したかどうかを示す値を取得します。Gets whether this Task has completed.

IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully
IsFaulted IsFaulted IsFaulted IsFaulted

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

Status Status Status Status

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

方法

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

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

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

呼び出し元から提供される状態情報を受け取り、対象の Task が完了したときに実行される継続タスクを作成します。Creates a continuation that receives caller-supplied state information and executes when the target Task completes.

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

呼び出し元から提供される状態情報およびキャンセル トークンを受け取り、対象の Task の完了時に非同期的に実行される継続タスクを作成します。Creates a continuation that receives caller-supplied state information and a cancellation token and that executes asynchronously when the target Task completes.

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

呼び出し元から提供される状態情報およびキャンセル トークンを受け取り、対象の Task の完了時に実行される継続タスクを作成します。Creates a continuation that receives caller-supplied state information and a cancellation token and that executes when the target Task completes. 継続タスクは、指定した一連の条件に基づき、指定したスケジューラを使用して実行されます。The continuation executes based on a set of specified conditions and uses a specified scheduler.

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

呼び出し元から提供される状態情報を受け取り、対象の Task が完了したときに実行される継続タスクを作成します。Creates a continuation that receives caller-supplied state information and executes when the target Task completes. 継続タスクは、指定した一連の条件に基づいて実行されます。The continuation executes based on a set of specified conditions.

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

呼び出し元から提供される状態情報を受け取り、対象の Task が完了したときに非同期的に実行される継続タスクを作成します。Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. 継続タスクは、指定されたスケジューラを使用します。The continuation uses a specified scheduler.

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

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

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

キャンセル トークンを受け取って、対象の Task が完了したときに非同期的に実行される継続タスクを作成します。Creates a continuation that receives a cancellation token and executes asynchronously when the target Task completes.

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

対象のタスクが完了したときに、指定した TaskContinuationOptions に従って実行される継続タスクを作成します。Creates a continuation that executes when the target task competes according to the specified TaskContinuationOptions. この継続タスクは、キャンセル トークンを受け取り、指定されたスケジューラを使用します。The continuation receives a cancellation token and uses a specified scheduler.

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

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

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

ターゲットの Task が完了したときに非同期に実行する継続タスクを作成します。Creates a continuation that executes asynchronously when the target Task completes. 継続タスクは、指定されたスケジューラを使用します。The continuation uses a specified scheduler.

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

呼び出し元から提供される状態情報を受け取り、対象の Task が完了したときに非同期的に実行され、値を返す継続タスクを作成します。Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes and returns a value.

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

対象の Task が完了して値を返したときに非同期的に実行される継続タスクを作成します。Creates a continuation that executes asynchronously when the target Task completes and returns a value. この継続タスクは、呼び出し元から提供される状態情報とキャンセル トークンを受け取ります。The continuation receives caller-supplied state information and a cancellation token.

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

対象の Task が完了したときに、指定したタスク継続オプションに基づいて実行され、値を返す継続タスクを作成します。Creates a continuation that executes based on the specified task continuation options when the target Task completes and returns a value. この継続タスクは、呼び出し元から提供される状態情報とキャンセル トークンを受け取り、指定したスケジューラを使用します。The continuation receives caller-supplied state information and a cancellation token and uses the specified scheduler.

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

対象の Task が完了したときに、指定したタスク継続オプションに基づいて実行される継続タスクを作成します。Creates a continuation that executes based on the specified task continuation options when the target Task completes. この継続タスクは、呼び出し元から提供される状態情報を受け取ります。The continuation receives caller-supplied state information.

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

ターゲットの Task が完了したときに非同期に実行する継続タスクを作成します。Creates a continuation that executes asynchronously when the target Task completes. この継続タスクは、呼び出し元から提供される状態情報を受け取り、指定したスケジューラを使用します。The continuation receives caller-supplied state information and uses a specified scheduler.

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

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

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

対象の Task が完了して値を返したときに非同期的に実行される継続タスクを作成します。Creates a continuation that executes asynchronously when the target Task completes and returns a value. この継続タスクは、キャンセル トークンを受け取ります。The continuation receives a cancellation token.

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

指定された継続のオプションに従って実行され、値を返す継続タスクを作成します。Creates a continuation that executes according to the specified continuation options and returns a value. 継続タスクは、キャンセル トークンを渡され、指定されたスケジューラを使用します。The continuation is passed a cancellation token and uses a specified scheduler.

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

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

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

対象の Task が完了して値を返したときに非同期的に実行される継続タスクを作成します。Creates a continuation that executes asynchronously when the target Task completes and returns a value. 継続タスクは、指定されたスケジューラを使用します。The continuation uses a specified scheduler.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

スレッド プール上で実行する指定された作業をキューに配置し、その作業を表す Task オブジェクトを戻します。Queues the specified work to run on the thread pool and returns a Task object that represents that work.

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

スレッド プール上で実行する指定された作業をキューに配置し、その作業を表す Task オブジェクトを戻します。Queues the specified work to run on the thread pool and returns a Task object that represents that work. キャンセル トークンで作業をキャンセルできます。A cancellation token allows the work to be cancelled.

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

スレッド プール上で実行する作業を指定してキューに配置し、function によって返されるタスクのプロキシを返します。Queues the specified work to run on the thread pool and returns a proxy for the task returned by function.

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

スレッド プール上で実行する作業を指定してキューに配置し、function によって返されるタスクのプロキシを返します。Queues the specified work to run on the thread pool and returns a proxy for the task returned by function.

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

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

スレッド プール上で実行する指定された作業をキューに配置し、その作業を表す Task<TResult> オブジェクトを戻します。Queues the specified work to run on the thread pool and returns a Task<TResult> object that represents that work.

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

スレッド プール上で実行する指定された作業をキューに配置し、その作業を表す Task(TResult) オブジェクトを戻します。Queues the specified work to run on the thread pool and returns a Task(TResult) object that represents that work. キャンセル トークンで作業をキャンセルできます。A cancellation token allows the work to be cancelled.

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

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

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

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

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

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

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

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

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

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

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

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

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

Task の実行が完了するまで待機します。Waits for the Task to complete execution. タスクの完了前にキャンセル トークンが取り消される場合は、待機が終了します。The wait terminates if a cancellation token is canceled before the task completes.

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

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

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

Task の実行が完了するまで待機します。Waits for the Task to complete execution. タスクの完了前に、タイムアウト期間が経過するか、キャンセル トークンが取り消される場合には、待機が終了します。The wait terminates if a timeout interval elapses or a cancellation token is canceled before the task completes.

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

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

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

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

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

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

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

提供されたすべての Task オブジェクトの実行が完了するまで、指定したミリ秒数以内の間、待機します。Waits for all of the provided Task objects to complete execution within a specified number of milliseconds.

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

指定したミリ秒数まで、または待機が取り消されるまで、提供されたすべての Task オブジェクトの実行が完了するのを待機します。Waits for all of the provided Task objects to complete execution within a specified number of milliseconds or until the wait is cancelled.

WaitAll(Task[], TimeSpan) WaitAll(Task[], TimeSpan) WaitAll(Task[], TimeSpan) WaitAll(Task[], TimeSpan)

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

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

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

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

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

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

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

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

指定したミリ秒数まで、または待機トークンが取り消されるまで、提供されたいずれかの Task オブジェクトの実行が完了するのを待機します。Waits for any of the provided Task objects to complete execution within a specified number of milliseconds or until a cancellation token is cancelled.

WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Extension Methods

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

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

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

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

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

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

適用対象

スレッド セーフ

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

こちらもご覧ください