Task Sınıf

Tanım

Zaman uyumsuz bir işlemi temsil eder.Represents an asynchronous operation.

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
Devralma
Task
Türetilmiş
Uygulamalar

Açıklamalar

TaskSınıfı, bir değer döndürmeyen ve genellikle zaman uyumsuz olarak yürütülen tek bir işlemi temsil eder.The Task class represents a single operation that does not return a value and that usually executes asynchronously. Task nesneler, ilk olarak .NET Framework 4 ' te tanıtılan görev tabanlı zaman uyumsuz modelin merkezi bileşenlerinden biridir.Task objects are one of the central components of the task-based asynchronous pattern first introduced in the .NET Framework 4. Bir nesne tarafından gerçekleştirilen iş, Task genellikle ana uygulama iş parçacığı üzerinde zaman uyumsuz olarak değil, iş parçacığı havuzu iş parçacığında zaman uyumsuz olarak yürütülebildiğinden, Status IsCanceled IsCompleted IsFaulted bir görevin durumunu belirleyebilmek için,, ve özelliklerini de kullanabilirsiniz.Because the work performed by a Task object typically executes asynchronously on a thread pool thread rather than synchronously on the main application thread, you can use the Status property, as well as the IsCanceled, IsCompleted, and IsFaulted properties, to determine the state of a task. En yaygın olarak, görevin gerçekleştireceği işi belirtmek için bir lambda ifadesi kullanılır.Most commonly, a lambda expression is used to specify the work that the task is to perform.

Değer döndüren işlemler için Task<TResult> sınıfını kullanırsınız.For operations that return values, you use the Task<TResult> class.

Bu bölümdeki konular:In this section:

Görev örneği oluşturma örnekleri Task instantiation examples
Bir görevi oluşturma ve yürütme Creating and executing a task
Görev oluşturma ve yürütmeyi ayırma Separating task creation and execution
Bir veya daha fazla görevin tamamlanması bekleniyor Waiting for one or more tasks to complete
Görevler ve kültür Tasks and culture
Hata ayıklayıcı geliştiricileri içinFor debugger developers

Görev örneklemesiTask instantiation

Aşağıdaki örnek dört görev oluşturur ve yürütür.The following example creates and executes four tasks. Üç görev Action<T> action , türünde bir bağımsız değişken kabul eden adlı bir temsilciyi yürütür Object .Three tasks execute an Action<T> delegate named action, which accepts an argument of type Object. Dördüncü görev, Action görev oluşturma yöntemine yapılan çağrıda satır içi olarak tanımlanan bir lambda ifadesini (bir temsilci) yürütür.A fourth task executes a lambda expression (an Action delegate) that is defined inline in the call to the task creation method. Her görev örneği oluşturulur ve farklı bir şekilde çalıştırılır:Each task is instantiated and run in a different way:

  • Görev, t1 bir görev sınıfı Oluşturucusu çağırarak başlatılır, ancak Start() yöntemi yalnızca görev başlatıldıktan sonra çağırarak başlatılır t2 .Task t1 is instantiated by calling a Task class constructor, but is started by calling its Start() method only after task t2 has started.

  • Görev, t2 yöntemi çağırarak tek bir yöntem çağrısında oluşturulur ve başlatılır TaskFactory.StartNew(Action<Object>, Object) .Task t2 is instantiated and started in a single method call by calling the TaskFactory.StartNew(Action<Object>, Object) method.

  • Görev, t3 yöntemi çağırarak tek bir yöntem çağrısında oluşturulur ve başlatılır Run(Action) .Task t3 is instantiated and started in a single method call by calling the Run(Action) method.

  • Görev, t4 yöntemi çağırarak ana iş parçacığında zaman uyumlu olarak yürütülür RunSynchronously() .Task t4 is executed synchronously on the main thread by calling the RunSynchronously() method.

Görev t4 zaman uyumlu olarak yürütülüyorsa, ana uygulama iş parçacığında yürütülür.Because task t4 executes synchronously, it executes on the main application thread. Kalan görevler, genellikle bir veya daha fazla iş parçacığı havuzu iş parçacığında zaman uyumsuz olarak yürütülür.The remaining tasks execute asynchronously typically on one or more thread pool threads.

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

class Example
{
    static void Main()
    {
        Action<object> action = (object obj) =>
                                {
                                   Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                   Task.CurrentId, obj,
                                   Thread.CurrentThread.ManagedThreadId);
                                };

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

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

        // Launch t1 
        t1.Start();
        Console.WriteLine("t1 has been launched. (Main Thread={0})",
                          Thread.CurrentThread.ManagedThreadId);
        // Wait for the task to finish.
        t1.Wait();

        // Construct a started task using Task.Run.
        String taskData = "delta";
        Task t3 = Task.Run( () => {Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                                     Task.CurrentId, taskData,
                                                      Thread.CurrentThread.ManagedThreadId);
                                   });
        // Wait for the task to finish.
        t3.Wait();

        // Construct an unstarted task
        Task t4 = new Task(action, "gamma");
        // Run it synchronously
        t4.RunSynchronously();
        // Although the task was run synchronously, it is a good practice
        // to wait for it in the event exceptions were thrown by the task.
        t4.Wait();
    }
}
// The example displays output like the following:
//       Task=1, obj=beta, Thread=3
//       t1 has been launched. (Main Thread=1)
//       Task=2, obj=alpha, Thread=4
//       Task=3, obj=delta, Thread=3
//       Task=4, obj=gamma, Thread=1
Imports System.Threading
Imports System.Threading.Tasks

