Task Třída

Definice

Představuje asynchronní operaci.Represents an asynchronous operation.

public ref class Task : IAsyncResult, IDisposable
public class Task : IAsyncResult, IDisposable
type Task = class
    interface IAsyncResult
    interface IDisposable
Public Class Task
Implements IAsyncResult, IDisposable
Dědičnost
Task
Odvozené
Implementuje

Poznámky

Třída Task představuje jednu operaci, která nevrací hodnotu, která se obvykle provádí asynchronně.The Task class represents a single operation that does not return a value and that usually executes asynchronously. objekty Task jsou jednou z centrálních komponent asynchronního vzoru založeného na úlohách , které se poprvé zavedly v .NET Framework 4.Task objects are one of the central components of the task-based asynchronous pattern first introduced in the .NET Framework 4. Vzhledem k tomu, že se práce prováděná Taskm objektem obvykle provádí asynchronně ve vlákně fondu vláken, nikoli synchronně v hlavním vlákně aplikace, můžete použít vlastnost Status a vlastnosti IsCanceled, IsCompleteda IsFaulted k určení stavu úkolu.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. Nejčastěji se výraz lambda používá k určení práce, kterou má úkol provést.Most commonly, a lambda expression is used to specify the work that the task is to perform.

Pro operace, které vracejí hodnoty, použijte třídu Task<TResult>.For operations that return values, you use the Task<TResult> class.

V této části:In this section:

Příklady vytváření instancí úloh Task instantiation examples
Vytvoření a spuštění úlohy Creating and executing a task
Oddělení vytváření a spouštění úloh Separating task creation and execution
Čeká se na dokončení jednoho nebo více úloh Waiting for one or more tasks to complete
Úlohy a jazykové verzeTasks and culture
Pro vývojáře ladicího programuFor debugger developers

Vytváření instancí úlohyTask instantiation

Následující příklad vytvoří a spustí čtyři úkoly.The following example creates and executes four tasks. Tři úlohy spouštějí delegáta Action<T> s názvem action, který přijímá argument typu Object.Three tasks execute an Action<T> delegate named action, which accepts an argument of type Object. Čtvrtá úloha spustí lambda výraz (Action delegát), který je definovaný jako vložený ve volání metody vytváření úlohy.A fourth task executes a lambda expression (an Action delegate) that is defined inline in the call to the task creation method. Každý úkol je vytvořen a spuštěn jiným způsobem:Each task is instantiated and run in a different way:

  • Instance t1 úlohy je vytvořena voláním konstruktoru třídy úlohy, ale je spuštěna voláním metody Start() až po spuštění t2 úlohy.Task t1 is instantiated by calling a Task class constructor, but is started by calling its Start() method only after task t2 has started.

  • t2 úlohy je vytvořena instance a spuštěna v rámci jediného volání metody voláním metody TaskFactory.StartNew(Action<Object>, Object).Task t2 is instantiated and started in a single method call by calling the TaskFactory.StartNew(Action<Object>, Object) method.

  • t3 úlohy je vytvořena instance a spuštěna v rámci jediného volání metody voláním metody Run(Action).Task t3 is instantiated and started in a single method call by calling the Run(Action) method.

  • Úkol t4 je spuštěn synchronně v hlavním vlákně voláním metody RunSynchronously().Task t4 is executed synchronously on the main thread by calling the RunSynchronously() method.

Vzhledem k tomu, že se úloha t4 spouští synchronně, provede se v hlavním vlákně aplikace.Because task t4 executes synchronously, it executes on the main application thread. Zbývající úlohy se spouštějí asynchronně obvykle v jednom nebo více vláknech fondu vláken.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

Vytvoření a spuštění úlohyCreating and executing a task

