Task Třída

Definice

Představuje asynchronní operaci.

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
Dědičnost
Task
Odvozené
Implementuje

Poznámky

Třída Task představuje jednu operaci, která nevrací hodnotu a obvykle se spouští asynchronně. Task objekty jsou jednou z hlavních komponent asynchronního vzoru založeného na úlohách , které byly poprvé zavedeny v rozhraní .NET Framework 4. Vzhledem k tomu, že práce prováděná Task objektem obvykle provádí asynchronně ve vlákně fondu vláken, nikoli synchronně na hlavním vlákně aplikace, můžete použít Status vlastnost, stejně jako IsCanceledvlastnosti a vlastnosti IsFaulted IsCompleted, určit stav úlohy. Nejčastěji se výraz lambda používá k určení práce, kterou má úkol provést.

Pro operace, které vracejí hodnoty, použijete Task<TResult> třídu.

V této části:

Příklady vytváření instancí úkolů
Vytvoření a spuštění úlohy
Oddělení vytváření a spouštění úloh
Čekání na dokončení jednoho nebo více úkolů
Úkoly a kultura
Vývojáři ladicího programu

Vytvoření instance úlohy

Následující příklad vytvoří a spustí čtyři úlohy. Tři úkoly spouštějí Action<T> delegáta s názvem action, který přijímá argument typu Object. Čtvrtý úkol spustí výraz lambda ( Action delegát), který je definovaný v volání metody vytvoření úkolu. Každá úloha se vytvoří instance a spustí se jiným způsobem:

  • Úloha t1 je vytvořena voláním konstruktoru třídy Task, ale je spuštěn voláním jeho Start() metody pouze po spuštění úkolu t2 .

  • Úloha t2 se vytvoří instance a spustí se v jednom volání metody voláním TaskFactory.StartNew(Action<Object>, Object) metody.

  • Úloha t3 se vytvoří instance a spustí se v jednom volání metody voláním Run(Action) metody.

  • Úloha t4 se provádí synchronně v hlavním vlákně voláním RunSynchronously() metody.

Vzhledem k tomu, že se úloha t4 spouští synchronně, spustí se na hlavním vlákně aplikace. Zbývající úlohy se spouští asynchronně na jednom nebo více vláknech fondu vláken.

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

Vytvoření a spuštění úlohy

Task instance se můžou vytvářet různými způsoby. Nejběžnějším přístupem, který je k dispozici počínaje rozhraním .NET Framework 4.5, je volání statické Run metody. Metoda Run poskytuje jednoduchý způsob, jak spustit úlohu pomocí výchozích hodnot a bez nutnosti dalších parametrů. Následující příklad používá metodu Run(Action) ke spuštění úlohy, která smyčky a pak zobrazí počet iterací smyčky:

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

Alternativou a nejběžnější metodou spuštění úlohy v rozhraní .NET Framework 4 je statická TaskFactory.StartNew metoda. Vlastnost Task.Factory vrátí TaskFactory objekt. TaskFactory.StartNew Přetížení metody umožňují zadat parametry, které se mají předat možnostem vytváření úkolů a plánovači úkolů. Následující příklad používá metodu TaskFactory.StartNew ke spuštění úkolu. Je funkčně ekvivalentní kódu v předchozím příkladu.

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

Podrobnější příklady najdete v tématu Asynchronní programování založené na úlohách.

Oddělení vytváření a spouštění úloh

Třída Task také poskytuje konstruktory, které inicializují úlohu, ale neplánují ji pro provádění. Z důvodů výkonu Task.Run je upřednostňovaným TaskFactory.StartNew mechanismem pro vytváření a plánování výpočetních úloh, ale pro scénáře, ve kterých je potřeba vytvořit a plánování oddělit, můžete použít konstruktory a pak metodu Task.Start volat k naplánování úlohy pro provádění později.

Čekání na dokončení jednoho nebo více úkolů

Vzhledem k tomu, že úlohy obvykle běží asynchronně ve vlákně fondu vláken, vlákno, které vytváří a spouští úlohu, pokračuje v provádění, jakmile bude úloha vytvořena instance. V některých případech, když je volající vlákno hlavním vláknem aplikace, může aplikace ukončit před zahájením provádění úlohy. V jiných případech může logika vaší aplikace vyžadovat, aby volající vlákno pokračovalo ve spouštění pouze v případě, že se dokončilo provádění jedné nebo více úloh. Spuštění volajícího vlákna a asynchronních úloh, které spustí, můžete synchronizovat voláním Wait metody, která bude čekat na dokončení jedné nebo více úloh.