Module Example
    Public Sub Main()
        Dim action As Action(Of Object) = 
              Sub(obj As Object)
                 Console.WriteLine("Task={0}, obj={1}, Thread={2}", 
                 Task.CurrentId, obj,
                 Thread.CurrentThread.ManagedThreadId)
              End Sub

        ' Construct an unstarted task
        Dim t1 As New Task(action, "alpha")

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

        ' Launch t1 
        t1.Start()
        Console.WriteLine("t1 has been launched. (Main Thread={0})",
                          Thread.CurrentThread.ManagedThreadId)
        ' Wait for the task to finish.
        t1.Wait()

        ' Construct a started task using Task.Run.
        Dim taskData As String = "delta"
        Dim t3 As Task = Task.Run(Sub()
                                     Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                     Task.CurrentId, taskData,
                                     Thread.CurrentThread.ManagedThreadId)
                                  End Sub)
        ' Wait for the task to finish.
        t3.Wait()
        
        ' Construct an unstarted task
        Dim t4 As New Task(action, "gamma")
        ' Run it synchronously
        t4.RunSynchronously()
        ' Although the task was run synchronously, it is a good practice
        ' to wait for it in the event exceptions were thrown by the task.
        t4.Wait()
    End Sub
End Module
' The example displays output like the following:
'       Task=1, obj=beta, Thread=3
'       t1 has been launched. (Main Thread=1)
'       Task=2, obj=alpha, Thread=3
'       Task=3, obj=delta, Thread=3
'       Task=4, obj=gamma, Thread=1

Bir görevi oluşturma ve yürütmeCreating and executing a task

Task örnekler çeşitli yollarla oluşturulabilir.Task instances may be created in a variety of ways. .NET Framework 4,5 ile başlayarak kullanılabilen en yaygın yaklaşım, statik yöntemi çağırmalıdır Run .The most common approach, which is available starting with the .NET Framework 4.5, is to call the static Run method. RunYöntemi, varsayılan değerleri kullanarak ve ek parametreler istemeden bir görevi başlatmak için basit bir yol sağlar.The Run method provides a simple way to start a task using default values and without requiring additional parameters. Aşağıdaki örnek, Run(Action) döngüsü yineleme sayısını gösteren bir görevi başlatmak için yöntemini kullanır:The following example uses the Run(Action) method to start a task that loops and then displays the number of loop iterations:

using System;
using System.Threading.Tasks;