instance Task mohou být vytvořeny různými způsoby.Task instances may be created in a variety of ways. Nejběžnější přístup, který je k dispozici počínaje .NET Framework 4.5.NET Framework 4.5, je zavolat statickou metodu Run.The most common approach, which is available starting with the .NET Framework 4.5.NET Framework 4.5, is to call the static Run method. Metoda Run poskytuje jednoduchý způsob, jak spustit úlohu s využitím výchozích hodnot a bez nutnosti dalších parametrů.The Run method provides a simple way to start a task using default values and without requiring additional parameters. Následující příklad používá metodu Run(Action) ke spuštění úlohy, která Cykluje a pak zobrazuje počet iterací smyčky: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

Alternativou a Nejběžnější metodou spuštění úlohy v .NET Framework 4.NET Framework 4je statická TaskFactory.StartNew metoda.An alternative, and the most common method to start a task in .NET Framework 4.NET Framework 4, is the static TaskFactory.StartNew method. Vlastnost Task.Factory vrací objekt TaskFactory.The Task.Factory property returns a TaskFactory object. Přetížení metody TaskFactory.StartNew umožňují zadat parametry, které mají být předávány možnostem vytvoření úlohy a plánovačem úloh.Overloads of the TaskFactory.StartNew method let you specify parameters to pass to the task creation options and a task scheduler. Následující příklad používá metodu TaskFactory.StartNew ke spuštění úlohy.The following example uses the TaskFactory.StartNew method to start a task. Je funkčně ekvivalentní kódu v předchozím příkladu.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

Další kompletní příklady najdete v tématu asynchronní programování na základě úkolů.For more complete examples, see Task-based Asynchronous Programming.

Oddělení vytváření a provádění úlohSeparating task creation and execution

Třída Task také poskytuje konstruktory, které inicializují úlohu, ale neplánují ji pro provedení.The Task class also provides constructors that initialize the task but that do not schedule it for execution. Z důvodů výkonu je metoda Task.Run nebo TaskFactory.StartNew upřednostňovaným mechanismem pro vytváření a plánování výpočetních úloh, ale pro scénáře, kdy musí být vytváření a plánování nutné oddělení, můžete použít konstruktory a pak zavolat metodu Task.Start k naplánování úlohy na pozdější dobu.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.

Čeká se na dokončení nejméně jednoho úkolu.Waiting for one or more tasks to complete

Vzhledem k tomu, že se úlohy obvykle spouštějí asynchronně ve vlákně fondu vláken, vlákno, které vytvoří a spustí úlohu, pokračuje v provádění, jakmile se vytvoří instance úkolu.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. V některých případech platí, že pokud je volající vlákno hlavním vláknem aplikace, aplikace může skončit ještě před tím, než úloha skutečně zahájí provádění.In some cases, when the calling thread is the main application thread, the app may terminate before any the task actually begins execution. V ostatních případech logika vaší aplikace může vyžadovat, aby volající vlákno pokračovalo v provádění pouze v případě, že bylo dokončeno provedení jedné nebo více úloh.In others, your application's logic may require that the calling thread continue execution only when one or more tasks has completed execution. Můžete synchronizovat spuštění volajícího vlákna a asynchronní úlohy, které spustí, voláním metody Wait pro čekání na dokončení jedné nebo více úloh.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.

Chcete-li počkat na dokončení jedné úlohy, můžete zavolat její metodu Task.Wait.To wait for a single task to complete, you can call its Task.Wait method. Volání metody Wait blokuje volající vlákno, dokud instance jedné třídy nedokončila provádění.A call to the Wait method blocks the calling thread until the single class instance has completed execution.

Následující příklad volá metodu Wait() bez parametrů, aby čekala bezpodmínečně, dokud se úloha nedokončí.The following example calls the parameterless Wait() method to wait unconditionally until a task completes. Úkol simuluje práci voláním metody Thread.Sleep do režimu spánku po dobu dvou sekund.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

