Task Sınıf

Tanım

Ad Alanı:

System.Threading.Tasks

Bütünleştirilmiş Kod:

System.Runtime.dll

Zaman uyumsuz bir işlemi temsil eder.

public ref class Task : IAsyncResult, IDisposable

public class Task : IAsyncResult, IDisposable

type Task = class
    interface IAsyncResult
    interface IDisposable

Public Class Task
Implements IAsyncResult, IDisposable

Devralma

Object

Task

Türetilmiş

System.Threading.Tasks.Task<TResult>

Uygulamalar

IAsyncResult IDisposable

Açıklamalar

Task sınıfı, bir değer döndürmeyen ve genellikle zaman uyumsuz olarak yürütülen tek bir işlemi temsil eder. Tasknesneler, ilk olarak .NET Framework 4'te tanıtılan görev tabanlı zaman uyumsuz desenin merkezi bileşenlerinden biridir. Bir Task nesne tarafından gerçekleştirilen çalışma genellikle ana uygulama iş parçacığında zaman uyumlu olarak değil, bir iş parçacığı havuzu iş parçacığında zaman uyumsuz olarak yürütülür; görevin durumunu belirlemek için özelliğinin yanı IsCanceledsıra , IsCompletedve IsFaulted özelliklerini de kullanabilirsinizStatus. En yaygın olarak, görevin gerçekleştireceğiniz çalışmayı belirtmek için bir lambda ifadesi kullanılır.

Değer döndüren işlemler için sınıfını Task<TResult> kullanırsınız.

Bu bölümdeki konular:

Görev örneği oluşturma örnekleriGörev oluşturma ve yürütmeyiayırma Görev oluşturma ve yürütmeBir veya daha fazla görevin tamamlanmasını bekliyorGörevler ve kültürHata ayıklayıcısı geliştiricileri için

Görev örneği oluşturma

Aşağıdaki örnek dört görev oluşturur ve yürütür. Üç görev, türünde Objectbir Action<T> bağımsız değişken kabul eden adlı actionbir temsilci yürütür. Dördüncü bir görev, görev oluşturma yöntemi çağrısında satır içinde tanımlanan bir Action lambda ifadesi (temsilci) yürütür. Her görevin örneği oluşturulur ve farklı bir şekilde çalıştırılır:

• Görev t1 sınıfı oluşturucu çağrılarak görev örneği oluşturulur, ancak yalnızca görev t2 başlatıldıktan sonra yöntemini çağırarak Start() başlatılır.

• Görev t2 örneği oluşturulur ve yöntemi çağrılarak tek bir yöntem çağrısında TaskFactory.StartNew(Action<Object>, Object) başlatılır.

• Görev t3 örneği oluşturulur ve yöntemi çağrılarak tek bir yöntem çağrısında Run(Action) başlatılır.

• Görev t4 , yöntemi çağrılarak RunSynchronously() ana iş parçacığında zaman uyumlu olarak yürütülür.

Görev t4 zaman uyumlu olarak yürütür çünkü ana uygulama iş parçacığında yürütülür. Kalan görevler genellikle bir veya daha fazla iş parçacığı havuzu iş parçacığında zaman uyumsuz olarak yürütülür.

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

Görev oluşturma ve yürütme

Örnekleri çeşitli yollarla oluşturabilirsiniz Task . En yaygın yaklaşım statik Run yöntemi çağırmaktır. yöntemi, Run varsayılan değerleri kullanarak ve ek parametreler gerektirmeden bir görevi başlatmak için basit bir yol sağlar. Aşağıdaki örnek, döngü oluşturan ve döngü yinelemelerinin sayısını görüntüleyen bir görevi başlatmak için yöntemini kullanır 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