public class Example
{
   public static async Task Main()
   {
      await Task.Run( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations
Imports System.Threading.Tasks

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

Diğer bir seçenek ve .NET Framework 4 ' te bir görevi başlatmak için en sık kullanılan yöntem static TaskFactory.StartNew yöntemidir.An alternative, and the most common method to start a task in .NET Framework 4, is the static TaskFactory.StartNew method. Task.FactoryÖzelliği bir nesnesi döndürür TaskFactory .The Task.Factory property returns a TaskFactory object. Yöntemin aşırı yüklemeleri, TaskFactory.StartNew görev oluşturma seçeneklerine ve bir görev zamanlayıcısına geçirilecek parametreleri belirtmenize olanak tanır.Overloads of the TaskFactory.StartNew method let you specify parameters to pass to the task creation options and a task scheduler. Aşağıdaki örnek, TaskFactory.StartNew bir görevi başlatmak için yöntemini kullanır.The following example uses the TaskFactory.StartNew method to start a task. Bu, önceki örnekteki kodun işlevsel olarak eşdeğeridir.It is functionally equivalent to the code in the previous example.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Factory.StartNew( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
      t.Wait();
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations
Imports System.Threading.Tasks

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

Daha fazla örnek için bkz. görev tabanlı zaman uyumsuz programlama.For more complete examples, see Task-based Asynchronous Programming.

Görev oluşturma ve yürütmeyi ayırmaSeparating task creation and execution

TaskSınıfı ayrıca görevi başlatacak ancak yürütme için zamanmayan oluşturucular sağlar.The Task class also provides constructors that initialize the task but that do not schedule it for execution. Performans nedenleriyle, ya da Task.Run 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 Task.Start görevi daha sonra yürütülmek üzere zamanlamak için yöntemini çağırabilirsiniz.For performance reasons, the Task.Run or TaskFactory.StartNew method is the preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation and scheduling must be separated, you can use the constructors and then call the Task.Start method to schedule the task for execution at a later time.

Bir veya daha fazla görevin tamamlanması bekleniyorWaiting for one or more tasks to complete

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 örneklendiği anda yürütmeye devam eder.Because tasks typically run asynchronously on a thread pool thread, the thread that creates and starts the task continues execution as soon as the task has been instantiated. Bazı durumlarda, çağıran iş parçacığı ana uygulama iş parçacığı olduğunda, görev gerçekten yürütmeyi başlamadan önce uygulama sonlandırılabilir.In some cases, when the calling thread is the main application thread, the app may terminate before the task actually begins execution. Diğer bir deyişle, uygulamanızın mantığı çağıran iş parçacığının yürütmeye yalnızca bir veya daha fazla görev tamamlandığında devam etmesini gerektirebilir.In others, your application's logic may require that the calling thread continue execution only when one or more tasks have completed execution. WaitBir veya daha fazla görevin tamamlanmasını beklemek için bir yöntem çağırarak, çağıran iş parçacığının ve başlatılan zaman uyumsuz görevlerin yürütülmesini aktarabilirsiniz.You can synchronize the execution of the calling thread and the asynchronous tasks it launches by calling a Wait method to wait for one or more tasks to complete.

Tek bir görevin tamamlanmasını beklemek için Task.Wait yöntemini çağırabilirsiniz.To wait for a single task to complete, you can call its Task.Wait method. Yöntemine yapılan çağrı, Wait tek sınıf örneği yürütmeyi tamamlayana kadar çağıran iş parçacığını engeller.A call to the Wait method blocks the calling thread until the single class instance has completed execution.

Aşağıdaki örnek, Wait() bir görev tamamlanana kadar koşulsuz olarak beklemek için parametresiz yöntemini çağırır.The following example calls the parameterless Wait() method to wait unconditionally until a task completes. Görev, Thread.Sleep iki saniye boyunca uyku moduna geçmek için yöntemini çağırarak işe benzetir.The task simulates work by calling the Thread.Sleep method to sleep for two seconds.

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

class Program
{
    static Random rand = new Random();

    static void Main()
    {
        // Wait on a single task with no timeout specified.
        Task taskA = Task.Run( () => Thread.Sleep(2000));
        Console.WriteLine("taskA Status: {0}", taskA.Status);
        try {
          taskA.Wait();
          Console.WriteLine("taskA Status: {0}", taskA.Status);
       } 
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }   
    }    
}
// The example displays output like the following:
//     taskA Status: WaitingToRun
//     taskA Status: RanToCompletion
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait on a single task with no timeout specified.
      Dim taskA = Task.Run( Sub() Thread.Sleep(2000))
      Console.WriteLine("taskA Status: {0}", taskA.Status)
      Try
        taskA.Wait()
        Console.WriteLine("taskA Status: {0}", taskA.Status)
      Catch e As AggregateException
         Console.WriteLine("Exception in taskA.")
      End Try
   End Sub
End Module
' The example displays output like the following:
'     taskA Status: WaitingToRun
'     taskA Status: RanToCompletion

Ayrıca, bir görevin tamamlanmasını koşullu olarak bekleyebilirsiniz.You can also conditionally wait for a task to complete. Wait(Int32)Ve Wait(TimeSpan) yöntemleri, görev bitene veya bir zaman aşımı aralığı sona erene kadar çağıran iş parçacığını engeller ve hangisi önce gelir.The Wait(Int32) and Wait(TimeSpan) methods block the calling thread until the task finishes or a timeout interval elapses, whichever comes first. Aşağıdaki örnek iki saniye boyunca uykuya geçen ancak tek saniyelik bir zaman aşımı değeri tanımlayan bir görevi başlattığında, çağıran iş parçacığı zaman aşımı süresi dolana kadar ve görevin yürütülmesi tamamlanmadan önce engeller.Since the following example launches a task that sleeps for two seconds but defines a one-second timeout value, the calling thread blocks until the timeout expires and before the task has completed execution.

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

public class Example
{
   public static void Main()
   {
      // Wait on a single task with a timeout specified.
      Task taskA = Task.Run( () => Thread.Sleep(2000));
      try {
        taskA.Wait(1000);       // Wait for 1 second.
        bool completed = taskA.IsCompleted;
        Console.WriteLine("Task A completed: {0}, Status: {1}",
                         completed, taskA.Status);
        if (! completed)
           Console.WriteLine("Timed out before task A completed.");                 
       }
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }   
   }
}
// The example displays output like the following:
//     Task A completed: False, Status: Running
//     Timed out before task A completed.
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait on a single task with a timeout specified.
      Dim taskA As Task = Task.Run( Sub() Thread.Sleep(2000))
      Try
         taskA.Wait(1000)        ' Wait for 1 second.
         Dim completed As Boolean = taskA.IsCompleted
         Console.WriteLine("Task.Completed: {0}, Status: {1}",
                           completed, taskA.Status)
         If Not completed Then 
            Console.WriteLine("Timed out before task A completed.")
         End If                     
      Catch e As AggregateException
         Console.WriteLine("Exception in taskA.")
      End Try
   End Sub
End Module
' The example displays the following output:
'     Task A completed: False, Status: Running
'     Timed out before task A completed.

Ayrıca, ve yöntemlerini çağırarak bir iptal belirteci sağlayabilirsiniz Wait(CancellationToken) Wait(Int32, CancellationToken) .You can also supply a cancellation token by calling the Wait(CancellationToken) and Wait(Int32, CancellationToken) methods. Belirtecin IsCancellationRequested özelliği true ya da true Wait Yöntem yürütülürken olursa, yöntemi bir oluşturur OperationCanceledException .If the token's IsCancellationRequested property is true or becomes true while the Wait method is executing, the method throws an OperationCanceledException.

Bazı durumlarda, bir dizi yürütmenin ilk görevinin tamamlanmasını beklemek isteyebilirsiniz, ancak hangi görevin olduğunu dikkate almanız gerekir.In some cases, you may want to wait for the first of a series of executing tasks to complete, but don't care which task it is. Bu amaçla, yönteminin aşırı yüklemelerinin birini çağırabilirsiniz Task.WaitAny .For this purpose, you can call one of the overloads of the Task.WaitAny method. Aşağıdaki örnek, her biri rastgele bir sayı üreticisi tarafından belirlenen bir Aralık için uykudaki üç görevi oluşturur.The following example creates three tasks, each of which sleeps for an interval determined by a random number generator. WaitAny(Task[])Yöntemi, ilk görevin tamamlanmasını bekler.The WaitAny(Task[]) method waits for the first task to complete. Örnek daha sonra, üç görevin de durumuyla ilgili bilgileri görüntüler.The example then displays information about the status of all three tasks.

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

public class Example
{
   public static void Main()
   {
      var tasks = new Task[3];
      var rnd = new Random();
      for (int ctr = 0; ctr <= 2; ctr++)
         tasks[ctr] = Task.Run( () => Thread.Sleep(rnd.Next(500, 3000)));

      try {
         int index = Task.WaitAny(tasks);
         Console.WriteLine("Task #{0} completed first.\n", tasks[index].Id);
         Console.WriteLine("Status of all tasks:");
         foreach (var t in tasks)
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
      }
      catch (AggregateException) {
         Console.WriteLine("An exception occurred.");
      }
   }
}
// The example displays output like the following:
//     Task #1 completed first.
//     
//     Status of all tasks:
//        Task #3: Running
//        Task #1: RanToCompletion
//        Task #4: Running
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks(2) As Task
      Dim rnd As New Random()
      For ctr As Integer = 0 To 2
         tasks(ctr) = Task.Run( Sub()  Thread.Sleep(rnd.Next(500, 3000)))
      Next
      