Můžete také podmíněně počkat na dokončení úlohy.You can also conditionally wait for a task to complete. Metody Wait(Int32) a Wait(TimeSpan) zablokují volající vlákno, dokud neskončí úloha nebo uplyne časový interval, podle toho, co nastane dřív.The Wait(Int32) and Wait(TimeSpan) methods block the calling thread until the task finishes or a timeout interval elapses, whichever comes first. Vzhledem k tomu, že následující příklad spustí úlohu, která bude v režimu spánku po dobu dvou sekund, ale definuje hodnotu časového limitu sekund, volající vlákno zablokuje až do vypršení časového limitu a před dokončením provádění úlohy.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.

Token zrušení můžete také dodat voláním metod Wait(CancellationToken) a Wait(Int32, CancellationToken).You can also supply a cancellation token by calling the Wait(CancellationToken) and Wait(Int32, CancellationToken) methods. Pokud je vlastnost IsCancellationRequested tokenu true nebo se stala true, zatímco metoda Wait je spuštěná, vyvolá metoda OperationCanceledException.If the token's IsCancellationRequested property is true or becomes true while the Wait method is executing, the method throws an OperationCanceledException.

V některých případech můžete chtít počkat na dokončení řady spuštěných úloh, ale nezáleží na tom, který úkol je.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. Pro tento účel můžete zavolat jedno z přetížení metody Task.WaitAny.For this purpose, you can call one of the overloads of the Task.WaitAny method. Následující příklad vytvoří tři úkoly, z nichž každý přejde do režimu spánku v intervalu, který určuje generátor náhodných čísel.The following example creates three tasks, each of which sleeps for an interval determine by a random number generator. Metoda WaitAny(Task[]) čeká na dokončení první úlohy.The WaitAny(Task[]) method waits for the first task to complete. V příkladu se pak zobrazí informace o stavu všech tří úkolů.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

Můžete také počkat na dokončení všech řad úloh voláním metody WaitAll.You can also wait for all of a series of tasks to complete by calling the WaitAll method. Následující příklad vytvoří deset úkolů, počká na dokončení všech deseti a pak zobrazí jejich stav.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

Všimněte si, že když čekáte na dokončení jednoho nebo více úloh, všechny výjimky vyvolané ve spuštěných úlohách jsou šířeny do vlákna, které volá metodu Wait, jak ukazuje následující příklad.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. Spustí 12 úloh, tři z nich, jejichž dokončení je dokončeno normálně a tři z nich vyvolá výjimku.It launches 12 tasks, three of which complete normally and three of which throw an exception. Zbývajících šest úkolů bylo zrušeno před začátkem a tři budou zrušeny při jejich provádění.Of the remaining six tasks, three are cancelled before they start, and three are cancelled while they are executing. Výjimky jsou vyvolány ve volání metody WaitAll a jsou zpracovávány try/bloku 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

Další informace o zpracování výjimek v asynchronních operacích založených na úlohách naleznete v tématu zpracování výjimek.For more information on exception handling in task-based asynchronous operations, see Exception Handling.

Úlohy a jazyková verzeTasks and culture

Od aplikací klasické pracovní plochy, které cílí na .NET Framework 4.6.NET Framework 4.6, se jazyková verze vlákna, která vytváří a vyvolává úkol, bude součástí kontextu vlákna.Starting with desktop apps that target the .NET Framework 4.6.NET Framework 4.6, the culture of the thread that creates and invokes a task becomes part of the thread's context. To znamená, bez ohledu na aktuální jazykovou verzi vlákna, na kterém je úloha spuštěna, aktuální jazyková verze úkolu je jazyková verze volajícího vlákna.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. Pro aplikace, které cílí na verze .NET Framework před .NET Framework 4.6.NET Framework 4.6, je jazyková verze této úlohy jazyková verze vlákna, na které se úloha spouští.For apps that target versions of the .NET Framework prior to the .NET Framework 4.6.NET Framework 4.6, the culture of the task is the culture of the thread on which the task executes. Další informace naleznete v části "jazyková verze a asynchronní operace založené na úlohách" v tématu CultureInfo.For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic.

Poznámka

Aplikace pro Store dodržujte prostředí Windows Runtime v části nastavení a získání výchozí jazykové verze.Store apps follow the Windows Runtime in setting and getting the default culture.

