Task クラス

リファレンス

定義

名前空間:: System.Threading.Tasks

アセンブリ:: System.Threading.Tasks.dll

アセンブリ:: System.Runtime.dll

アセンブリ:: mscorlib.dll

アセンブリ:: netstandard.dll

重要

一部の情報は、リリース前に大きく変更される可能性があるプレリリースされた製品に関するものです。 Microsoft は、ここに記載されている情報について、明示または黙示を問わず、一切保証しません。

非同期操作を表します。

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

継承: Object
Task

派生: System.Threading.Tasks.Task<TResult>

実装: IAsyncResult IDisposable

注釈

クラスは Task 、値を返さない 1 つの操作を表し、通常は非同期的に実行されます。 Taskオブジェクトは、.NET Framework 4 で最初に導入されたタスクベースの非同期パターンの中心的なコンポーネントの 1 つです。オブジェクトによって実行されるTask作業は、通常、メインアプリケーションスレッドではなくスレッドプールスレッドで非同期的に実行されるため、プロパティとプロパティ、IsCanceled IsCompleted、および IsFaulted プロパティを使用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

open System.Threading
open System.Threading.Tasks

let action =
    fun (obj: obj) -> printfn $"Task={Task.CurrentId}, obj={obj}, Thread={Thread.CurrentThread.ManagedThreadId}"

// Create a task but do not start it.
let t1 = new Task(action, "alpha")

// Construct a started task
let t2 = Task.Factory.StartNew(action, "beta")
// Block the main thread to demonstrate that t2 is executing
t2.Wait()

// Launch t1
t1.Start()
printfn $"t1 has been launched. (Main Thread={Thread.CurrentThread.ManagedThreadId})"
// Wait for the task to finish.
t1.Wait()

// Construct a started task using Task.Run.
let taskData = "delta"

let t3 =
    Task.Run(fun () -> printfn $"Task={Task.CurrentId}, obj={taskData}, Thread={Thread.CurrentThread.ManagedThreadId}")
// Wait for the task to finish.
t3.Wait()

// Construct an unstarted task
let 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

open System.Threading.Tasks

let main =
    task {
        do!
            Task.Run(fun () ->
                for i = 0 to 1000000 do
                    printfn $"Finished {i} loop iterations")
    }

main.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.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

open System.Threading.Tasks

let t =
    Task.Factory.StartNew(fun () ->
        // Just loop.
        for i = 0 to 1000000 do
            printfn $"Finished {i} loop iterations")

t.Wait()


// The example displays the following output:
//        Finished 1000001 loop iterations

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Factory.StartNew(Sub()
                                  ' Just loop.
                                  Dim ctr As Integer = 0
                                  For ctr = 0 to 1000000
                                  Next
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr)
                               End Sub)
      t.Wait()
   End Sub
End Module
' The example displays the following output:
'       Finished 1000001 loop iterations

詳細な例については、「タスクベースの非同期プログラミング」を参照してください。

タスクの作成と実行の分離

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

1 つ以上のタスクが完了するのを待つ

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

open System
open System.Threading
open System.Threading.Tasks

let rand = Random()

// Wait on a single task with no timeout specified.
let taskA = Task.Run(fun () -> Thread.Sleep 2000)
printfn $"taskA Status: {taskA.Status}"
try 
    taskA.Wait()
    printfn $"taskA Status: {taskA.Status}"

with :? AggregateException ->
    printfn "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.

open System
open System.Threading
open System.Threading.Tasks

// Wait on a single task with a timeout specified.
let taskA = Task.Run(fun () -> Thread.Sleep 2000)

try
    taskA.Wait 1000 |> ignore // Wait for 1 second.
    let completed = taskA.IsCompleted
    printfn $"Task A completed: {completed}, Status: {taskA.Status}"

    if not completed then
        printfn "Timed out before task A completed."

with :? AggregateException ->
    printfn "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(Int32, CancellationToken) メソッドを呼び出してキャンセルトークンをWait(CancellationToken)指定することもできます。メソッドの実行中にトークンの IsCancellationRequested プロパティが true またはになったtrueWait場合、メソッドはをOperationCanceledExceptionスローします。

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

open System
open System.Threading
open System.Threading.Tasks

let rnd = new Random()

let tasks =
    [| for _ = 0 to 2 do
           Task.Run(fun () -> rnd.Next(500, 3000) |> Thread.Sleep) |]

try
    let index = Task.WaitAny tasks
    printfn $"Task #{tasks[index].Id} completed first.\n"
    printfn "Status of all tasks:"

    for t in tasks do
        printfn $"   Task #{t.Id}: {t.Status}"

with :? AggregateException ->
    printfn "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

open System
open System.Threading
open System.Threading.Tasks

// Wait for all tasks to complete.
let tasks =
    [| for _ = 0 to 9 do
           Task.Run(fun () -> Thread.Sleep 2000) |]

try
    Task.WaitAll tasks

with :? AggregateException as ae ->
    printfn "One or more exceptions occurred: "

    for ex in ae.Flatten().InnerExceptions do
        printfn $"   {ex.Message}"

printfn "Status of completed tasks:"

for t in tasks do
    printfn $"   Task #{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

open System
open System.Threading
open System.Threading.Tasks

// Create a cancellation token and cancel it.
let source1 = new CancellationTokenSource()
let token1 = source1.Token
source1.Cancel()
// Create a cancellation token for later cancellation.
let source2 = new CancellationTokenSource()
let token2 = source2.Token