      Try 
         Dim index As Integer= Task.WaitAny(tasks)
         Console.WriteLine("Task #{0} completed first.", tasks(index).Id)
         Console.WriteLine()
         Console.WriteLine("Status of all tasks:")
         For Each t in tasks
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
         Next   
      Catch e As AggregateException
         Console.WriteLine("An exception occurred.")
      End Try
   End Sub
End Module
' The example displays output like the following:
'     Task #1 completed first.
'     
'     Status of all tasks:
'        Task #3: Running
'        Task #1: RanToCompletion
'        Task #4: Running

Ayrıca yöntemini çağırarak bir dizi görevin tümünün tamamlanmasını bekleyebilirsiniz WaitAll .You can also wait for all of a series of tasks to complete by calling the WaitAll method. Aşağıdaki örnek on görev oluşturur, on ' un tamamlanmasını bekler ve sonra durumlarını görüntüler.The following example creates ten tasks, waits for all ten to complete, and then displays their status.

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

public class Example
{
   public static void Main()
   {
      // Wait for all tasks to complete.
      Task[] tasks = new Task[10];
      for (int i = 0; i < 10; i++)
      {
          tasks[i] = Task.Run(() => Thread.Sleep(2000));
      }
      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
         Console.WriteLine("One or more exceptions occurred: ");
         foreach (var ex in ae.Flatten().InnerExceptions)
            Console.WriteLine("   {0}", ex.Message);
      }   

      Console.WriteLine("Status of completed tasks:");
      foreach (var t in tasks)
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
   }
}
// The example displays the following output:
//     Status of completed tasks:
//        Task #2: RanToCompletion
//        Task #1: RanToCompletion
//        Task #3: RanToCompletion
//        Task #4: RanToCompletion
//        Task #6: RanToCompletion
//        Task #5: RanToCompletion
//        Task #7: RanToCompletion
//        Task #8: RanToCompletion
//        Task #9: RanToCompletion
//        Task #10: RanToCompletion
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait for all tasks to complete.
      Dim tasks(9) As Task
      For i As Integer = 0 To 9
          tasks(i) = Task.Run( Sub() Thread.Sleep(2000) )
      Next
      Try 
         Task.WaitAll(tasks)
      Catch ae As AggregateException
         Console.WriteLine("One or more exceptions occurred: ")
         For Each ex In ae.Flatten().InnerExceptions
            Console.WriteLine("   {0}", ex.Message)
         Next
      End Try   

      Console.WriteLine("Status of completed tasks:")
      For Each t in tasks
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
      Next   
   End Sub
End Module
' The example displays the following output:
'     Status of completed tasks:
'        Task #2: RanToCompletion
'        Task #1: RanToCompletion
'        Task #3: RanToCompletion
'        Task #4: RanToCompletion
'        Task #6: RanToCompletion
'        Task #5: RanToCompletion
'        Task #7: RanToCompletion
'        Task #8: RanToCompletion
'        Task #9: RanToCompletion
'        Task #10: RanToCompletion

Bir veya daha fazla görevin tamamlanmasını beklerseniz, çalışan görevlerde oluşan tüm özel durumlar, Wait Aşağıdaki örnekte gösterildiği gibi yöntemi çağıran iş parçacığına yayılır.Note that when you wait for one or more tasks to complete, any exceptions thrown in the running tasks are propagated on the thread that calls the Wait method, as the following example shows. 12 görev, her biri normal ve üç adet bir istisna oluşturan 12 görevi başlatır.It launches 12 tasks, three of which complete normally and three of which throw an exception. Kalan altı görev, başlamadan önce iptal edilir ve bunlar yürütülürken üç iptal edilir.Of the remaining six tasks, three are cancelled before they start, and three are cancelled while they are executing. Özel durumlar WaitAll Yöntem çağrısında oluşturulur ve bir blok tarafından işlenir try / catch .Exceptions are thrown in the WaitAll method call and are handled by a try/catch block.

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

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

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

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

Görev tabanlı zaman uyumsuz işlemlerde özel durum işleme hakkında daha fazla bilgi için bkz. özel durum işleme.For more information on exception handling in task-based asynchronous operations, see Exception Handling.

Görevler ve kültürTasks and culture

.NET Framework 4,6 ' i 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 içeriğinin bir parçası haline gelir.Starting with desktop apps that target the .NET Framework 4.6, the culture of the thread that creates and invokes a task becomes part of the thread's context. Diğer bir deyişle, görevin çalıştırıldığı iş parçacığının geçerli kültürüne bakılmaksızın, görevin geçerli kültürü çağıran iş parçacığının kültürüdür.That is, regardless of the current culture of the thread on which the task executes, the current culture of the task is the culture of the calling thread. .NET Framework 4,6 ' den önceki .NET Framework sürümlerini hedefleyen uygulamalar için, görevin kültürü görevin çalıştırıldığı iş parçacığının kültürüdür.For apps that target versions of the .NET Framework prior to the .NET Framework 4.6, the culture of the task is the culture of the thread on which the task executes. Daha fazla bilgi için, konusunun "Kültür ve görev tabanlı zaman uyumsuz işlemler" bölümüne bakın CultureInfo .For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic.