Alternatif olarak statik TaskFactory.StartNew yöntem de vardır. Task.Factory özelliği bir TaskFactory nesnesi döndürür. yönteminin TaskFactory.StartNew aşırı yüklemeleri, görev oluşturma seçeneklerine ve bir görev zamanlayıcıya geçireceğiniz parametreleri belirtmenize olanak sağlar. Aşağıdaki örnek, bir görevi başlatmak için yöntemini kullanır TaskFactory.StartNew . İşlevsel olarak önceki örnekteki kodla eşdeğerdir.

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

Daha eksiksiz örnekler için bkz . Görev Tabanlı Zaman Uyumsuz Programlama.

Görev oluşturma ve yürütmeyi ayırma

sınıfı Task , görevi başlatan ancak yürütme için zamanlamayan oluşturucular da sağlar. Performans nedenleriyle, Task.Run veya TaskFactory.StartNew yöntemi hesaplama görevlerini oluşturmak ve zamanlamak için tercih edilen mekanizmadır, ancak oluşturma ve zamanlamanın ayrılması gereken senaryolar için oluşturucuları kullanabilir ve sonra daha sonra görevi yürütme için zamanlamak üzere yöntemini çağırabilirsiniz Task.Start .

Bir veya daha fazla görev tamamlanmasını bekliyor

Görevler genellikle bir iş parçacığı havuzu iş parçacığında zaman uyumsuz olarak çalıştığından, görevi oluşturan ve başlatan iş parçacığı, görev örneği oluşturulur başlatılmaz yürütülmeye devam eder. Bazı durumlarda, çağıran iş parçacığı ana uygulama iş parçacığı olduğunda, görev yürütülmeye başlamadan önce uygulama sonlandırılabilir. Diğerlerinde uygulamanızın mantığı, çağıran iş parçacığının yalnızca bir veya daha fazla görev yürütmeyi tamamladığında yürütmeye devam etmesi gerektirebilir. Bir veya daha fazla görev tamamlanmasını beklemek için bir Wait yöntem çağırarak çağıran iş parçacığının ve başlattığı zaman uyumsuz görevlerin yürütülmesini eşitleyebilirsiniz.

Tek bir görevin tamamlanmasını beklemek için yöntemini çağırabilirsiniz Task.Wait . yöntemine yapılan Wait bir çağrı, tek sınıf örneği yürütmeyi tamamlayana kadar çağıran iş parçacığını engeller.

Aşağıdaki örnek, bir görev tamamlanana kadar koşulsuz olarak beklemek için parametresiz Wait() yöntemini çağırır. Görev, iki saniye uyku için yöntemini çağırarak Thread.Sleep çalışmanın simülasyonunu oluşturur.

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

Ayrıca, bir görevin tamamlanmasını koşullu olarak bekleyebilirsiniz. Wait(Int32) ve Wait(TimeSpan) yöntemleri, görev bitene veya zaman aşımı aralığı geçene (hangisi önce gelirse) kadar çağıran iş parçacığını engeller. Aşağıdaki örnek iki saniye boyunca uyuyan ancak bir saniyelik bir zaman aşımı değeri tanımlayan bir görevi başlattığından, zaman aşımı süresi dolana kadar ve görevin yürütülmesi tamamlanmadan önce çağıran iş parçacığı engellenir.

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.

ve Wait(Int32, CancellationToken) yöntemlerini çağırarak Wait(CancellationToken) bir iptal belirteci de sağlayabilirsiniz. Belirtecin IsCancellationRequested özelliği true yöntemi yürütülürken Wait ise veya olursatrue, yöntemi bir OperationCanceledExceptionoluşturur.

Bazı durumlarda, bir dizi yürütme görevinin ilkinin tamamlanmasını beklemek isteyebilirsiniz, ancak hangi görev olduğu önemli değildir. Bu amaçla yönteminin aşırı yüklemelerinden Task.WaitAny birini çağırabilirsiniz. Aşağıdaki örnek, her biri rastgele bir sayı oluşturucu tarafından belirlenen bir aralık için uyku moduna geçen üç görev oluşturur. yöntemi ilk WaitAny(Task[]) görevin tamamlanmasını bekler. Örnek daha sonra üç görevi de durumuyla ilgili bilgileri görüntüler.

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