Pro vývojáře ladicího programuFor debugger developers

Pro vývojáře, kteří implementují vlastní ladicí programy, můžou být užitečná několik interních a privátních členů úlohy (můžou se změnit z verze na verzi).For developers implementing custom debuggers, several internal and private members of task may be useful (these may change from release to release). Pole m_taskId slouží jako záložní úložiště pro vlastnost Id, avšak 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 (čítač s_taskIdCounter slouží k načtení dalšího dostupného ID pro úlohu).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). Podobně pole m_stateFlags ukládá informace o aktuální fázi životního cyklu daného úkolu, informace jsou dostupné také prostřednictvím vlastnosti Status.Similarly, the m_stateFlags field stores information about the current lifecycle stage of the task, information also accessible through the Status property. Pole m_action ukládá odkaz na delegáta úkolu a pole m_stateObject ukládá asynchronní stav předané do úlohy vývojářem.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. Nakonec pro ladicí programy, které analyzují rámce zásobníku, metoda InternalWait slouží jako potenciální značka pro případy, kdy úloha vstupuje do operace čekání.Finally, for debuggers that parse stack frames, the InternalWait method serves a potential marker for when a task is entering a wait operation.

Konstruktory

Task(Action)

Inicializuje novou Task se zadanou akcí.Initializes a new Task with the specified action.

Task(Action, CancellationToken)

Inicializuje novou Task se zadanou akcí a CancellationToken.Initializes a new Task with the specified action and CancellationToken.

Task(Action, CancellationToken, TaskCreationOptions)

Inicializuje novou Task se zadanou akcí a možnostmi vytvoření.Initializes a new Task with the specified action and creation options.

Task(Action, TaskCreationOptions)

Inicializuje novou Task se zadanou akcí a možnostmi vytvoření.Initializes a new Task with the specified action and creation options.

Task(Action<Object>, Object)

Inicializuje novou Task se zadanou akcí a stavem.Initializes a new Task with the specified action and state.

Task(Action<Object>, Object, CancellationToken)

Inicializuje novou Task se zadanou akcí, stavem a možnostmi.Initializes a new Task with the specified action, state, and options.

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

Inicializuje novou Task se zadanou akcí, stavem a možnostmi.Initializes a new Task with the specified action, state, and options.

Task(Action<Object>, Object, TaskCreationOptions)

Inicializuje novou Task se zadanou akcí, stavem a možnostmi.Initializes a new Task with the specified action, state, and options.

Vlastnosti

AsyncState

Získá objekt stavu dodaný při vytvoření Task nebo hodnotu null, pokud nebyla zadána žádná.Gets the state object supplied when the Task was created, or null if none was supplied.

CompletedTask

Načte úkol, který již byl úspěšně dokončen.Gets a task that has already completed successfully.

CreationOptions

Získá TaskCreationOptions použitý k vytvoření tohoto úkolu.Gets the TaskCreationOptions used to create this task.

CurrentId

Vrátí ID aktuálně prováděného Task.Returns the ID of the currently executing Task.

Exception

Získá AggregateException, který způsobil předčasné ukončení Task.Gets the AggregateException that caused the Task to end prematurely. Pokud se Task úspěšně dokončil nebo ještě nevolala žádná výjimka, vrátí se null.If the Task completed successfully or has not yet thrown any exceptions, this will return null.

Factory

Poskytuje přístup k výrobním metodám pro vytváření a konfiguraci instancí Task a Task<TResult>.Provides access to factory methods for creating and configuring Task and Task<TResult> instances.

Id

Získá ID pro tuto instanci Task.Gets an ID for this Task instance.

IsCanceled

Zjistí, zda tato instance Task dokončila provádění z důvodu zrušení.Gets whether this Task instance has completed execution due to being canceled.

IsCompleted

Získá hodnotu, která označuje, zda byla úloha dokončena.Gets a value that indicates whether the task has completed.