Not

Mağaza uygulamaları, ayar ve varsayılan kültür alma Windows Çalışma Zamanı izler.Store apps follow the Windows Runtime in setting and getting the default culture.

Hata ayıklayıcı geliştiricileri içinFor debugger developers

Özel hata ayıklayıcıları uygulayan geliştiriciler için, bazı iç ve özel görev üyeleri yararlı olabilir (Bu, sürümden yayına değişebilir).For developers implementing custom debuggers, several internal and private members of task may be useful (these may change from release to release). m_taskIdAlanı, özelliği için yedekleme deposu görevi görür Id , ancak bu alana doğrudan bir hata ayıklayıcısından erişmek, özelliğin alıcı yöntemiyle aynı değere erişmekten daha etkili olabilir ( s_taskIdCounter bir GÖREVIN sonraki kullanılabilir kimliğini almak için sayaç kullanılır).The m_taskId field serves as the backing store for the Id property, however accessing this field directly from a debugger may be more efficient than accessing the same value through the property's getter method (the s_taskIdCounter counter is used to retrieve the next available ID for a task). Benzer şekilde, m_stateFlags alan, görevin geçerli yaşam döngüsü aşaması hakkındaki bilgileri, ayrıca özelliği aracılığıyla da erişilebilir şekilde depolar Status .Similarly, the m_stateFlags field stores information about the current lifecycle stage of the task, information also accessible through the Status property. m_actionAlan, görevin temsilcisine bir başvuru depolar ve m_stateObject alan, geliştirici tarafından göreve geçirilen zaman uyumsuz durumu depolar.The m_action field stores a reference to the task's delegate, and the m_stateObject field stores the async state passed to the task by the developer. Son olarak, yığın çerçevelerini ayrıştırmaya yönelik hata ayıklayıcılar için, InternalWait Yöntem bir görevin bekleme işlemini girerken olası bir işaret sunar.Finally, for debuggers that parse stack frames, the InternalWait method serves a potential marker for when a task is entering a wait operation.

Oluşturucular

Task(Action)

Belirtilen eylemle yeni bir başlatır Task .Initializes a new Task with the specified action.

Task(Action, CancellationToken)

TaskBelirtilen eylem ve ile yeni bir ile başlatır CancellationToken .Initializes a new Task with the specified action and CancellationToken.

Task(Action, CancellationToken, TaskCreationOptions)

TaskBelirtilen eylem ve oluşturma seçenekleriyle yeni bir başlatır.Initializes a new Task with the specified action and creation options.

Task(Action, TaskCreationOptions)

TaskBelirtilen eylem ve oluşturma seçenekleriyle yeni bir başlatır.Initializes a new Task with the specified action and creation options.

Task(Action<Object>, Object)

TaskBelirtilen eylem ve durumla yeni bir başlatır.Initializes a new Task with the specified action and state.

Task(Action<Object>, Object, CancellationToken)

TaskBelirtilen eylem, durum ve seçeneklerle yeni bir başlatır.Initializes a new Task with the specified action, state, and options.

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

TaskBelirtilen eylem, durum ve seçeneklerle yeni bir başlatır.Initializes a new Task with the specified action, state, and options.

Task(Action<Object>, Object, TaskCreationOptions)

TaskBelirtilen eylem, durum ve seçeneklerle yeni bir başlatır.Initializes a new Task with the specified action, state, and options.

Özellikler

AsyncState

Oluşturulduğunda sağlanan durum nesnesini alır Task veya hiç sağlanmazsa null değeri alır.Gets the state object supplied when the Task was created, or null if none was supplied.

CompletedTask

Başarıyla tamamlanmış bir görevi alır.Gets a task that has already completed successfully.

CreationOptions

TaskCreationOptionsBu görevi oluşturmak için kullanılan öğesini alır.Gets the TaskCreationOptions used to create this task.

CurrentId

Şu anda yürütülmekte olan KIMLIĞI döndürür Task .Returns the ID of the currently executing Task.

Exception

' Nin AggregateException erken sona uğramasını sağlayan öğesini alır Task .Gets the AggregateException that caused the Task to end prematurely. TaskBaşarıyla tamamlanırsa veya hiç özel durum oluşturmadıysanız, bu döndürülür null .If the Task completed successfully or has not yet thrown any exceptions, this will return null.

Factory

Ve örnekleri oluşturmak ve yapılandırmak için fabrika yöntemlerine erişim Task sağlar Task<TResult> .Provides access to factory methods for creating and configuring Task and Task<TResult> instances.

Id

Bu örnek için bir KIMLIK alır Task .Gets an ID for this Task instance.

IsCanceled

Bu Task Örneğin iptal edilmesi nedeniyle yürütmenin tamamlanıp tamamlanmadığını alır.Gets whether this Task instance has completed execution due to being canceled.

IsCompleted

Görevin tamamlanıp tamamlanmadığını gösteren bir değer alır.Gets a value that indicates whether the task has completed.

IsCompletedSuccessfully

Görevin tamamlanana kadar çalışıp çalışmadığını alır.Gets whether the task ran to completion.

IsFaulted

Taskİşlenmeyen bir özel durum nedeniyle tamamlanmadığını alır.Gets whether the Task completed due to an unhandled exception.

Status

TaskStatusBu görevi alır.Gets the TaskStatus of this task.

Yöntemler

ConfigureAwait(Boolean)

Bunu beklemek için kullanılan bir awaiter yapılandırır Task .Configures an awaiter used to await this Task.

ContinueWith(Action<Task,Object>, Object)

Çağıranın sağladığı durum bilgilerini alan ve hedef tamamlandığında yürüten bir devamlılık oluşturur Task .Creates a continuation that receives caller-supplied state information and executes when the target Task completes.

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