Yöntemini çağırarak WaitAll bir dizi görevi tamamlamayı da bekleyebilirsiniz. Aşağıdaki örnek on görev oluşturur, on görevinin tümünün tamamlanmasını bekler ve sonra durumlarını görüntüler.

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

Bir veya daha fazla görevi tamamlamayı beklediğinizde, aşağıdaki örnekte gösterildiği gibi, çalışan görevlerde oluşan özel durumların yöntemini çağıran iş parçacığına Wait yayıldığını unutmayın. Üçü normal tamamlanan ve üçü özel durum oluşturan 12 görevi başlatır. Kalan altı görevden üçü başlamadan önce iptal edilir ve üçü yürütülürken iptal edilir. Yöntem çağrısında WaitAll özel durumlar oluşturulur ve bir try/catch blok tarafından işlenir.

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

Görev tabanlı zaman uyumsuz işlemlerde özel durum işleme hakkında daha fazla bilgi için bkz. Özel Durum İşleme.

Görevler ve kültür

.NET Framework 4.6'yı hedefleyen masaüstü uygulamalarından başlayarak, bir görevi oluşturan ve çağıran iş parçacığının kültürü iş parçacığının bağlamının bir parçası olur. Yani, görevin yürütülürken iş parçacığının geçerli kültürü ne olursa olsun, görevin geçerli kültürü çağıran iş parçacığının kültürüdür. .NET Framework 4.6'dan önceki .NET Framework sürümlerini hedefleyen uygulamalar için, görevin kültürü görevin yürütüldiği iş parçacığının kültürüdür. Daha fazla bilgi için konunun "Kültür ve görev tabanlı zaman uyumsuz işlemler" bölümüne CultureInfo bakın.

Not

Mağaza uygulamaları, varsayılan kültürü ayarlama ve alma Windows Çalışma Zamanı izler.

Hata ayıklayıcısı geliştiricileri için

Özel hata ayıklayıcıları uygulayan geliştiriciler için, görevin birkaç iç ve özel üyesi yararlı olabilir (bunlar yayından yayına değişebilir). alan m_taskId özelliği için Id yedekleme deposu görevi görür, ancak bu alana doğrudan bir hata ayıklayıcıdan erişmek, özelliğin getter yöntemi aracılığıyla aynı değere erişmekten daha verimli olabilir ( s_taskIdCounter sayaç, bir görevin sonraki kullanılabilir kimliğini almak için kullanılır). Benzer şekilde, m_stateFlags alanı görevin geçerli yaşam döngüsü aşaması hakkındaki bilgileri depolar ve bu bilgilere özelliği aracılığıyla Status da erişilebilir. alanı m_action , görevin temsilcisine bir başvuru depolar ve m_stateObject alan, geliştirici tarafından göreve geçirilen zaman uyumsuz durumu depolar. Son olarak, yığın çerçevelerini ayrıştıran hata ayıklayıcılar için yöntemi, InternalWait bir görevin bekleme işlemine girdiği zaman için olası bir işaretleyici sağlar.

Oluşturucular

Task(Action)	Belirtilen eylemle yeni Task bir başlatır.
Task(Action, CancellationToken)	Belirtilen eylem ve CancellationTokenile yeni Task bir başlatır.
Task(Action, CancellationToken, TaskCreationOptions)	Belirtilen eylem ve oluşturma seçenekleriyle yeni Task bir başlatır.
Task(Action, TaskCreationOptions)	Belirtilen eylem ve oluşturma seçenekleriyle yeni Task bir başlatır.
Task(Action<Object>, Object)	Belirtilen eylem ve durumla yeni Task bir başlatır.
Task(Action<Object>, Object, CancellationToken)	Belirtilen eylem, durum ve seçeneklerle yeni Task bir başlatır.
Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)	Belirtilen eylem, durum ve seçeneklerle yeni Task bir başlatır.
Task(Action<Object>, Object, TaskCreationOptions)	Belirtilen eylem, durum ve seçeneklerle yeni Task bir başlatır.