IsCompletedSuccessfully

Vrátí, zda byl úkol dokončen.Gets whether the task ran to completion.

IsFaulted

Vrátí, zda Task dokončeno z důvodu neošetřené výjimky.Gets whether the Task completed due to an unhandled exception.

Status

Získá TaskStatus tohoto úkolu.Gets the TaskStatus of this task.

Metody

ConfigureAwait(Boolean)

Nakonfiguruje await, který se používá k čekání na tento Task.Configures an awaiter used to await this Task.

ContinueWith(Action<Task,Object>, Object)

Vytvoří pokračování, které obdrží informace o stavu dodaném volajícím a provede se, až se cílový Task dokončí.Creates a continuation that receives caller-supplied state information and executes when the target Task completes.

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

Vytvoří pokračování, které obdrží informace o stavu dodaném volajícím a token zrušení a který provede asynchronní zpracování po dokončení cílového 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)

Vytvoří pokračování, které obdrží informace o stavu dodaném volajícím a token zrušení a který se provede po dokončení cíle Task.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes when the target Task completes. Pokračování se provede na základě sady zadaných podmínek a použije zadaného plánovače.The continuation executes based on a set of specified conditions and uses a specified scheduler.

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

Vytvoří pokračování, které obdrží informace o stavu dodaném volajícím a provede se, až se cílový Task dokončí.Creates a continuation that receives caller-supplied state information and executes when the target Task completes. Pokračování se provede na základě sady zadaných podmínek.The continuation executes based on a set of specified conditions.

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

Vytvoří pokračování, které obdrží informace o stavu dodaném volajícím a provede asynchronní zpracování po dokončení cílového Task.Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. Pokračování používá zadaný Plánovač.The continuation uses a specified scheduler.

ContinueWith(Action<Task>)

Vytvoří pokračování, které se provede asynchronně po dokončení cílového Task.Creates a continuation that executes asynchronously when the target Task completes.

ContinueWith(Action<Task>, CancellationToken)

Vytvoří pokračování, které přijme token zrušení a provede asynchronní zpracování po dokončení cílového Task.Creates a continuation that receives a cancellation token and executes asynchronously when the target Task completes.

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

Vytvoří pokračování, které se provede, když cílová úloha soutěží podle zadaného TaskContinuationOptions.Creates a continuation that executes when the target task competes according to the specified TaskContinuationOptions. Pokračování obdrží token zrušení a použije zadaného plánovače.The continuation receives a cancellation token and uses a specified scheduler.

ContinueWith(Action<Task>, TaskContinuationOptions)

Vytvoří pokračování, které se provede, když se cílová úloha dokončí podle zadaného TaskContinuationOptions.Creates a continuation that executes when the target task completes according to the specified TaskContinuationOptions.

ContinueWith(Action<Task>, TaskScheduler)

Vytvoří pokračování, které se provede asynchronně po dokončení cílového Task.Creates a continuation that executes asynchronously when the target Task completes. Pokračování používá zadaný Plánovač.The continuation uses a specified scheduler.

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

Vytvoří pokračování, které obdrží informace o stavu dodaném volajícím a provede asynchronní zpracování po dokončení cílového Task a vrátí hodnotu.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)

Vytvoří pokračování, které se provede asynchronně po dokončení cílového Task a vrátí hodnotu.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Pokračování obdrží informace o stavu dodaném volajícímu a token zrušení.The continuation receives caller-supplied state information and a cancellation token.

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

Vytvoří pokračování, které se provede na základě zadaných možností pokračování úlohy, když je cílový Task dokončený a vrátí hodnotu.Creates a continuation that executes based on the specified task continuation options when the target Task completes and returns a value. Pokračování obdrží informace o stavu dodaném volajícímu a token zrušení a použije zadaný Plánovač.The continuation receives caller-supplied state information and a cancellation token and uses the specified scheduler.

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