Çağıranın sağladığı durum bilgilerini ve bir iptal belirtecini alan ve hedef tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur Task .Creates a continuation that receives caller-supplied state information and a cancellation token and that executes asynchronously when the target Task completes.

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

Çağıranın sağladığı durum bilgilerini ve bir iptal belirtecini alan ve hedef tamamlandığında yürüten bir devamlılık oluşturur Task .Creates a continuation that receives caller-supplied state information and a cancellation token and that executes when the target Task completes. Devamlılık, belirtilen koşullar kümesine göre yürütülür ve belirtilen bir zamanlayıcıyı kullanır.The continuation executes based on a set of specified conditions and uses a specified scheduler.

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

Çağıranın sağladığı durum bilgilerini alan ve hedef tamamlandığında yürüten bir devamlılık oluşturur Task .Creates a continuation that receives caller-supplied state information and executes when the target Task completes. Devamlılık, belirtilen koşullar kümesine göre yürütülür.The continuation executes based on a set of specified conditions.

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

Çağıranın sağladığı durum bilgilerini alan ve hedef tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur Task .Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. Devamlılık belirtilen bir zamanlayıcıyı kullanır.The continuation uses a specified scheduler.

ContinueWith(Action<Task>)

Hedef tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur Task .Creates a continuation that executes asynchronously when the target Task completes.

ContinueWith(Action<Task>, CancellationToken)

Bir iptal belirteci alan ve hedef tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur Task .Creates a continuation that receives a cancellation token and executes asynchronously when the target Task completes.

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

Hedef görev, belirtilen değere göre uygun olduğunda yürütülen bir devamlılık oluşturur TaskContinuationOptions .Creates a continuation that executes when the target task competes according to the specified TaskContinuationOptions. Devamlılık bir iptal belirteci alır ve belirtilen bir zamanlayıcıyı kullanır.The continuation receives a cancellation token and uses a specified scheduler.

ContinueWith(Action<Task>, TaskContinuationOptions)

Hedef görev, belirtilen öğesine göre tamamlandığında yürütülen bir devamlılık oluşturur TaskContinuationOptions .Creates a continuation that executes when the target task completes according to the specified TaskContinuationOptions.

ContinueWith(Action<Task>, TaskScheduler)

Hedef tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur Task .Creates a continuation that executes asynchronously when the target Task completes. Devamlılık belirtilen bir zamanlayıcıyı kullanır.The continuation uses a specified scheduler.

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

Çağıran tarafından sağlanan durum bilgilerini alan ve hedef tamamlandığında zaman uyumsuz olarak yürütülen ve bir değer döndüren bir devamlılık oluşturur Task .Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes and returns a value.

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

Hedef tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur Task ve bir değer döndürür.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Devamlılık, çağıranın sağladığı durum bilgilerini ve bir iptal belirtecini alır.The continuation receives caller-supplied state information and a cancellation token.

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

Hedef tamamlandığında belirtilen görev devamlılık seçeneklerine göre yürütülen bir devamlılık oluşturur Task ve bir değer döndürür.Creates a continuation that executes based on the specified task continuation options when the target Task completes and returns a value. Devamlılık, çağıranın sağladığı durum bilgilerini ve bir iptal belirtecini alır ve belirtilen zamanlayıcıyı kullanır.The continuation receives caller-supplied state information and a cancellation token and uses the specified scheduler.

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

Hedef tamamlandığında, belirtilen görev devamlılık seçeneklerine göre yürütülen bir devamlılık oluşturur Task .Creates a continuation that executes based on the specified task continuation options when the target Task completes. Devamlılık, çağıranın sağladığı durum bilgilerini alır.The continuation receives caller-supplied state information.

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

Hedef tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur Task .Creates a continuation that executes asynchronously when the target Task completes. Devamlılık, çağıranın sağladığı durum bilgilerini alır ve belirtilen bir zamanlayıcıyı kullanır.The continuation receives caller-supplied state information and uses a specified scheduler.

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

Hedef tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur Task<TResult> ve bir değer döndürür.Creates a continuation that executes asynchronously when the target Task<TResult> completes and returns a value.

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

Hedef tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur Task ve bir değer döndürür.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Devamlılık bir iptal belirteci alır.The continuation receives a cancellation token.

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.Creates a continuation that executes according to the specified continuation options and returns a value. Devamlılık bir iptal belirteci geçti ve belirtilen bir zamanlayıcıyı kullanır.The continuation is passed a cancellation token and uses a specified scheduler.

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.Creates a continuation that executes according to the specified continuation options and returns a value.

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

Hedef tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur Task ve bir değer döndürür.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Devamlılık belirtilen bir zamanlayıcıyı kullanır.The continuation uses a specified scheduler.

Delay(Int32)

Belirtilen sayıda milisaniye sonra tamamlanan bir görev oluşturur.Creates a task that completes after a specified number of milliseconds.

Delay(Int32, CancellationToken)

Belirtilen sayıda milisaniye sonra tamamlanan bir iptal edilebilir görevi oluşturur.Creates a cancellable task that completes after a specified number of milliseconds.

Delay(TimeSpan)

Belirtilen bir zaman aralığından sonra tamamlanan bir görev oluşturur.Creates a task that completes after a specified time interval.

Delay(TimeSpan, CancellationToken)

Belirtilen bir zaman aralığından sonra tamamlanan bir iptal edilebilir görevi oluşturur.Creates a cancellable task that completes after a specified time interval.

Dispose()

Task sınıfının geçerli örneği tarafından kullanılan tüm kaynakları serbest bırakır.Releases all resources used by the current instance of the Task class.