Özellikler

AsyncState	oluşturulduğunda sağlanan durum nesnesini veya sağlanmazsa Task null değerini alır.
CompletedTask	Başarıyla tamamlanmış bir görevi alır.
CreationOptions	Bu görevi oluşturmak için kullanılan öğesini TaskCreationOptions alır.
CurrentId	Şu anda yürütülmekte Taskolan öğesinin kimliğini döndürür.
Exception	'nin AggregateException erken bitmesini sağlayan öğesini Task alır. Task başarıyla tamamlandıysa veya henüz herhangi bir özel durum oluşturduysa, bu döndürürnull.
Factory	ve örneklerini oluşturmak ve yapılandırmak için fabrika yöntemlerine TaskTask<TResult> erişim sağlar.
Id	Bu Task örnek için bir kimlik alır.
IsCanceled	Bu Task örneğin iptal edildiği için yürütmeyi tamamlayıp tamamlamadığını alır.
IsCompleted	Görevin tamamlanıp tamamlanmadığını gösteren bir değer alır.
IsCompletedSuccessfully	Görevin tamamlanmaya çalışıp çalışmadığını alır.
IsFaulted	İşlenmeyen Task bir özel durum nedeniyle tamamlanıp tamamlanmadığını alır.
Status	Bu görevin değerini TaskStatus alır.

Yöntemler