Vytvoří pokračování, které se provede na základě zadaných možností pokračování úlohy po dokončení cíle Task.Creates a continuation that executes based on the specified task continuation options when the target Task completes. Pokračování obdrží informace o stavu dodaných volajícímu.The continuation receives caller-supplied state information.

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

Vytvoří pokračování, které se provede asynchronně po dokončení cílového Task.Creates a continuation that executes asynchronously when the target Task completes. Pokračování obdrží informace o stavu dodaných volajícím a používá zadaného plánovače.The continuation receives caller-supplied state information and uses a specified scheduler.

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

Vytvoří pokračování, které se provede asynchronně po dokončení cílového Task<TResult> a vrátí hodnotu.Creates a continuation that executes asynchronously when the target Task<TResult> completes and returns a value.

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

Vytvoří pokračování, které se provede asynchronně po dokončení cílového Task a vrátí hodnotu.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Pokračování obdrží token zrušení.The continuation receives a cancellation token.

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

Vytvoří pokračování, které se provede podle zadaných možností pokračování a vrátí hodnotu.Creates a continuation that executes according to the specified continuation options and returns a value. Pokračováním bylo předáno token zrušení a použijete zadaného plánovače.The continuation is passed a cancellation token and uses a specified scheduler.

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

Vytvoří pokračování, které se provede podle zadaných možností pokračování a vrátí hodnotu.Creates a continuation that executes according to the specified continuation options and returns a value.

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

Vytvoří pokračování, které se provede asynchronně po dokončení cílového Task a vrátí hodnotu.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Pokračování používá zadaný Plánovač.The continuation uses a specified scheduler.

Delay(Int32)

Vytvoří úlohu, která se dokončí po zadaném počtu milisekund.Creates a task that completes after a specified number of milliseconds.

Delay(Int32, CancellationToken)

Vytvoří úlohu zrušit, která se dokončí po zadaném počtu milisekund.Creates a cancellable task that completes after a specified number of milliseconds.

Delay(TimeSpan)

Vytvoří úlohu, která se dokončí po zadaném časovém intervalu.Creates a task that completes after a specified time interval.

Delay(TimeSpan, CancellationToken)

Vytvoří úlohu zrušit, která se dokončí po zadaném časovém intervalu.Creates a cancellable task that completes after a specified time interval.

Dispose()

Uvolní všechny prostředky používané aktuální instancí třídy Task.Releases all resources used by the current instance of the Task class.

Dispose(Boolean)

Odstraní Taska uvolní všechny jeho nespravované prostředky.Disposes the Task, releasing all of its unmanaged resources.

Equals(Object)

Určuje, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

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

Vytvoří Task, která je dokončena z důvodu zrušení se zadaným tokenem zrušení.Creates a Task that's completed due to cancellation with a specified cancellation token.

FromCanceled<TResult>(CancellationToken)

Vytvoří Task<TResult>, která je dokončena z důvodu zrušení se zadaným tokenem zrušení.Creates a Task<TResult> that's completed due to cancellation with a specified cancellation token.

FromException(Exception)

Vytvoří Task, která byla dokončena se zadanou výjimkou.Creates a Task that has completed with a specified exception.

FromException<TResult>(Exception)

Vytvoří Task<TResult>, která byla dokončena se zadanou výjimkou.Creates a Task<TResult> that's completed with a specified exception.

FromResult<TResult>(TResult)

Vytvoří Task<TResult>, která byla úspěšně dokončena se zadaným výsledkem.Creates a Task<TResult> that's completed successfully with the specified result.

GetAwaiter()

Získá await, který slouží k čekání na tento Task.Gets an awaiter used to await this Task.

GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

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

Získá Type aktuální instance.Gets the Type of the current instance.

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

Vytvoří kopii aktuálního Objectbez podstruktury.Creates a shallow copy of the current Object.

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

Zařadí zadanou práci do fronty pro spuštění ve fondu vláken a vrátí objekt Task, který představuje tuto práci.Queues the specified work to run on the thread pool and returns a Task object that represents that work.

