Windows apps
Sbalit obsah
Rozbalit obsah
Tento článek byl přeložený strojově. Pokud chcete zobrazit článek v angličtině, zaškrtněte políčko Angličtina. Anglickou verzi článku můžete také zobrazit v místním okně přesunutím ukazatele myši nad text.
Překlad
Angličtina
Information
The topic you requested is included in another documentation set. For convenience, it's displayed below. Choose Switch to see the topic in its original location.

Třída Task

.NET Framework (current version)
 

Publikováno: srpen 2016

System_CAPS_notePoznámka

The .NET API Reference documentation has a new home. Visit the .NET API Browser on docs.microsoft.com to see the new experience.

Představuje asynchronní operaci.

K procházení zdrojového kódu rozhraní .NET Framework pro tento typ, naleznete v části Reference Source.

Obor názvů:   System.Threading.Tasks
Sestavení:  mscorlib (v mscorlib.dll)

System.Object
  System.Threading.Tasks.Task
    System.Threading.Tasks.Task<TResult>

[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public class Task : IAsyncResult, IDisposable

NázevPopis
System_CAPS_pubmethodTask(Action)

Inicializuje novou Task spolu s určenou akcí.

System_CAPS_pubmethodTask(Action, CancellationToken)

Inicializuje novou Task spolu s určenou akcí a CancellationToken.

System_CAPS_pubmethodTask(Action, CancellationToken, TaskCreationOptions)

Inicializuje novou Task s možnostmi zadanou akci a vytvoření.

System_CAPS_pubmethodTask(Action, TaskCreationOptions)

Inicializuje novou Task s možnostmi zadanou akci a vytvoření.

System_CAPS_pubmethodTask(Action<Object>, Object)

Inicializuje novou Task s určenou akcí a stavu.

System_CAPS_pubmethodTask(Action<Object>, Object, CancellationToken)

Inicializuje novou Task s určenou akcí, stavu a možnosti.

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

Inicializuje novou Task s určenou akcí, stavu a možnosti.

System_CAPS_pubmethodTask(Action<Object>, Object, TaskCreationOptions)

Inicializuje novou Task s určenou akcí, stavu a možnosti.

NázevPopis
System_CAPS_pubpropertyAsyncState

Získá stav objektu zadán, kdy Task byl vytvořený nebo null, pokud žádné nebylo zadáno.

System_CAPS_pubpropertySystem_CAPS_staticCompletedTask

Získá úlohu, která již byla úspěšně dokončena.

System_CAPS_pubpropertyCreationOptions

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

System_CAPS_pubpropertySystem_CAPS_staticCurrentId

Vrátí ID aktuálně spuštěných Task.

System_CAPS_pubpropertyException

Získá AggregateException způsobující Task předčasné ukončení. Pokud Task byla úspěšně dokončena nebo nebyla dosud vyvolána jakékoli výjimky vrátí null.

System_CAPS_pubpropertySystem_CAPS_staticFactory

Poskytuje přístup k továrních metod pro vytváření a konfigurace Task a Task<TResult> instance.

System_CAPS_pubpropertyId

Získá ID pro tuto Task instance.

System_CAPS_pubpropertyIsCanceled

Získá zda to Task instance dokončila spuštění z důvodu probíhá její zrušení.

System_CAPS_pubpropertyIsCompleted

Získá zda to Task byla dokončena.

System_CAPS_pubpropertyIsFaulted

Získá zda Task Dokončit z důvodu neošetřené výjimky.

System_CAPS_pubpropertyStatus

Získá TaskStatus tohoto úkolu.

NázevPopis
System_CAPS_pubmethodConfigureAwait(Boolean)

Konfiguruje awaiter používá k await to Task.

System_CAPS_pubmethodContinueWith(Action<Task, Object>, Object)

Vytvoří pokračování, které obdrží informace o volajícím zadané stavu a provede při cíl Task dokončení.

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

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

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

Vytvoří pokračování, která přijímá informace o volajícím zadané stavu a token zrušení a, která se spouští při cíl Task dokončení. Pokračování provádí na základě sady splnění určitých podmínek a použije zadaný plánovače.

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

Vytvoří pokračování, které obdrží informace o volajícím zadané stavu a provede při cíl Task dokončení. Pokračování provádí na základě sady splnění určitých podmínek.

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

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

System_CAPS_pubmethodContinueWith(Action<Task>)

Vytvoří pokračování, které se provádí asynchronně při cíl Task dokončení.

System_CAPS_pubmethodContinueWith(Action<Task>, CancellationToken)

Vytvoří pokračování, který přijímá token zrušení a provádí asynchronně při cíl Task dokončení.

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

Vytvoří pokračování, které se spustí, pokud cílová úloha soupeří podle zadané TaskContinuationOptions. Pokračování přijímá token zrušení a používá zadaný plánovače.

System_CAPS_pubmethodContinueWith(Action<Task>, TaskContinuationOptions)

Vytvoří pokračování, který se spustí po dokončení úlohy cíl podle zadané TaskContinuationOptions.

System_CAPS_pubmethodContinueWith(Action<Task>, TaskScheduler)

Vytvoří pokračování, které se provádí asynchronně při cíl Task dokončení. Pokračování používá zadaný plánovače.

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

Vytvoří pokračování, které se provádí asynchronně při cíl Task<TResult> dokončí a vrátí hodnotu.

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

Vytvoří pokračování, které se provádí asynchronně při cíl Task dokončí a vrátí hodnotu. Pokračování přijímá token zrušení.

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

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

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

Vytvoří pokračování, které se provádí podle možnosti zadané pokračování a vrátí hodnotu.

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

Vytvoří pokračování, které se provádí asynchronně při cíl Task dokončí a vrátí hodnotu. Pokračování používá zadaný plánovače.

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

Vytvoří pokračování, které přijímá informace zadané volající stavu a spustí asynchronně při cíl Task dokončí a vrátí hodnotu.

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

Vytvoří pokračování, které se provádí asynchronně při cíl Task dokončí a vrátí hodnotu. Informace o volajícím zadané stavu a token zrušení obdrží pokračování.

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

Vytvoří pokračování, které provádí podle zadané možnosti pokračování úlohy, kdy cílový Task dokončí a vrátí hodnotu. Pokračování obdrží informace o stavu zadaný volající a token zrušení a použije zadaný plánovače.

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

Vytvoří pokračování, které provádí podle zadané možnosti pokračování úlohy, kdy cílový Task dokončení. Pokračování obdrží informace o stavu zadaný volajícího.

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

Vytvoří pokračování, které se provádí asynchronně při cíl Task dokončení. Pokračování obdrží informace o volajícím zadané stavu a použije zadaný plánovače.

System_CAPS_pubmethodSystem_CAPS_staticDelay(Int32)

Vytvoří úlohu, která je dokončena po prodlevě čas.

System_CAPS_pubmethodSystem_CAPS_staticDelay(Int32, CancellationToken)

Vytvoří zrušit úlohu, která je dokončena po prodlevě čas.

System_CAPS_pubmethodSystem_CAPS_staticDelay(TimeSpan)

Vytvoří úlohu, která je dokončena po zadaný časový interval.

System_CAPS_pubmethodSystem_CAPS_staticDelay(TimeSpan, CancellationToken)

Vytvoří zrušit úlohu, která je dokončena po zadaný časový interval.

System_CAPS_pubmethodDispose()

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

System_CAPS_protmethodDispose(Boolean)

Odstraňuje Task, uvolnění všech jeho nespravovaných prostředků.

System_CAPS_pubmethodEquals(Object)

Určuje, zda se zadaný objekt rovná aktuálnímu objektu.(Zděděno z Object.)

System_CAPS_protmethodFinalize()

Umožňuje objekt k pokusu o uvolnění prostředků a provádět další operace čištění předtím, než je uvolněn systémem uvolňování paměti.(Zděděno z Object.)

System_CAPS_pubmethodSystem_CAPS_staticFromCanceled(CancellationToken)

Vytvoří Task dokončení z důvodu zrušení s token zrušení zadaný.

System_CAPS_pubmethodSystem_CAPS_staticFromCanceled<TResult>(CancellationToken)

Vytvoří Task<TResult> dokončení z důvodu zrušení s token zrušení zadaný.

System_CAPS_pubmethodSystem_CAPS_staticFromException(Exception)

Vytvoří Task byla dokončena se zadanou výjimkou.

System_CAPS_pubmethodSystem_CAPS_staticFromException<TResult>(Exception)

Vytvoří Task<TResult> dokončení se zadanou výjimkou.

System_CAPS_pubmethodSystem_CAPS_staticFromResult<TResult>(TResult)

Vytvoří Task<TResult> je úspěšně dokončena s výsledkem zadané.

System_CAPS_pubmethodGetAwaiter()

Získá awaiter používá k await to Task.

System_CAPS_pubmethodGetHashCode()

Slouží jako výchozí funkce hash.(Zděděno z Object.)

System_CAPS_pubmethodGetType()

Získá Type aktuální instance.(Zděděno z Object.)

System_CAPS_protmethodMemberwiseClone()

Vytvoří mělká kopie aktuálního Object.(Zděděno z Object.)

System_CAPS_pubmethodSystem_CAPS_staticRun(Action)

Fronty zadaná práce pro spuštění ve fondu vláken a vrátí Task objekt, který představuje tuto práci.

System_CAPS_pubmethodSystem_CAPS_staticRun(Action, CancellationToken)

Fronty zadaná práce pro spuštění ve fondu vláken a vrátí Task objekt, který představuje tuto práci. Token zrušení umožňuje zrušit prací.

System_CAPS_pubmethodSystem_CAPS_staticRun(Func<Task>)

Fronty zadaná práce pro spuštění ve fondu vláken a vrátí proxy pro Úloha vrácená function.

System_CAPS_pubmethodSystem_CAPS_staticRun(Func<Task>, CancellationToken)

Fronty zadaná práce pro spuštění ve fondu vláken a vrátí proxy pro Úloha vrácená function.

System_CAPS_pubmethodSystem_CAPS_staticRun<TResult>(Func<TResult>)

Fronty zadaná práce pro spuštění ve fondu vláken a vrátí Task<TResult> objekt, který představuje tuto práci.

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

Fronty zadaná práce pro spuštění ve fondu vláken a vrátí Task(TResult) objekt, který představuje tuto práci. Token zrušení umožňuje zrušit prací.

System_CAPS_pubmethodSystem_CAPS_staticRun<TResult>(Func<Task<TResult>>)

Fronty zadaná práce pro spuštění ve fondu vláken a vrátí proxy pro Task(TResult) vrácený function.

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

Fronty zadaná práce ke spuštění ve fondu vláken a vrátí proxy server pro Task(TResult) vrácený function.

System_CAPS_pubmethodRunSynchronously()

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

System_CAPS_pubmethodRunSynchronously(TaskScheduler)

Spustí Task synchronně na TaskScheduler zadat.

System_CAPS_pubmethodStart()

Spustí Task, plánování pro spuštění na aktuální TaskScheduler.

System_CAPS_pubmethodStart(TaskScheduler)

Spustí Task, plánování pro spuštění na zadaný TaskScheduler.

System_CAPS_pubmethodToString()

Vrátí řetězec, který představuje aktuální objekt.(Zděděno z Object.)

System_CAPS_pubmethodWait()

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

System_CAPS_pubmethodWait(CancellationToken)

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

System_CAPS_pubmethodWait(Int32)

Čeká Task pro spuštění v rámci zadaný počet milisekund, po dokončení.

System_CAPS_pubmethodWait(Int32, CancellationToken)

Čeká Task k dokončení provádění. Čekání ukončí, když uplyne časový limit nebo token zrušení se zrušilo před dokončením úlohy.

System_CAPS_pubmethodWait(TimeSpan)

Čeká Task k dokončení spuštění v rámci zadaného časového intervalu.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[])