// Create a series of tasks that will complete, be cancelled,
// timeout, or throw an exception.
let tasks =
    [| for i in 0..11 do
           match i % 4 with
           // Task should run to completion.
           | 0 -> Task.Run(fun () -> Thread.Sleep 2000)
           // Task should be set to canceled state.
           | 1 -> Task.Run(fun () -> Thread.Sleep 2000, token1)
           // Task should throw an exception.
           | 2 -> Task.Run(fun () -> NotSupportedException())
           // Task should examine cancellation token.
           | _ ->
               Task.Run(fun () ->
                   Thread.Sleep 2000

                   if token2.IsCancellationRequested then
                       token2.ThrowIfCancellationRequested()

                   Thread.Sleep 500, token2) |]


Thread.Sleep 250
source2.Cancel()

try
    Task.WaitAll tasks

with :? AggregateException as ae ->
    printfn "One or more exceptions occurred:"

    for ex in ae.InnerExceptions do
        printfn $"   {ex.GetType().Name}: {ex.Message}"

printfn "\nStatus of tasks:"

for t in tasks do
    printfn $"   Task #{t.Id}: {t.Status}"

    if isNull t.Exception |> not then
        for ex in t.Exception.InnerExceptions do
            printfn $"      {ex.GetType().Name}: {ex.Message}"

// The example displays output like the following:
//   One or more exceptions occurred:
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//
//   Status of tasks:
//      Task #13: RanToCompletion
//      Task #1: Canceled
//      Task #3: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #8: Canceled
//      Task #14: RanToCompletion
//      Task #4: Canceled
//      Task #6: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #7: Canceled
//      Task #15: RanToCompletion
//      Task #9: Canceled
//      Task #11: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #12: Canceled

Imports System.Threading
Imports System.Threading.Tasks

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

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

タスクとカルチャ

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

注意

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

デバッガー開発者向け

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

コンストラクター

Task(Action)	指定したアクションで新しい Task を初期化します。
Task(Action, CancellationToken)	指定したアクションおよび Task で新しい CancellationToken を初期化します。
Task(Action, CancellationToken, TaskCreationOptions)	指定したアクションと作成オプションで新しい Task を初期化します。
Task(Action, TaskCreationOptions)	指定したアクションと作成オプションで新しい Task を初期化します。
Task(Action<Object>, Object)	指定したアクションと状態で新しい Task を初期化します。
Task(Action<Object>, Object, CancellationToken)	指定したアクション、状態、およびオプションで新しい Task を初期化します。
Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)	指定したアクション、状態、およびオプションで新しい Task を初期化します。
Task(Action<Object>, Object, TaskCreationOptions)	指定したアクション、状態、およびオプションで新しい Task を初期化します。

プロパティ

AsyncState	Task が作成されたときに渡される状態オブジェクトを取得します。渡されなかった場合は null。
CompletedTask	既に正常に完了したタスクを取得します。
CreationOptions	このタスクの作成に使用される TaskCreationOptions を取得します。
CurrentId	現在実行中の Task の ID を返します。
Exception	AggregateException が途中で終了する原因となった Task を取得します。 Task が正常に完了した場合、または例外がスローされていない場合は、`null` が返されます。
Factory	Task および Task<TResult> インスタンスを作成して構成するためのファクトリメソッドへのアクセスを提供します。
Id	この Task インスタンスの ID を取得します。
IsCanceled	この Task インスタンスの実行が取り消されることによって完了したかどうかを示す値を取得します。
IsCompleted	タスクが完了したかどうかを示す値を取得します。
IsCompletedSuccessfully	タスクが完了まで実行されたかどうかを示す値を取得します。
IsFaulted	処理されない例外が発生したことが原因で Task が完了したかどうかを示す値を取得します。
Status	このタスクの TaskStatus を取得します。

メソッド

ConfigureAwait(Boolean)	この Task を待機するために使用する awaiter を構成します。
ConfigureAwait(ConfigureAwaitOptions)	この 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)	指定した期間の後に完了するキャンセル可能タスクを作成します。
Delay(TimeSpan, TimeProvider)	指定した期間の後に完了するタスクを作成します。
Delay(TimeSpan, TimeProvider, 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()	現在の Task で TaskScheduler を同期的に実行します。
RunSynchronously(TaskScheduler)	指定された Task で TaskScheduler を同期的に実行します。
Start()	現在の Task に TaskScheduler の実行をスケジュールし、それを開始します。
Start(TaskScheduler)	指定された Task に TaskScheduler の実行をスケジュールし、それを開始します。
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取得します。
WaitAsync(TimeSpan, TimeProvider)	TaskこれがTask完了するか、指定したタイムアウトの有効期限が切れたときに完了するを取得します。
WaitAsync(TimeSpan, TimeProvider, 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)	この Task が DispatcherOperation に関連付けられているかどうかを示す値を返します。
AsAsyncAction(Task)	開始されたタスクを表す Windows ランタイム非同期アクションを返します。

適用対象

スレッドセーフ

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

Task クラス

定義

注釈

タスクのインスタンス化

タスクの作成と実行

タスクの作成と実行の分離

1 つ以上のタスクが完了するのを待つ

タスクとカルチャ

デバッガー開発者向け

コンストラクター

プロパティ

メソッド

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

拡張メソッド

適用対象

スレッドセーフ

こちらもご覧ください

その他のリソース

Task クラス

定義

注釈

タスクのインスタンス化

タスクの作成と実行

タスクの作成と実行の分離

1 つ以上のタスクが完了するのを待つ

タスクとカルチャ

デバッガー開発者向け

コンストラクター

プロパティ

メソッド

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

拡張メソッド

適用対象

スレッド セーフ

こちらもご覧ください

その他のリソース

スレッドセーフ