Pokud chcete počkat na dokončení jednoho úkolu, můžete volat jeho Task.Wait metodu. Volání Wait metody blokuje volající vlákno, dokud instance jedné třídy nedokončila provádění.

Následující příklad volá metodu bez Wait() parametrů, která bude bezvýkladně čekat, dokud se úkol dokončí. Úloha simuluje práci voláním Thread.Sleep metody do režimu spánku po dobu dvou sekund.

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

Můžete také podmíněně počkat na dokončení úkolu. Metody Wait(Int32) blokují Wait(TimeSpan) volající vlákno, dokud úloha nedokončí nebo uplynul časový limit, podle toho, co nastane dříve. Vzhledem k tomu, že následující příklad spustí úlohu, která spí po dobu dvou sekund, ale definuje hodnotu časového limitu o jednu sekundu, volající vlákno zablokuje až do vypršení časového limitu a před dokončením provádění úkolu.

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.

Token zrušení můžete zadat také voláním Wait(CancellationToken) a Wait(Int32, CancellationToken) metodami. Pokud je vlastnost tokenu IsCancellationRequested nebo se stanetrue, když Wait je metoda spuštěna, metoda vyvolá OperationCanceledException.true

V některých případech můžete chtít počkat na dokončení první série provádění úkolů, ale nezajímá vás, který úkol je. Pro tento účel můžete volat jednu z přetížení Task.WaitAny metody. Následující příklad vytvoří tři úkoly, z nichž každý spí pro interval určený generátorem náhodných čísel. Metoda WaitAny(Task[]) čeká na dokončení prvního úkolu. V příkladu se pak zobrazí informace o stavu všech tří úkolů.

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

Můžete také počkat na dokončení všech řad úkolů voláním WaitAll metody. Následující příklad vytvoří deset úkolů, počká na dokončení všech deset a zobrazí jejich stav.

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

Všimněte si, že když počkáte na dokončení jedné nebo více úkolů, všechny výjimky vyvolané ve spuštěných úkolech se rozšíří do vlákna, které volá metodu Wait , jak ukazuje následující příklad. Spustí 12 úkolů, z nichž tři se obvykle dokončí a tři z nichž vyvolá výjimku. Zbývajících šest úkolů se před zahájením zruší tři a během provádění se zruší tři. Výjimky jsou vyvolán v WaitAll volání metody a jsou zpracovávány blokem/try``catch.

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

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

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

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

Další informace o zpracování výjimek v asynchronních operacích založených na úlohách najdete v tématu Zpracování výjimek.

Úkoly a kultura

Počínaje desktopovými aplikacemi, které cílí na rozhraní .NET Framework 4.6, se jazyková verze vlákna, která vytvoří a vyvolá úlohu, stane součástí kontextu vlákna. To znamená, že bez ohledu na aktuální jazykovou verzi vlákna, na které se úloha provádí, je aktuální jazyková verze úkolu jazykovou verzí volajícího vlákna. Pro aplikace, které cílí na verze rozhraní .NET Framework před rozhraním .NET Framework 4.6, je jazyková verze úlohy jazykovou verzí vlákna, na které se úloha spouští. Další informace najdete v části Jazykové a asynchronní operace založené na úlohách v CultureInfo tématu.

Poznámka

Aplikace Pro Store se řídí prostředí Windows Runtime nastavením a získáním výchozí jazykové verze.

Vývojáři ladicího programu

Pro vývojáře, kteří implementují vlastní ladicí programy, může být užitečné několik interních a privátních členů úlohy (mohou se změnit z verze na vydání). Toto m_taskId pole slouží jako záložní úložiště vlastnosti Id , ale přístup k tomuto poli přímo z ladicího programu může být efektivnější než přístup ke stejné hodnotě prostřednictvím metody getter vlastnosti ( s_taskIdCounter čítač se používá k načtení dalšího dostupného ID úkolu). m_stateFlags Podobně pole ukládá informace o aktuální fázi životního cyklu úkolu, informace jsou přístupné také prostřednictvím Status vlastnosti. Pole m_action ukládá odkaz na delegáta úkolu a m_stateObject pole ukládá asynchronní stav předaný úkolu vývojářem. Nakonec pro ladicí programy, které parsují rámce zásobníku, InternalWait metoda slouží potenciální značku, pro kterou úloha zadává operaci čekání.