Run(Action, CancellationToken)

Zařadí zadanou práci do fronty pro spuštění ve fondu vláken a vrátí objekt Task, který představuje tuto práci.Queues the specified work to run on the thread pool and returns a Task object that represents that work. Token zrušení umožňuje zrušení práce.A cancellation token allows the work to be cancelled.

Run(Func<Task>)

Zařadí zadanou práci do fronty pro spuštění ve fondu vláken a vrátí proxy server pro úlohu vrácenou 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)

Zařadí zadanou práci do fronty pro spuštění ve fondu vláken a vrátí proxy server pro úlohu vrácenou function.Queues the specified work to run on the thread pool and returns a proxy for the task returned by function.

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

Zařadí zadanou práci do fronty pro spuštění ve fondu vláken a vrátí proxy pro Task(TResult) vrácenou 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<Task<TResult>>, CancellationToken)

Zařadí zadanou práci do fronty pro spuštění ve fondu vláken a vrátí proxy pro Task(TResult) vrácenou 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>)

Zařadí zadanou práci do fronty pro spuštění ve fondu vláken a vrátí objekt Task<TResult>, který představuje tuto práci.Queues the specified work to run on the thread pool and returns a Task<TResult> object that represents that work.

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

Zařadí zadanou práci do fronty pro spuštění ve fondu vláken a vrátí objekt Task(TResult), který představuje tuto práci.Queues the specified work to run on the thread pool and returns a Task(TResult) object that represents that work. Token zrušení umožňuje zrušení práce.A cancellation token allows the work to be cancelled.

RunSynchronously()

Spustí Task synchronně na aktuální TaskScheduler.Runs the Task synchronously on the current TaskScheduler.

RunSynchronously(TaskScheduler)

Spustí Task synchronně na poskytnuté TaskScheduler.Runs the Task synchronously on the TaskScheduler provided.

Start()

Spustí Taska naplánuje jeho spuštění na aktuální TaskScheduler.Starts the Task, scheduling it for execution to the current TaskScheduler.

Start(TaskScheduler)

Spustí Taska naplánuje spuštění na zadaný TaskScheduler.Starts the Task, scheduling it for execution to the specified TaskScheduler.

ToString()

Vrací řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

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

Čeká na dokončení provádění Task.Waits for the Task to complete execution.

Wait(CancellationToken)

Čeká na dokončení provádění Task.Waits for the Task to complete execution. Čekání skončí, pokud je zrušený token zrušení před dokončením úkolu.The wait terminates if a cancellation token is canceled before the task completes.

Wait(Int32)

Čeká, až Task dokončit provádění během zadaného počtu milisekund.Waits for the Task to complete execution within a specified number of milliseconds.

Wait(Int32, CancellationToken)

Čeká na dokončení provádění Task.Waits for the Task to complete execution. Čekání skončí, pokud uplyne časový limit nebo je zrušen token zrušení před dokončením úkolu.The wait terminates if a timeout interval elapses or a cancellation token is canceled before the task completes.

Wait(TimeSpan)

Čeká, až Task dokončit provádění během zadaného časového intervalu.Waits for the Task to complete execution within a specified time interval.

WaitAll(Task[])

Počká, až všechny poskytnuté Task objekty dokončí provádění.Waits for all of the provided Task objects to complete execution.

WaitAll(Task[], CancellationToken)

Počká, až se všechny poskytnuté Task objekty dokončí provedení, dokud se čekání nezruší.Waits for all of the provided Task objects to complete execution unless the wait is cancelled.

WaitAll(Task[], Int32)

Počká, až se všechny poskytnuté Task objekty dokončí provádění během zadaného počtu milisekund.Waits for all of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAll(Task[], Int32, CancellationToken)

Počká, až se všechny poskytnuté Task objekty dokončí provádění během zadaného počtu milisekund nebo do doby, než se čeká na zrušení.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)

Čeká na dokončení provádění v zadaném časovém intervalu všemi zadanými Task zrušit objekty.Waits for all of the provided cancellable Task objects to complete execution within a specified time interval.