Čeká na všechny poskytnutého Task objekty na dokončení provádění.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], CancellationToken)

Čeká na všechny ze zadaných Task objekty, které chcete dokončit provádění, pokud byla zrušena čekání.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], Int32)

Čeká na všechny ze zadaných Task objekty pro spuštění v rámci zadaný počet milisekund, po dokončení.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], Int32, CancellationToken)

Čeká na všechny ze zadaných Task objekty, které chcete dokončit provádění v rámci určeného čísla milisekund nebo dokud čekání byla zrušena.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], TimeSpan)

Počká pro všechny ze zadaných zrušit Task objekty, které chcete dokončit provádění v rámci zadaného časového intervalu.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[])

Čeká na některý ze zadaných Task objekty, které chcete dokončit provádění.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], CancellationToken)

Čeká na některý ze zadaných Task objekty, které chcete dokončit provádění, pokud byla zrušena čekání.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], Int32)

Čeká na některý ze zadaných Task objekty pro spuštění v rámci zadaný počet milisekund, po dokončení.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], Int32, CancellationToken)

Čeká na některý ze zadaných Task objekty, které chcete dokončit provádění v rámci určeného čísla milisekund nebo dokud token zrušení byla zrušena.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], TimeSpan)

Čeká na některý ze zadaných Task objekty, které chcete dokončit provádění v rámci zadaného časového intervalu.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll(IEnumerable<Task>)