Konstruktory

Task(Action)

Inicializuje novou Task pomocí zadané akce.

Task(Action, CancellationToken)

Inicializuje novou Task se zadanou akcí a CancellationToken.

Task(Action, CancellationToken, TaskCreationOptions)

Inicializuje novou Task se zadanou akcí a možnostmi vytvoření.

Task(Action, TaskCreationOptions)

Inicializuje novou Task se zadanou akcí a možnostmi vytvoření.

Task(Action<Object>, Object)

Inicializuje novou Task se zadanou akcí a stavem.

Task(Action<Object>, Object, CancellationToken)

Inicializuje novou Task se zadanou akcí, stavem a možnostmi.

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

Inicializuje novou Task se zadanou akcí, stavem a možnostmi.

Task(Action<Object>, Object, TaskCreationOptions)

Inicializuje novou Task se zadanou akcí, stavem a možnostmi.

Vlastnosti

AsyncState

Získá stav objekt zadaný při Task vytvoření, nebo null, pokud nebyla zadána žádná.

CompletedTask

Získá úkol, který už byl úspěšně dokončen.

CreationOptions

TaskCreationOptions Získá použité k vytvoření tohoto úkolu.

CurrentId

Vrátí ID aktuálně spuštěného Taskobjektu .

Exception

AggregateException Získá to, co způsobilo Task konec předčasně. Pokud se Task dokončeno úspěšně nebo ještě nevyvolá žádné výjimky, vrátí se null.

Factory

Poskytuje přístup k metodám továrny pro vytváření a konfiguraci Task a Task<TResult> konfiguraci instancí.

Id

Získá ID pro tuto Task instanci.

IsCanceled

Získá, zda tato Task instance dokončila provádění kvůli zrušení.

IsCompleted

Získá hodnotu, která označuje, zda úkol dokončil.

IsCompletedSuccessfully

Získá, jestli se úkol spustil k dokončení.

IsFaulted

Získá, zda dokončeno Task kvůli neošetřené výjimce.

Status

TaskStatus Získá tento úkol.

Metody

ConfigureAwait(Boolean)

Konfiguruje awaiter použitý k čekání na tento Task.

ContinueWith(Action<Task,Object>, Object)

Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a spustí se po dokončení cíle Task .

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

Vytvoří pokračování, které přijímá informace o stavu zadané volajícím a token zrušení a který se spustí asynchronně po dokončení cíle Task .

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

Vytvoří pokračování, které přijímá informace o stavu zadané volajícím a token zrušení a který se spustí po dokončení cíle Task . Pokračování se spustí na základě sady zadaných podmínek a používá zadaný plánovač.

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

Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a spustí se po dokončení cíle Task . Pokračování se provede na základě sady zadaných podmínek.

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

Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a spustí se asynchronně po dokončení cíle Task . Pokračování používá zadaný plánovač.

ContinueWith(Action<Task>)

Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task .

ContinueWith(Action<Task>, CancellationToken)

Vytvoří pokračování, které obdrží token zrušení a spustí asynchronně po dokončení cíle Task .

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

Vytvoří pokračování, které se spustí, když cílová úloha konkuruje podle zadaného TaskContinuationOptions. Pokračování obdrží token zrušení a použije zadaný plánovač.

ContinueWith(Action<Task>, TaskContinuationOptions)

Vytvoří pokračování, které se spustí při dokončení cílové úlohy podle zadaného TaskContinuationOptions.

ContinueWith(Action<Task>, TaskScheduler)

Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task . Pokračování používá zadaný plánovač.

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

Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a spustí asynchronně po dokončení cíle Task a vrátí hodnotu.

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

Vytvoří pokračování, které se provede asynchronně po dokončení cíle Task a vrátí hodnotu. Pokračování přijímá informace o stavu zadané volajícím a token zrušení.

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

Vytvoří pokračování, které se spustí na základě zadaných možností pokračování úkolu po dokončení cíle Task a vrátí hodnotu. Pokračování přijímá informace o stavu zadané volajícím a token zrušení a používá zadaný plánovač.

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

Vytvoří pokračování, které se spustí na základě zadaných možností pokračování úkolu po dokončení cíle Task . Pokračování obdrží informace o stavu zadané volajícím.

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

Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task . Pokračování přijímá informace o stavu zadané volajícím a používá zadaný plánovač.

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

Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task<TResult> a vrátí hodnotu.

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