Dispose(Boolean)

, Task Tüm yönetilmeyen kaynaklarını serbest bırakarak ' ı ortadan kaldırın.Disposes the Task, releasing all of its unmanaged resources.

Equals(Object)

Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler.Determines whether the specified object is equal to the current object.

(Devralındığı yer: Object)
FromCanceled(CancellationToken)

Belirtilen bir Task iptal belirteci ile iptal nedeniyle tamamlanan bir oluşturur.Creates a Task that's completed due to cancellation with a specified cancellation token.

FromCanceled<TResult>(CancellationToken)

Belirtilen bir Task<TResult> iptal belirteci ile iptal nedeniyle tamamlanan bir oluşturur.Creates a Task<TResult> that's completed due to cancellation with a specified cancellation token.

FromException(Exception)

Belirtilen bir Task özel durumla tamamlanan bir oluşturur.Creates a Task that has completed with a specified exception.

FromException<TResult>(Exception)

Belirtilen bir Task<TResult> özel durumla tamamlanan bir oluşturur.Creates a Task<TResult> that's completed with a specified exception.

FromResult<TResult>(TResult)

Task<TResult>Belirtilen sonuçla başarıyla tamamlanan bir oluşturur.Creates a Task<TResult> that's completed successfully with the specified result.

GetAwaiter()

Bunu beklemek için kullanılan bir awaiter alır Task .Gets an awaiter used to await this Task.

GetHashCode()

Varsayılan karma işlevi olarak işlev görür.Serves as the default hash function.

(Devralındığı yer: Object)
GetType()

TypeGeçerli örneği alır.Gets the Type of the current instance.

(Devralındığı yer: Object)
MemberwiseClone()

Geçerli bir basit kopyasını oluşturur Object .Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
Run(Action)

Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde sıralar ve Task Bu çalışmayı temsil eden bir nesne döndürür.Queues the specified work to run on the thread pool and returns a Task object that represents that work.

Run(Action, CancellationToken)

Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde sıralar ve Task Bu çalışmayı temsil eden bir nesne döndürür.Queues the specified work to run on the thread pool and returns a Task object that represents that work. İptal belirteci, henüz başlamamışsa çalışmanın iptal edilmesine izin verir.A cancellation token allows the work to be cancelled if it has not yet started.

Run(Func<Task>)

Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde sıralar ve tarafından döndürülen görev için bir ara sunucu döndürür function .Queues the specified work to run on the thread pool and returns a proxy for the task returned by function.

Run(Func<Task>, CancellationToken)

Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde sıralar ve tarafından döndürülen görev için bir ara sunucu döndürür function .Queues the specified work to run on the thread pool and returns a proxy for the task returned by function. İptal belirteci, henüz başlamamışsa çalışmanın iptal edilmesine izin verir.A cancellation token allows the work to be cancelled if it has not yet started.

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

Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde sıralar ve tarafından döndürülen için bir proxy döndürür Task(TResult) function .Queues the specified work to run on the thread pool and returns a proxy for the Task(TResult) returned by function. İptal belirteci, henüz başlamamışsa çalışmanın iptal edilmesine izin verir.A cancellation token allows the work to be cancelled if it has not yet started.

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

Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde sıralar ve tarafından döndürülen için bir proxy döndürür Task(TResult) function .Queues the specified work to run on the thread pool and returns a proxy for the Task(TResult) returned by function.

Run<TResult>(Func<TResult>)

Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde sıralar ve Task<TResult> Bu çalışmayı temsil eden bir nesne döndürür.Queues the specified work to run on the thread pool and returns a Task<TResult> object that represents that work. İptal belirteci, henüz başlamamışsa çalışmanın iptal edilmesine izin verir.A cancellation token allows the work to be cancelled if it has not yet started.

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

Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde sıralar ve Task(TResult) Bu çalışmayı temsil eden bir nesne döndürür.Queues the specified work to run on the thread pool and returns a Task(TResult) object that represents that work.

RunSynchronously()

Geçerli zamanda Task zaman uyumlu olarak çalışır TaskScheduler .Runs the Task synchronously on the current TaskScheduler.

RunSynchronously(TaskScheduler)

, Task Belirtilen zamanda zaman uyumlu olarak çalışır TaskScheduler .Runs the Task synchronously on the TaskScheduler provided.

Start()

, Öğesini başlatır ve Task geçerli bir yürütme için zamanlama TaskScheduler .Starts the Task, scheduling it for execution to the current TaskScheduler.

Start(TaskScheduler)

, Task Öğesini başlatır, belirtilen öğesine yürütülmek üzere planlama yapın TaskScheduler .Starts the Task, scheduling it for execution to the specified TaskScheduler.

ToString()

Geçerli nesneyi temsil eden dizeyi döndürür.Returns a string that represents the current object.

(Devralındığı yer: Object)
Wait()

TaskÇalışmasının tamamlanmasını bekler.Waits for the Task to complete execution.

Wait(CancellationToken)

TaskÇalışmasının tamamlanmasını bekler.Waits for the Task to complete execution. Bekleme, görev tamamlanmadan iptal belirteci iptal edilirse sonlanır.The wait terminates if a cancellation token is canceled before the task completes.

Wait(Int32)

TaskBelirtilen sayıda milisaniye içinde yürütmenin tamamlanmasını bekler.Waits for the Task to complete execution within a specified number of milliseconds.

Wait(Int32, CancellationToken)

TaskÇalışmasının tamamlanmasını bekler.Waits for the Task to complete execution. Bir zaman aşımı aralığı geçtiğinde veya bir iptal belirteci, görev tamamlanmadan önce iptal edilirse, bekleme sona erer.The wait terminates if a timeout interval elapses or a cancellation token is canceled before the task completes.