Vytvoří úlohu, která bude dokončena, kdy všechny Task dokončili objekty v vyčíslitelné kolekce.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll(Task[])

Vytvoří úlohu, která bude dokončena, kdy všechny Task dokončili objekty v poli.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll<TResult>(IEnumerable<Task<TResult>>)

Vytvoří úlohu, která bude dokončena, kdy všechny Task<TResult> dokončili objekty v vyčíslitelné kolekce.

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

Vytvoří úlohu, která bude dokončena, kdy všechny Task<TResult> dokončili objekty v poli.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny(IEnumerable<Task>)

Vytvoří úlohu, která bude dokončena, když byly dokončeny všechny zadané úlohy.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny(Task[])

Vytvoří úlohu, která bude dokončena, když byly dokončeny všechny zadané úlohy.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny<TResult>(IEnumerable<Task<TResult>>)

Vytvoří úlohu, která bude dokončena, když byly dokončeny všechny zadané úlohy.

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

Vytvoří úlohu, která bude dokončena, když byly dokončeny všechny zadané úlohy.

System_CAPS_pubmethodSystem_CAPS_staticYield()

Vytvoří awaitable úkol, který asynchronně dává zpět do aktuálního kontextu při očekáváno.

NázevPopis
System_CAPS_pubinterfaceSystem_CAPS_privpropertyIAsyncResult.AsyncWaitHandle