Vytvoří pokračování, které se provede asynchronně po dokončení cíle Task a vrátí hodnotu. Pokračování obdrží token zrušení.

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

Vytvoří pokračování, které se spustí podle zadaných možností pokračování a vrátí hodnotu. Pokračování se předává token zrušení a používá zadaný plánovač.

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

Vytvoří pokračování, které se spustí podle zadaných možností pokračování a vrátí hodnotu.

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

Vytvoří pokračování, které se provede asynchronně po dokončení cíle Task a vrátí hodnotu. Pokračování používá zadaný plánovač.

Delay(Int32)

Vytvoří úlohu, která se dokončí po zadaném počtu milisekund.

Delay(Int32, CancellationToken)

Vytvoří zrušený úkol, který se dokončí po zadaném počtu milisekund.

Delay(TimeSpan)

Vytvoří úkol, který se dokončí po zadaném časovém intervalu.

Delay(TimeSpan, CancellationToken)

Vytvoří zrušený úkol, který se dokončí po zadaném časovém intervalu.

Dispose()

Uvolní všechny prostředky používané aktuální instancí Task třídy.

Dispose(Boolean)

TaskUvolní všechny jeho nespravované prostředky.

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.

(Zděděno od Object)
FromCanceled(CancellationToken)

Vytvoří dokončený Task kvůli zrušení se zadaným tokenem zrušení.

FromCanceled<TResult>(CancellationToken)

Vytvoří dokončený Task<TResult> kvůli zrušení se zadaným tokenem zrušení.

FromException(Exception)

Vytvoří dokončenou Task s zadanou výjimkou.

FromException<TResult>(Exception)

Vytvoří dokončenou s Task<TResult> zadanou výjimkou.

FromResult<TResult>(TResult)

Vytvoří úspěšně dokončený Task<TResult> se zadaným výsledkem.

GetAwaiter()

Získá awaiter, který se používá k čekacímu Tasktomuto .

GetHashCode()

Slouží jako výchozí funkce hash.

(Zděděno od Object)
GetType()

Type Získá aktuální instanci.

(Zděděno od Object)
MemberwiseClone()

Vytvoří použádnou kopii aktuálního souboru Object.

(Zděděno od Object)
Run(Action)

Zařadí zadanou práci, která se má spustit ve fondu vláken, a vrátí objekt, který představuje danou Task práci.

Run(Action, CancellationToken)

Zařadí zadanou práci do fronty pro spuštění ve fondu vláken a vrátí objekt, který představuje danou Task práci. Token zrušení umožňuje zrušit práci, pokud ještě nezačal.

Run(Func<Task>)

Zařadí zadanou práci, která se má spustit ve fondu vláken, a vrátí proxy server pro úlohu vrácenou .function

Run(Func<Task>, CancellationToken)

Zařadí zadanou práci, která se má spustit ve fondu vláken, a vrátí proxy server pro úlohu vrácenou function. Token zrušení umožňuje zrušit práci, pokud ještě nezačal.

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

Zařadí zadanou práci, která se má spustit ve fondu vláken, a vrátí proxy server pro vrácený Task(TResult) function. Token zrušení umožňuje zrušit práci, pokud ještě nezačal.

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

Zařadí zadanou práci, která se má spustit ve fondu vláken, a vrátí proxy server pro vrácený Task(TResult) function.

Run<TResult>(Func<TResult>)

Zařadí zadanou práci do fronty pro spuštění ve fondu vláken a vrátí objekt, který představuje danou Task<TResult> práci. Token zrušení umožňuje zrušit práci, pokud ještě nezačal.

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

Zařadí zadanou práci do fronty pro spuštění ve fondu vláken a vrátí objekt, který představuje danou Task(TResult) práci.

RunSynchronously()

Task Spustí synchronně na aktuální TaskScheduler.

RunSynchronously(TaskScheduler)

Task Spustí synchronně na zadaném webuTaskScheduler.

Start()

TaskSpustí , plánování spuštění na aktuální TaskScheduler.

Start(TaskScheduler)

TaskSpustí , plánování spuštění na zadané TaskScheduler.

ToString()

Vrátí řetězec, který představuje aktuální objekt.

(Zděděno od Object)
Wait()

Čeká na Task dokončení provádění.

Wait(CancellationToken)

Čeká na Task dokončení provádění. Čekání se ukončí, pokud se před dokončením úkolu zruší token zrušení.

Wait(Int32)

Čeká na Task dokončení provádění v zadaném počtu milisekund.