WaitAny(Task[])

Počká na dokončení provádění všech zadaných Taskch objektů.Waits for any of the provided Task objects to complete execution.

WaitAny(Task[], CancellationToken)

Počká, dokud některý z poskytnutých Task objektů nedokončí provádění, dokud se čekání nezruší.Waits for any of the provided Task objects to complete execution unless the wait is cancelled.

WaitAny(Task[], Int32)

Počká, dokud žádný z poskytnutých Task objektů nedokončí provádění během zadaného počtu milisekund.Waits for any of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAny(Task[], Int32, CancellationToken)

Počká, až tyto Task objekty dokončí provádění během zadaného počtu milisekund nebo až do zrušení tokenu zrušení.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)

Počká, až tyto Task objekty dokončí provádění během zadaného časového intervalu.Waits for any of the provided Task objects to complete execution within a specified time interval.

WhenAll(IEnumerable<Task>)

Vytvoří úlohu, která bude dokončena po dokončení všech objektů Task v vyčíslitelné kolekci.Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

WhenAll(Task[])

Vytvoří úlohu, která bude dokončena po dokončení všech objektů Task v poli.Creates a task that will complete when all of the Task objects in an array have completed.

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

Vytvoří úlohu, která bude dokončena po dokončení všech objektů Task<TResult> v vyčíslitelné kolekci.Creates a task that will complete when all of the Task<TResult> objects in an enumerable collection have completed.

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

Vytvoří úlohu, která bude dokončena po dokončení všech objektů Task<TResult> v poli.Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

WhenAny(IEnumerable<Task>)

Vytvoří úkol, který se dokončí, když se dokončí kterákoli z dodaných úkolů.Creates a task that will complete when any of the supplied tasks have completed.

WhenAny(Task[])

Vytvoří úkol, který se dokončí, když se dokončí kterákoli z dodaných úkolů.Creates a task that will complete when any of the supplied tasks have completed.

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

Vytvoří úkol, který se dokončí, když se dokončí kterákoli z dodaných úkolů.Creates a task that will complete when any of the supplied tasks have completed.

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

Vytvoří úkol, který se dokončí, když se dokončí kterákoli z dodaných úkolů.Creates a task that will complete when any of the supplied tasks have completed.

Yield()

Vytvoří očekávaný úkol, který asynchronně vrátí do aktuálního kontextu při čekání.Creates an awaitable task that asynchronously yields back to the current context when awaited.

Explicitní implementace rozhraní

IAsyncResult.AsyncWaitHandle

Získá WaitHandle, který se dá použít k čekání na dokončení úlohy.Gets a WaitHandle that can be used to wait for the task to complete.

IAsyncResult.CompletedSynchronously

Získá informace o tom, zda byla operace dokončena synchronně.Gets an indication of whether the operation completed synchronously.

Metody rozšíření

DispatcherOperationWait(Task)

Počká po neomezenou dobu, než DispatcherOperation se podklade dokončí.Waits indefinitely for the underlying DispatcherOperation to complete.

DispatcherOperationWait(Task, TimeSpan)

Počká na určenou dobu, než se podkladová DispatcherOperation hodnota dokončí.Waits for the specified amount of time for the underlying DispatcherOperation to complete.

IsDispatcherOperationTask(Task)

Vrátí hodnotu, která označuje, zda Task je tato hodnota přidružena DispatcherOperationk.Returns a value that indicates whether this Task is associated with a DispatcherOperation.

AsAsyncAction(Task)

Vrací asynchronní akci prostředí Windows Runtime, která představuje spuštěný úkol.Returns a Windows Runtime asynchronous action that represents a started task.

Platí pro

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

Všechny členy Task, s výjimkou Dispose(), jsou bezpečné pro přístup z více vláken a lze je použít z více vláken současně.All members of Task, except for Dispose(), are thread-safe and may be used from multiple threads concurrently.

Viz také