Získá WaitHandle který lze použít pro čekání na dokončení úlohy.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIAsyncResult.CompletedSynchronously

Získá údaj o tom, zda operace dokončena synchronně.

NázevPopis
System_CAPS_pubmethodDispatcherOperationWait()

Přetížené Čeká na dobu neurčitou podkladové DispatcherOperation k dokončení.(Definoval TaskExtensions.)

System_CAPS_pubmethodDispatcherOperationWait(TimeSpan)

Přetížené Čeká na specifikovaný čas pro základní DispatcherOperation k dokončení.(Definoval TaskExtensions.)

System_CAPS_pubmethodIsDispatcherOperationTask()

Vrátí hodnotu, která označuje, zda to Task je přidružen DispatcherOperation.(Definoval TaskExtensions.)

System_CAPS_notePoznámka

Chcete-li zobrazit zdrojový kód rozhraní .NET Framework pro tento typ, naleznete v části Reference Source. Můžete procházet zdrojový kód online, stahování odkazu pro zobrazení offline a krokovat zdroje (včetně oprav a aktualizací) během ladění. see instructions.

Task Třídy představuje jedné operace, která nevrací hodnotu, kterou obvykle provádí asynchronně. Task objekty jsou jedním z centrální součásti asynchronní vzor založený na úlohách poprvé představena v rozhraní .NET Framework 4. Protože práce prováděné Task objekt obvykle provádí asynchronně na vláknu fondu vláken spíše než synchronně u hlavního vlákna aplikace, můžete Status vlastnost, stejně jako IsCanceled, IsCompleted, a IsFaulted Vlastnosti k určení stavu úlohy. Výraz lambda nejčastěji slouží k určení práci, kterou je úkol provést.

Pro operace, které vrací hodnoty, můžete použít Task<TResult> třídy.