Wait(Int32, CancellationToken)

Čeká na Task dokončení provádění. Čekání se ukončí, pokud před dokončením úkolu uplynul časový limit nebo se zruší token zrušení.

Wait(TimeSpan)

Čeká na Task dokončení provádění v zadaném časovém intervalu.

WaitAll(Task[])

Čeká na dokončení provádění všech zadaných Task objektů.

WaitAll(Task[], CancellationToken)

Čeká na dokončení provádění všech zadaných Task objektů, pokud se čekání nezruší.

WaitAll(Task[], Int32)

Čeká na dokončení provádění všech zadaných Task objektů v zadaném počtu milisekund.

WaitAll(Task[], Int32, CancellationToken)

Čeká na dokončení provádění všech zadaných Task objektů v zadaném počtu milisekund nebo až do zrušení čekání.

WaitAll(Task[], TimeSpan)

Čeká na dokončení provádění všech zadaných zrušených Task objektů v zadaném časovém intervalu.

WaitAny(Task[])

Čeká na dokončení provádění některého z zadaných Task objektů.

WaitAny(Task[], CancellationToken)

Čeká na dokončení provádění některého z zadaných Task objektů, pokud se čekání nezruší.

WaitAny(Task[], Int32)

Čeká na dokončení provádění některého z zadaných Task objektů v zadaném počtu milisekund.

WaitAny(Task[], Int32, CancellationToken)

Čeká na dokončení provádění některého z zadaných Task objektů v zadaném počtu milisekund nebo do zrušení tokenu zrušení.

WaitAny(Task[], TimeSpan)

Čeká na dokončení provádění některého z zadaných Task objektů v zadaném časovém intervalu.

WaitAsync(CancellationToken)

Task Získá, který se dokončí po dokončení Task nebo když zadaný CancellationToken požadavek na zrušení.

WaitAsync(TimeSpan)

Task Získá, který se dokončí po Task dokončení nebo po vypršení zadaného časového limitu.

WaitAsync(TimeSpan, CancellationToken)

Task Získá, který se dokončí po Task dokončení, po vypršení zadaného časového limitu nebo po zadání CancellationToken požadavku na zrušení.

WhenAll(IEnumerable<Task>)

Vytvoří úlohu, která se dokončí, když se dokončí všechny Task objekty v výčtové kolekci.

WhenAll(Task[])

Vytvoří úlohu, která se dokončí po dokončení všech Task objektů v poli.

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

Vytvoří úlohu, která se dokončí, když se dokončí všechny Task<TResult> objekty v výčtové kolekci.

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

Vytvoří úlohu, která se dokončí po dokončení všech Task<TResult> objektů v poli.

WhenAny(IEnumerable<Task>)

Vytvoří úkol, který se dokončí, když se dokončí některý z zadaných úkolů.

WhenAny(Task, Task)

Vytvoří úkol, který se dokončí po dokončení některého z zadaných úkolů.

WhenAny(Task[])

Vytvoří úkol, který se dokončí, když se dokončí některý z zadaných úkolů.

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

Vytvoří úkol, který se dokončí, když se dokončí některý z zadaných úkolů.

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

Vytvoří úkol, který se dokončí po dokončení některého z zadaných úkolů.

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

Vytvoří úkol, který se dokončí, když se dokončí některý z zadaných úkolů.

Yield()

Vytvoří očekávanou úlohu, která asynchronně vrátí zpět aktuální kontext, když čekáte.

Explicitní implementace rozhraní

IAsyncResult.AsyncWaitHandle

WaitHandle Získá, který lze použít k čekání na dokončení úkolu.

IAsyncResult.CompletedSynchronously

Získá indikaci, zda operace byla dokončena synchronně.

Metody rozšíření

DispatcherOperationWait(Task)

Čeká na dokončení podkladového objektu DispatcherOperation na neomezenou dobu.

DispatcherOperationWait(Task, TimeSpan)

Počká na zadané množství času, než se podkladová DispatcherOperation hodnota dokončí.

IsDispatcherOperationTask(Task)

Vrátí hodnotu, která označuje, zda je tato Task hodnota přidružena k DispatcherOperation.

AsAsyncAction(Task)

Vrátí asynchronní Windows Runtime, která představuje spuštěnou úlohu.

Platí pro

Bezpečný přístup z více vláken

Všichni členové Task, s výjimkou Dispose(), jsou bezpečné pro vlákno a mohou být použity z více vláken současně.

Viz také