Wait(TimeSpan)

TaskBelirtilen bir zaman aralığı içinde yürütmenin tamamlanmasını bekler.Waits for the Task to complete execution within a specified time interval.

WaitAll(Task[])

Tüm belirtilen Task nesnelerin yürütmeyi tamamlamasını bekler.Waits for all of the provided Task objects to complete execution.

WaitAll(Task[], CancellationToken)

TaskBekleme iptal edilmediği takdirde, tüm belirtilen nesnelerin yürütmeyi tamamlamasını bekler.Waits for all of the provided Task objects to complete execution unless the wait is cancelled.

WaitAll(Task[], Int32)

TaskBelirtilen milisaniye sayısı içinde, belirtilen tüm nesnelerin yürütülmesini tamamlamasını bekler.Waits for all of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAll(Task[], Int32, CancellationToken)

TaskBelirtilen sayıda milisaniye içinde veya bekleme iptal edilene kadar tüm sunulan nesnelerin yürütülmesini bekler.Waits for all of the provided Task objects to complete execution within a specified number of milliseconds or until the wait is cancelled.

WaitAll(Task[], TimeSpan)

TaskBelirtilen bir zaman aralığı içinde yürütmeyi tamamlamaya yönelik tüm sağlanmış nesneleri bekler.Waits for all of the provided cancellable Task objects to complete execution within a specified time interval.

WaitAny(Task[])

Belirtilen nesnelerden herhangi birinin Task yürütmeyi tamamlamasını bekler.Waits for any of the provided Task objects to complete execution.

WaitAny(Task[], CancellationToken)

TaskBekleme iptal edilmediği takdirde, belirtilen nesnelerden herhangi birinin yürütmeyi tamamlamasını bekler.Waits for any of the provided Task objects to complete execution unless the wait is cancelled.

WaitAny(Task[], Int32)

TaskBelirtilen sayıda milisaniye içinde yürütme işleminin tamamlanmasını bekler.Waits for any of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAny(Task[], Int32, CancellationToken)

TaskBelirtilen sayıda milisaniye içinde veya iptal belirteci iptal edilene kadar, belirtilen nesnelerden herhangi birinin yürütmeyi tamamlamasını bekler.Waits for any of the provided Task objects to complete execution within a specified number of milliseconds or until a cancellation token is cancelled.

WaitAny(Task[], TimeSpan)

TaskBelirtilen bir zaman aralığı içinde yürütülen nesnelerden herhangi birinin yürütmeyi tamamlamasını bekler.Waits for any of the provided Task objects to complete execution within a specified time interval.

WhenAll(IEnumerable<Task>)

Sıralanabilir bir koleksiyondaki tüm nesneler tamamlandığında tamamlanacak bir görev oluşturur Task .Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

WhenAll(Task[])

Bir dizideki tüm nesneler tamamlandığında tamamlanacak bir görev oluşturur Task .Creates a task that will complete when all of the Task objects in an array have completed.

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

Sıralanabilir bir koleksiyondaki tüm nesneler tamamlandığında tamamlanacak bir görev oluşturur Task<TResult> .Creates a task that will complete when all of the Task<TResult> objects in an enumerable collection have completed.

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

Bir dizideki tüm nesneler tamamlandığında tamamlanacak bir görev oluşturur Task<TResult> .Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

WhenAny(IEnumerable<Task>)

Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur.Creates a task that will complete when any of the supplied tasks have completed.

WhenAny(Task, Task)

Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur.Creates a task that will complete when either of the supplied tasks have completed.

WhenAny(Task[])

Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur.Creates a task that will complete when any of the supplied tasks have completed.

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

Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur.Creates a task that will complete when any of the supplied tasks have completed.

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

Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur.Creates a task that will complete when either of the supplied tasks have completed.

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

Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur.Creates a task that will complete when any of the supplied tasks have completed.

Yield()

Beklendiğinde, zaman uyumsuz olarak geçerli içeriğe geri veren bir görev oluşturur.Creates an awaitable task that asynchronously yields back to the current context when awaited.

Belirtik Arabirim Kullanımları

IAsyncResult.AsyncWaitHandle

WaitHandleGörevin tamamlanmasını beklemek için kullanılabilecek bir alır.Gets a WaitHandle that can be used to wait for the task to complete.

IAsyncResult.CompletedSynchronously

İşlemin eşzamanlı olarak tamamlanıp tamamlanmadığını belirten bir bildirim alır.Gets an indication of whether the operation completed synchronously.

Uzantı Metotları

DispatcherOperationWait(Task)

Temeldeki DispatcherOperation işleminin tamamlanmasını süresiz olarak bekler.Waits indefinitely for the underlying DispatcherOperation to complete.

DispatcherOperationWait(Task, TimeSpan)

Temeldeki öğesinin tamamlanışında, belirtilen süre boyunca bekler DispatcherOperation .Waits for the specified amount of time for the underlying DispatcherOperation to complete.

IsDispatcherOperationTask(Task)

Bunun ile ilişkili olup olmadığını gösteren bir değer döndürür Task DispatcherOperation .Returns a value that indicates whether this Task is associated with a DispatcherOperation.

AsAsyncAction(Task)

Başlatılmış bir görevi temsil eden Windows Çalışma Zamanı zaman uyumsuz bir eylem döndürür.Returns a Windows Runtime asynchronous action that represents a started task.

Şunlara uygulanır

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

, Hariç tüm üyeleri Task Dispose() iş parçacığı açısından güvenlidir ve aynı anda birden çok iş parçacığından kullanılabilir.All members of Task, except for Dispose(), are thread-safe and may be used from multiple threads concurrently.

Ayrıca bkz.