V této části:

Vytvoření a provedení úkolu
Oddělení úloh vytvoření a spuštění
Čekání na dokončení jedné nebo více úloh
Úlohy a jazykovou verzi
Pro vývojáře ladicího programu

Task instance může být vytvořené v mnoha různými způsoby. Nejběžnějším přístupem, která je k dispozici od verze .NET Framework 4.5, je volání statických Run Metoda. Run Metoda poskytuje jednoduchý způsob, jak spustit úlohu pomocí výchozí hodnoty a bez nutnosti další parametry. Následující příklad používá Run(Action) Metoda spustit úlohu, která smyčky a poté zobrazí počet iterací, smyčka:

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Run( () => {
                                  // 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

Alternativu a nejběžnější způsob úlohu lze spustit .NET Framework 4, je statické TaskFactory.StartNew Metoda. Task.Factory Vlastnost vrátí TaskFactory objektu. Přetížení TaskFactory.StartNew metody umožňují zadat parametry pro předání možnosti vytvoření úlohy a Plánovač úkolů. Následující příklad používá TaskFactory.StartNew Metoda spuštění úlohy. Je funkčně ekvivalentní kód 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

Kompletní příklady naleznete v tématu Asynchronní programování založené na úlohách.

Task Třída rovněž poskytuje konstruktory, který inicializovat úkol, ale který není ji naplánovat na provedení. Z důvodů výkonu Task.Run nebo TaskFactory.StartNew Metoda je upřednostňovaný postup pro vytváření a plánování výpočetní úlohy, ale pro scénáře, kde musí být odděleny vytváření a plánování, můžete použít konstruktory a poté zavolejte Task.Start Metoda naplánovat úlohy pro spuštění později.

Vzhledem k tomu, že úkoly obvykle běží asynchronně na vláknu fondu vláken, vlákna, která vytvoří a spustí úlohu spuštění pokračuje, co nejdříve po vytvoření instance úlohy. V některých případech, když volající vlákno je hlavního vlákna aplikace, aplikace může ukončit před kteroukoli úlohu ve skutečnosti zahájí provádění. V jiných případech může vyžadovat vaše aplikační logiku, že volající vlákno v provádění pokračovat pouze v případě, že jeden nebo více úkolů dokončil provádění. Můžete synchronizovat provádění volajícího vlákna a asynchronní úlohy se spustí pomocí volání Wait Metoda čekat na dokončení jedné nebo více úloh.

Chcete-li čekat na dokončení jedné úlohy, můžete zavolat jeho Task.Wait Metoda. Volání Wait Metoda blokuje volající vlákno, dokud jedna instance třídy byl dokončen.

Následující příklad volá bezparametrový Wait() Metoda bezpodmínečně čekat, dokud nebude úloha dokončena. Úloha simuluje pracovní voláním Thread.Sleep Metoda do režimu spánku pro dvě sekundy.

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

Můžete také podmíněně počkat na dokončení úlohy. Wait(Int32) a Wait(TimeSpan) metody blokuje volající vlákno, dokud na dokončení úlohy nebo uplyne časový limit, nastane dříve. Vzhledem k tomu, že v následujícím příkladu spustí úlohu, která definuje hodnotu časového limitu jedné sekundy, volající vlákno blokuje, dokud vyprší časový limit ale dvě sekundy v režimu spánku a před úlohy byl dokončen.

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.

Můžete také zadat token zrušení voláním Wait(CancellationToken) a Wait(Int32, CancellationToken) metody. Pokud tento token IsCancellationRequested vlastnost je true, zrušena čekání; Pokud se stane při true Wait Metoda ukončí.

V některých případech můžete chtít čekat v první řadě provádění úlohy dokončit, ale není pozornost, které úlohy je je. Pro tento účel můžete volat jednu z přetížení Task.WaitAll Metoda. Následující příklad vytvoří tři úkoly, z nichž každá v režimu spánku pro interval určování Generátor pseudonáhodných čísel. WaitAny(Task[]) Metoda čeká na dokončení první úlohy. Následně příklad zobrazí informace o stavu všechny tři úkoly.

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

Můžete také počkat na řadu úloh dokončete voláním WaitAll Metoda. Následující příklad vytvoří deset úloh, počká na všech deset k dokončení a potom 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

Všimněte si, že při čekání na dokončení jedné nebo více úloh, jsou šířeny jakýchkoli výjimek v spuštěné úlohy na vlákno, které volá Wait jako následující příklad ukazuje metodu. Spustí 12 úlohy, z nichž tři normálně dokončeno a tři které throw výjimce. Zbývající šest úkolů tři jsou zrušena před zahájením a tři jsou zrušena při jejich provádění. Výjimky jsou vyvolány v WaitAll volání metody a jsou zpracována trynebocatch bloku.

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

Další informace o zpracování výjimek v asynchronních operací založený na úlohách najdete v části Zpracování výjimek (Task Parallel Library).

Od verze aplikace klasické pracovní plochy, které se zaměřují .NET Framework 4.6, jazykovou verzi vlákna, která vytvoří a spustí úlohu se stane součástí kontextu vlákna. Bez ohledu na aktuální jazykové verzi vlákna, na kterém se spustí úlohu, aktuální jazykové verze úlohy je jazyková verze volajícího vlákna. Pro aplikace, které cílové verze rozhraní .NET Framework před verzí .NET Framework 4.6, jazyková verze úlohy je jazykovou verzi vlákna, na kterém se provádí úlohy. Další informace naleznete v části "Jazyková verze a task-based asynchronních operací" v CultureInfo tématu.

System_CAPS_notePoznámka

Aplikace pro Store podle Windows Runtime v nastavení a získání výchozí jazykovou verzi.

Pro vývojáře, implementace vlastního ladicí programy může být užitečné, (tyto může změnit z vydání release) několika interní a soukromé členy úlohy. m_taskId Slouží jako záložní úložiště pro pole Id vlastnost, ale při přístupu k tohoto pole přímo z ladicí program může být efektivnější než přístup na stejnou hodnotu prostřednictvím metoda getter vlastnosti ( s_taskIdCounter čítač slouží k získání ID další dostupná pro úlohu). Podobně m_stateFlags pole jsou uloženy informace o aktuální fázi životního cyklu úkolu, informace, které jsou také přístupné prostřednictvím Status vlastnost. m_action Pole jsou uloženy odkaz na delegáta úkolu a m_stateObject pole jsou uloženy asynchronní stav předán úkolu vývojářem. Nakonec pro ladicí programy, které analyzovat rámce zásobníku InternalWait Metoda slouží potenciální značky, když je úloha zadávání operaci čekání.

Následující příklad vytvoří a spustí čtyři úkoly. Provést tři úkoly Action<T> delegáta s názvem action, která přijímá argument typu Object. Čtvrtý úloha provede výrazu lambda ( Action Delegovat) která je definována vložením ve volání metody vytváření úloh. Každý úkol je vytvořena instance a spusťte jiným způsobem:

  • Úloha t1 je vytvořena instance pomocí volání konstruktoru třídy úloh, ale je spuštěna voláním jeho Start() Metoda pouze po dokončení úlohy t2 bylo zahájeno.

  • Úloha t2 je vytvořena a spuštěna v rámci jednoho volání metody voláním TaskFactory.StartNew(Action<Object>, Object) Metoda.

  • Úloha t3 je vytvořena a spuštěna v rámci jednoho volání metody voláním Run(Action) Metoda.

  • Úloha t4 je proveden synchronně v hlavním vlákně voláním RunSynchronously() Metoda.

Protože úloha t4 provedena synchronně, provede na hlavního vlákna aplikace. Zbývající úkoly spustit asynchronně obvykle na jeden nebo více vláken 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 demonstate 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

Univerzální platforma Windows
K dispozici od 8
.NET Framework
K dispozici od 4.0
Přenosná knihovna tříd
Podporováno v: přenosné platformy .NET
Silverlight
K dispozici od 5.0
Windows Phone Silverlight
K dispozici od 8.0
Windows Phone
K dispozici od 8.1

Všichni členové Task, s výjimkou Dispose, jsou bezpečné pro vlákna a může používat z více vláken současně.

Zpět na začátek
Zobrazit:
© 2018 Microsoft