ConfigureAwait(Boolean)	Bunu Taskbeklemek için kullanılan bir awaiter yapılandırıyor.
ConfigureAwait(ConfigureAwaitOptions)	Bunu Taskbeklemek için kullanılan bir awaiter yapılandırıyor.
ContinueWith(Action<Task,Object>, Object)	Çağıran tarafından sağlanan durum bilgilerini alan ve hedef Task tamamlandığında yürütülen bir devamlılık oluşturur.
ContinueWith(Action<Task,Object>, Object, CancellationToken)	Çağıran tarafından sağlanan durum bilgilerini ve iptal belirtecini alan ve hedef Task tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur.
ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Çağıran tarafından sağlanan durum bilgilerini ve iptal belirtecini alan ve hedef Task tamamlandığında yürütülen bir devamlılık oluşturur. Devamlılık, belirtilen koşullar kümesine göre yürütülür ve belirtilen zamanlayıcıyı kullanır.
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)	Çağıran tarafından sağlanan durum bilgilerini alan ve hedef Task tamamlandığında yürütülen bir devamlılık oluşturur. Devamlılık, belirtilen koşullar kümesine göre yürütülür.
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	Çağıran tarafından sağlanan durum bilgilerini alan ve hedef Task tamamlandığında zaman uyumsuz olarak yürüten bir devamlılık oluşturur. Devamlılık, belirtilen bir zamanlayıcıyı kullanır.
ContinueWith(Action<Task>)	Hedef Task tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur.
ContinueWith(Action<Task>, CancellationToken)	İptal belirteci alan ve hedef Task tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur.
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Hedef görev belirtilen TaskContinuationOptionsdeğerine göre rekabet ettiğinde yürütülen bir devamlılık oluşturur. Devamlılık bir iptal belirteci alır ve belirtilen zamanlayıcıyı kullanır.
ContinueWith(Action<Task>, TaskContinuationOptions)	Hedef görev belirtilen TaskContinuationOptionsdeğerine göre tamamlandığında yürütülen bir devamlılık oluşturur.
ContinueWith(Action<Task>, TaskScheduler)	Hedef Task tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur. Devamlılık, belirtilen bir zamanlayıcıyı kullanır.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	Çağıran tarafından sağlanan durum bilgilerini alan ve hedef Task tamamlanıp bir değer döndürdüğünde zaman uyumsuz olarak yürütülen bir devamlılık oluşturur.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	Hedef Task tamamlandığında zaman uyumsuz olarak yürütülen ve bir değer döndüren bir devamlılık oluşturur. Devamlılık, çağıran tarafından sağlanan durum bilgilerini ve bir iptal belirtecini alır.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Hedef Task tamamlandığında ve bir değer döndürdüğünde belirtilen görev devamlılığı seçeneklerine göre yürütülen bir devamlılık oluşturur. Devamlılık, çağıran tarafından sağlanan durum bilgilerini ve bir iptal belirtecini alır ve belirtilen zamanlayıcıyı kullanır.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	Hedef Task tamamlandığında belirtilen görev devamlılığı seçeneklerine göre yürütülen bir devamlılık oluşturur. Devamlılık, çağıran tarafından sağlanan durum bilgilerini alır.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	Hedef Task tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur. Devamlılık, çağıran tarafından sağlanan durum bilgilerini alır ve belirtilen zamanlayıcıyı kullanır.
ContinueWith<TResult>(Func<Task,TResult>)	Hedef Task<TResult> tamamlandığında zaman uyumsuz olarak yürütülen ve bir değer döndüren bir devamlılık oluşturur.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	Hedef Task tamamlandığında zaman uyumsuz olarak yürütülen ve bir değer döndüren bir devamlılık oluşturur. Devamlılık bir iptal belirteci alır.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Belirtilen devamlılık seçeneklerine göre yürütülen bir devamlılık oluşturur ve bir değer döndürür. Devamlılık bir iptal belirteci geçirilir ve belirtilen zamanlayıcıyı kullanır.
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)	Belirtilen devamlılık seçeneklerine göre yürütülen bir devamlılık oluşturur ve bir değer döndürür.
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	Hedef Task tamamlandığında zaman uyumsuz olarak yürütülen ve bir değer döndüren bir devamlılık oluşturur. Devamlılık, belirtilen bir zamanlayıcıyı kullanır.
Delay(Int32)	Belirtilen sayıda milisaniyeden sonra tamamlanan bir görev oluşturur.
Delay(Int32, CancellationToken)	Belirtilen sayıda milisaniyeden sonra tamamlanan iptal edilebilir bir görev oluşturur.
Delay(TimeSpan)	Belirtilen zaman aralığından sonra tamamlanan bir görev oluşturur.
Delay(TimeSpan, CancellationToken)	Belirtilen zaman aralığından sonra tamamlanan iptal edilebilir bir görev oluşturur.
Delay(TimeSpan, TimeProvider)	Belirtilen zaman aralığından sonra tamamlanan bir görev oluşturur.
Delay(TimeSpan, TimeProvider, CancellationToken)	Belirtilen zaman aralığından sonra tamamlanan iptal edilebilir bir görev oluşturur.
Dispose()	Task sınıfının geçerli örneği tarafından kullanılan tüm kaynakları serbest bırakır.
Dispose(Boolean)	Task, tüm yönetilmeyen kaynaklarını serbest bırakarak atılır.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
FromCanceled(CancellationToken)	Belirtilen iptal Task belirteciyle iptal nedeniyle tamamlanan bir oluşturur.
FromCanceled<TResult>(CancellationToken)	Belirtilen iptal Task<TResult> belirteciyle iptal nedeniyle tamamlanan bir oluşturur.
FromException(Exception)	Task Belirtilen özel durumla tamamlanmış bir oluşturur.
FromException<TResult>(Exception)	Task<TResult> Belirtilen özel durumla tamamlanmış bir oluşturur.
FromResult<TResult>(TResult)	Belirtilen sonuçla başarıyla tamamlanan bir Task<TResult> oluşturur.
GetAwaiter()	Bunu Taskbeklemek için kullanılan bir awaiter alır.
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetType()	Type Geçerli örneğini alır. (Devralındığı yer: Object)
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
Run(Action)	Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve bu çalışmayı temsil eden bir Task nesne döndürür.
Run(Action, CancellationToken)	Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve bu çalışmayı temsil eden bir Task nesne döndürür. İptal belirteci, henüz başlatılmamışsa işin iptal edilmesini sağlar.
Run(Func<Task>)	Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve tarafından functiondöndürülen görev için bir ara sunucu döndürür.
Run(Func<Task>, CancellationToken)	Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve tarafından functiondöndürülen görev için bir ara sunucu döndürür. İptal belirteci, henüz başlatılmamışsa işin iptal edilmesini sağlar.
Run<TResult>(Func<Task<TResult>>)	Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve tarafından functiondöndürülen için Task(TResult) bir proxy döndürür. İptal belirteci, henüz başlatılmamışsa işin iptal edilmesini sağlar.
Run<TResult>(Func<Task<TResult>>, CancellationToken)	Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve tarafından functiondöndürülen için Task(TResult) bir proxy döndürür.
Run<TResult>(Func<TResult>)	Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve bu çalışmayı temsil eden bir Task<TResult> nesne döndürür. İptal belirteci, henüz başlatılmamışsa işin iptal edilmesini sağlar.
Run<TResult>(Func<TResult>, CancellationToken)	Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve bu çalışmayı temsil eden bir Task(TResult) nesne döndürür.
RunSynchronously()	geçerli TaskTaskSchedulerüzerinde zaman uyumlu olarak çalıştırır.
RunSynchronously(TaskScheduler)	sağlanan Task üzerinde TaskScheduler zaman uyumlu olarak çalıştırır.
Start()	Taskgeçerli ile yürütülmek TaskSchedulerüzere zamanlayarak öğesini başlatır.
Start(TaskScheduler)	Task, belirtilen öğesine yürütülmek üzere TaskSchedulerzamanlayarak başlatır.
ToString()	Geçerli nesneyi temsil eden dizeyi döndürür. (Devralındığı yer: Object)
Wait()	yürütmenin Task tamamlanmasını bekler.
Wait(CancellationToken)	yürütmenin Task tamamlanmasını bekler. Görev tamamlanmadan önce iptal belirteci iptal edilirse bekleme sonlandırılır.
Wait(Int32)	belirtilen milisaniye içinde yürütmenin Task tamamlanmasını bekler.
Wait(Int32, CancellationToken)	yürütmenin Task tamamlanmasını bekler. Görev tamamlanmadan önce bir zaman aşımı aralığı geçtiğinde veya iptal belirteci iptal edilirse bekleme sonlandırılır.
Wait(TimeSpan)	Yürütmenin Task belirli bir zaman aralığı içinde tamamlanmasını bekler.
Wait(TimeSpan, CancellationToken)	yürütmenin Task tamamlanmasını bekler.
WaitAll(Task[])	Sağlanan Task tüm nesnelerin yürütülmesini bekler.
WaitAll(Task[], CancellationToken)	Bekleme iptal edilmediği sürece sağlanan Task tüm nesnelerin yürütülmesini bekler.
WaitAll(Task[], Int32)	Sağlanan Task tüm nesnelerin belirli bir milisaniye içinde yürütmeyi tamamlanmasını bekler.
WaitAll(Task[], Int32, CancellationToken)	Sağlanan Task tüm nesnelerin belirli bir milisaniye içinde veya bekleme iptal edilene kadar yürütülmesini bekler.
WaitAll(Task[], TimeSpan)	Sağlanan iptal edilebilir Task nesnelerin tümünün belirtilen zaman aralığı içinde yürütülmesini bekler.
WaitAny(Task[])	Sağlanan Task nesnelerden herhangi birinin yürütülmesini bekler.
WaitAny(Task[], CancellationToken)	Bekleme iptal edilmediği sürece sağlanan Task nesnelerden herhangi birinin yürütülmesini bekler.
WaitAny(Task[], Int32)	Sağlanan Task nesnelerden herhangi birinin belirtilen sayıda milisaniye içinde yürütmeyi tamamlanmasını bekler.
WaitAny(Task[], Int32, CancellationToken)	Sağlanan Task nesnelerden herhangi birinin belirli bir milisaniye içinde veya iptal belirteci iptal edilene kadar yürütmenin tamamlanmasını bekler.
WaitAny(Task[], TimeSpan)	Sağlanan Task nesnelerden herhangi birinin belirli bir zaman aralığı içinde yürütülmesini bekler.
WaitAsync(CancellationToken)	Bu Task tamamlandığında veya belirtilen CancellationToken iptal istendiğinde tamamlanacak bir Task alır.
WaitAsync(TimeSpan)	Bu Task tamamlandığında veya belirtilen zaman aşımı sona erdiğinde tamamlanacak bir Task alır.
WaitAsync(TimeSpan, CancellationToken)	Bu Task tamamlandığında, belirtilen zaman aşımı sona erdiğinde veya belirtilen CancellationToken iptal istendiğinde tamamlanacak bir Task alır.
WaitAsync(TimeSpan, TimeProvider)	Bu Task tamamlandığında veya belirtilen zaman aşımı sona erdiğinde tamamlanacak bir Task alır.
WaitAsync(TimeSpan, TimeProvider, CancellationToken)	Bu Task tamamlandığında, belirtilen zaman aşımı sona erdiğinde veya belirtilen CancellationToken iptal istendiğinde tamamlanacak bir Task alır.
WhenAll(IEnumerable<Task>)	Numaralandırılabilir bir koleksiyondaki Task tüm nesneler tamamlandığında tamamlanacak bir görev oluşturur.
WhenAll(Task[])	Bir dizideki Task tüm nesneler tamamlandığında tamamlanacak bir görev oluşturur.
WhenAll<TResult>(IEnumerable<Task<TResult>>)	Numaralandırılabilir bir koleksiyondaki Task<TResult> tüm nesneler tamamlandığında tamamlanacak bir görev oluşturur.
WhenAll<TResult>(Task<TResult>[])	Bir dizideki Task<TResult> tüm nesneler tamamlandığında tamamlanacak bir görev oluşturur.
WhenAny(IEnumerable<Task>)	Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur.
WhenAny(Task, Task)	Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur.
WhenAny(Task[])	Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur.
WhenAny<TResult>(IEnumerable<Task<TResult>>)	Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur.
WhenAny<TResult>(Task<TResult>, Task<TResult>)	Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur.
WhenAny<TResult>(Task<TResult>[])	Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur.
Yield()	Beklendiğinde zaman uyumsuz olarak geçerli bağlama geri döndüren bir beklenebilir görev oluşturur.

Belirtik Arabirim Kullanımları

IAsyncResult.AsyncWaitHandle	Görevin tamamlanmasını beklemek için kullanılabilecek bir WaitHandle alır.
IAsyncResult.CompletedSynchronously	İşlemin zaman uyumlu olarak tamamlanıp tamamlanmadığına ilişkin bir gösterge alır.

Uzantı Metotları

İş Parçacığı Güvenliği

dışındaki Dispose()tüm üyeleri Taskiş parçacığı açısından güvenlidir ve aynı anda birden çok iş parçacığından kullanılabilir.

Ayrıca bkz.

• Task<TResult>
• Görev Paralel Kitaplığı (TPL)
• .NET'te görev tabanlı zaman uyumsuz desen (TAP): Giriş ve genel bakış
• Görev Tabanlı Zaman Uyumsuz Programlama
• .NET Core ve .NET Standard ile Paralel Programlama Örnekleri