Task<TResult> Třída

Reference

Definice

Obor názvů:: System.Threading.Tasks

Sestavení:: System.Threading.Tasks.dll

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Představuje asynchronní operaci, která může vrátit hodnotu.

generic <typename TResult>
public ref class Task : System::Threading::Tasks::Task

public class Task<TResult> : System.Threading.Tasks.Task

type Task<'Result> = class
    inherit Task

Public Class Task(Of TResult)
Inherits Task

Parametry typu

TResult

Typ výsledku vytvořeného tímto Task<TResult>.

Dědičnost: Object

Task
Task<TResult>

Poznámky

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

Task<TResult> instance mohou být vytvořeny různými způsoby. Nejběžnějším přístupem, který je k dispozici od rozhraní .NET Framework 4.5, je volat statickou Task.Run<TResult>(Func<TResult>) nebo Task.Run<TResult>(Func<TResult>, CancellationToken) metodu. Tyto metody poskytují jednoduchý způsob, jak spustit úlohu pomocí výchozích hodnot a bez získání dalších parametrů. Následující příklad používá metodu Task.Run<TResult>(Func<TResult>) ke spuštění úlohy, která smyčky a pak zobrazí počet iterací smyčky:

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task<int>.Run( () => {
                                      // Just loop.
                                      int max = 1000000;
                                      int ctr = 0;
                                      for (ctr = 0; ctr <= max; ctr++) {
                                         if (ctr == max / 2 && DateTime.Now.Hour <= 12) {
                                            ctr++;
                                            break;
                                         }
                                      }
                                      return ctr;
                                    } );
      Console.WriteLine("Finished {0:N0} iterations.", t.Result);
   }
}
// The example displays output like the following:
//        Finished 1,000,001 loop iterations.

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task(Of Integer) = Task.Run(Function()
                                  Dim max As Integer = 1000000
                                  Dim ctr As Integer
                                  For ctr = 0 to max
                                     If ctr = max \ 2 And Date.Now.Hour <= 12 Then
                                        ctr += 1
                                        Exit For
                                     End If
                                  Next
                                  Return ctr
                               End Function)
      Console.WriteLine("Finished {0:N0} iterations.", t.Result)
   End Sub
End Module
' The example displays the following output:
'       Finished 1,000,001 loop iterations

Alternativou a nejběžnějším způsobem spuštění úlohy v rozhraní .NET Framework 4 je volání statické TaskFactory.StartNew nebo TaskFactory<TResult>.StartNew metody. Vlastnost Task.Factory vrátí objekt TaskFactory a vlastnost Task<TResult>.Factory vrátí TaskFactory<TResult> objekt. Přetížení jejich StartNew metoda umožňuje předat argumenty, definovat možnosti vytváření úkolů a zadat plánovač úloh. Následující příklad používá metodu TaskFactory<TResult>.StartNew(Func<TResult>) ke spuštění úkolu. Funkčně odpovídá kódu v předchozím příkladu.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task<int>.Factory.StartNew( () => {
                                      // Just loop.
                                      int max = 1000000;
                                      int ctr = 0;
                                      for (ctr = 0; ctr <= max; ctr++) {
                                         if (ctr == max / 2 && DateTime.Now.Hour <= 12) {
                                            ctr++;
                                            break;
                                         }
                                      }
                                      return ctr;
                               } );
      Console.WriteLine("Finished {0:N0} iterations.", t.Result);
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t = Task(Of Integer).Factory.StartNew(Function()
                                  Dim max As Integer = 1000000
                                  Dim ctr As Integer
                                  For ctr = 0 to max
                                     If ctr = max \ 2 And Date.Now.Hour <= 12 Then
                                       ctr += 1
                                       Exit For
                                     End If
                                  Next
                                  Return ctr
                               End Function)
      Console.WriteLine("Finished {0:N0} iterations.", t.Result)
   End Sub
End Module
' The example displays output like the following:
'       Finished 1,000,001 iterations

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

Třída Task<TResult> také poskytuje konstruktory, které inicializují úlohu, ale neplánují ji pro provádění. Z důvodů výkonu jsou upřednostňované mechanismy vytváření a plánování výpočetních úloh Task.Run a Task.Factory.StartNew metody, ale ve scénářích, kdy je nutné oddělit vytváření a plánování úkolů, mohou být použity konstruktory a metodu Start úlohy pak lze použít k naplánování úlohy pro provádění později.

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

Pro operace, které nevrací hodnotu, použijte třídu Task. Počínaje jazykem C# 7.0 použijte pro jednodušší úlohu, která je typ hodnoty, nikoli typ odkazu, použijte strukturu System.Threading.Tasks.ValueTask<TResult>.

Konstruktory

Task<TResult>(Func<Object,TResult>, Object)	Inicializuje novou Task<TResult> se zadanou funkcí a stavem.
Task<TResult>(Func<Object,TResult>, Object, CancellationToken)	Inicializuje nový Task<TResult> se zadanou akcí, stavem a možnostmi.
Task<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions)	Inicializuje nový Task<TResult> se zadanou akcí, stavem a možnostmi.
Task<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	Inicializuje nový Task<TResult> se zadanou akcí, stavem a možnostmi.
Task<TResult>(Func<TResult>)	Inicializuje novou Task<TResult> se zadanou funkcí.
Task<TResult>(Func<TResult>, CancellationToken)	Inicializuje novou Task<TResult> se zadanou funkcí.
Task<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions)	Inicializuje novou Task<TResult> se zadanou funkcí a možnostmi vytvoření.
Task<TResult>(Func<TResult>, TaskCreationOptions)	Inicializuje novou Task<TResult> se zadanou funkcí a možnostmi vytvoření.

Vlastnosti

AsyncState	Získá stav objekt zadaný při vytvoření Task nebo null pokud nebyla zadána. (Zděděno od Task)
CreationOptions	Získá TaskCreationOptions použitý k vytvoření této úlohy. (Zděděno od Task)
Exception	Získá AggregateException, která způsobila Task předčasně ukončit. Pokud se Task úspěšně dokončil nebo ještě nevyvolá žádné výjimky, vrátí se `null`. (Zděděno od Task)
Factory	Získá metodu továrny pro vytváření a konfiguraci Task<TResult> instancí.
Id	Získá ID pro tuto instanci Task. (Zděděno od Task)
IsCanceled	Získá, zda tato Task instance dokončila provádění z důvodu zrušení. (Zděděno od Task)
IsCompleted	Získá hodnotu, která označuje, zda úkol byl dokončen. (Zděděno od Task)
IsCompletedSuccessfully	Získá, zda úkol běžel na dokončení. (Zděděno od Task)
IsFaulted	Získá, zda Task dokončena kvůli neošetřené výjimce. (Zděděno od Task)
Result	Získá výslednou hodnotu tohoto Task<TResult>.
Status	Získá TaskStatus tohoto úkolu. (Zděděno od Task)

Metody

ConfigureAwait(Boolean)	Konfiguruje awaiter, který se používá k vyčkání tohoto Task<TResult>.
ConfigureAwait(Boolean)	Konfiguruje awaiter, který se používá k vyčkání tohoto Task. (Zděděno od Task)
ConfigureAwait(ConfigureAwaitOptions)	Konfiguruje awaiter, který se používá k vyčkání tohoto Task.
ConfigureAwait(ConfigureAwaitOptions)	Konfiguruje awaiter, který se používá k vyčkání tohoto Task. (Zděděno od Task)
ContinueWith(Action<Task,Object>, Object)	Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a spustí se po dokončení cílového Task. (Zděděno od Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken)	Vytvoří pokračování, které přijímá informace o stavu zadané volajícím a token zrušení a který se spustí asynchronně po dokončení cílového Task. (Zděděno od Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Vytvoří pokračování, které přijímá informace o stavu zadané volajícím a token zrušení a který se spustí po dokončení cílového Task. Pokračování se provede na základě sady zadaných podmínek a použije zadaný plánovač. (Zděděno od Task)
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)	Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a spustí se po dokončení cílového Task. Pokračování se provede na základě sady zadaných podmínek. (Zděděno od Task)
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a spustí se asynchronně po dokončení cílového Task. Pokračování používá zadaný plánovač. (Zděděno od Task)
ContinueWith(Action<Task<TResult>,Object>, Object)	Vytvoří pokračování, které se předá informace o stavu a které se spustí po dokončení cílového Task<TResult>.
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken)	Vytvoří pokračování, které se spustí po dokončení cílového Task<TResult>.
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Vytvoří pokračování, které se spustí po dokončení cílového Task<TResult>.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions)	Vytvoří pokračování, které se spustí po dokončení cílového Task<TResult>.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler)	Vytvoří pokračování, které se spustí po dokončení cílového Task<TResult>.
ContinueWith(Action<Task<TResult>>)	Vytvoří pokračování, které se provede asynchronně po dokončení cílové úlohy.
ContinueWith(Action<Task<TResult>>, CancellationToken)	Vytvoří zrušené pokračování, které se provede asynchronně po dokončení cílového Task<TResult>.
ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Vytvoří pokračování, které se provede podle podmínky zadané v `continuationOptions`.
ContinueWith(Action<Task<TResult>>, TaskContinuationOptions)	Vytvoří pokračování, které se provede podle podmínky zadané v `continuationOptions`.
ContinueWith(Action<Task<TResult>>, TaskScheduler)	Vytvoří pokračování, které se provede asynchronně po dokončení cílového Task<TResult>.
ContinueWith(Action<Task>)	Vytvoří pokračování, které se provede asynchronně po dokončení cílového Task. (Zděděno od Task)
ContinueWith(Action<Task>, CancellationToken)	Vytvoří pokračování, které přijímá token zrušení asynchronně po dokončení cílového Task. (Zděděno od Task)
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Vytvoří pokračování, které se provede, když cílová úloha konkuruje podle zadané TaskContinuationOptions. Pokračování obdrží token zrušení a použije zadaný plánovač. (Zděděno od Task)
ContinueWith(Action<Task>, TaskContinuationOptions)	Vytvoří pokračování, které se spustí při dokončení cílové úlohy podle zadané TaskContinuationOptions. (Zděděno od Task)
ContinueWith(Action<Task>, TaskScheduler)	Vytvoří pokračování, které se provede asynchronně po dokončení cílového Task. Pokračování používá zadaný plánovač. (Zděděno od Task)
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object)	Vytvoří pokračování, které se spustí po dokončení cílového Task<TResult>.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken)	Vytvoří pokračování, které se spustí po dokončení cílového Task<TResult>.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Vytvoří pokračování, které se spustí po dokončení cílového Task<TResult>.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions)	Vytvoří pokračování, které se spustí po dokončení cílového Task<TResult>.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler)	Vytvoří pokračování, které se spustí po dokončení cílového Task<TResult>.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)	Vytvoří pokračování, které se provede asynchronně po dokončení cílového Task<TResult>.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken)	Vytvoří pokračování, které se provede asynchronně po dokončení cílového Task<TResult>.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Vytvoří pokračování, které se provede podle podmínky zadané v `continuationOptions`.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions)	Vytvoří pokračování, které se provede podle podmínky zadané v `continuationOptions`.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskScheduler)	Vytvoří pokračování, které se provede asynchronně po dokončení cílového Task<TResult>.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	Vytvoří pokračování, které přijímá informace o stavu zadané volajícím a spustí se asynchronně, když cíl Task dokončí a vrátí hodnotu. (Zděděno od Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	Vytvoří pokračování, které se provede asynchronně, když cíl Task dokončí a vrátí hodnotu. Pokračování obdrží informace o stavu zadané volajícím a token zrušení. (Zděděno od Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Vytvoří pokračování, které se spustí na základě zadaných možností pokračování úkolu, když cíl Task dokončí a vrátí hodnotu. Pokračování přijímá informace o stavu zadaném volajícím a token zrušení a používá zadaný plánovač. (Zděděno od Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	Vytvoří pokračování, které se spustí na základě zadaných možností pokračování úkolu po dokončení cílového Task. Pokračování obdrží informace o stavu zadané volajícím. (Zděděno od Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	Vytvoří pokračování, které se provede asynchronně po dokončení cílového Task. Pokračování přijímá informace o stavu zadané volajícím a používá zadaný plánovač. (Zděděno od Task)
ContinueWith<TResult>(Func<Task,TResult>)	Vytvoří pokračování, které se provede asynchronně, když cíl Task<TResult> dokončí a vrátí hodnotu. (Zděděno od Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	Vytvoří pokračování, které se provede asynchronně, když cíl Task dokončí a vrátí hodnotu. Pokračování obdrží token zrušení. (Zděděno od Task)
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. Pokračování se předává token zrušení a používá zadaný plánovač. (Zděděno od Task)
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. (Zděděno od Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	Vytvoří pokračování, které se provede asynchronně, když cíl Task dokončí a vrátí hodnotu. Pokračování používá zadaný plánovač. (Zděděno od Task)
Dispose()	Uvolní všechny prostředky používané aktuální instancí třídy Task. (Zděděno od Task)
Dispose(Boolean)	Odstraní Task, uvolní všechny jeho nespravované prostředky. (Zděděno od Task)
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
GetAwaiter()	Získá awaiter, který se používá k čekací Task<TResult>.
GetAwaiter()	Získá awaiter, který se používá k čekací Task. (Zděděno od Task)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetType()	Získá Type aktuální instance. (Zděděno od Object)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
RunSynchronously()	Spustí Task synchronně na aktuální TaskScheduler. (Zděděno od Task)
RunSynchronously(TaskScheduler)	Spustí Task synchronně na zadaném TaskScheduler. (Zděděno od Task)
Start()	Spustí Task, naplánování spuštění na aktuální TaskScheduler. (Zděděno od Task)
Start(TaskScheduler)	Spustí Task, plánování spuštění do zadané TaskScheduler. (Zděděno od Task)
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
Wait()	Čeká na dokončení provádění Task. (Zděděno od Task)
Wait(CancellationToken)	Čeká na dokončení provádění Task. Čekání se ukončí, pokud se před dokončením úlohy zruší token zrušení. (Zděděno od Task)
Wait(Int32)	Čeká na dokončení provádění Task v zadaném počtu milisekund. (Zděděno od Task)
Wait(Int32, CancellationToken)	Čeká na dokončení provádění Task. Čekání se ukončí, pokud se před dokončením úkolu zruší časový limit nebo se zruší token zrušení. (Zděděno od Task)
Wait(TimeSpan)	Čeká na dokončení provádění Task v zadaném časovém intervalu. (Zděděno od Task)
Wait(TimeSpan, CancellationToken)	Čeká na dokončení provádění Task. (Zděděno od Task)
WaitAsync(CancellationToken)	Získá Task<TResult>, který se dokončí po dokončení tohoto Task<TResult> nebo po vyžádání zadaného CancellationToken zrušení.
WaitAsync(CancellationToken)	Získá Task, který se dokončí po dokončení tohoto Task nebo po vyžádání zadaného CancellationToken zrušení. (Zděděno od Task)
WaitAsync(TimeSpan)	Získá Task<TResult>, který se dokončí po dokončení tohoto Task<TResult> nebo po vypršení zadaného časového limitu.
WaitAsync(TimeSpan)	Získá Task, který se dokončí po dokončení tohoto Task nebo po vypršení zadaného časového limitu. (Zděděno od Task)
WaitAsync(TimeSpan, CancellationToken)	Získá Task<TResult>, který se dokončí po dokončení tohoto Task<TResult>, po vypršení zadaného časového limitu nebo když zadaný CancellationToken požádá o zrušení.
WaitAsync(TimeSpan, CancellationToken)	Získá Task, který se dokončí po dokončení tohoto Task, po vypršení zadaného časového limitu nebo když zadaný CancellationToken požádá o zrušení. (Zděděno od Task)
WaitAsync(TimeSpan, TimeProvider)	Získá Task<TResult>, který se dokončí po dokončení tohoto Task<TResult> nebo po vypršení zadaného časového limitu.
WaitAsync(TimeSpan, TimeProvider)	Získá Task, který se dokončí po dokončení tohoto Task nebo po vypršení zadaného časového limitu. (Zděděno od Task)
WaitAsync(TimeSpan, TimeProvider, CancellationToken)	Získá Task<TResult>, který se dokončí po dokončení tohoto Task<TResult>, po vypršení zadaného časového limitu nebo když zadaný CancellationToken požádá o zrušení.
WaitAsync(TimeSpan, TimeProvider, CancellationToken)	Získá Task, který se dokončí po dokončení tohoto Task, po vypršení zadaného časového limitu nebo když zadaný CancellationToken požádá o zrušení. (Zděděno od Task)

Explicitní implementace rozhraní

IAsyncResult.AsyncWaitHandle	Získá WaitHandle, který lze použít k čekání na dokončení úkolu. (Zděděno od Task)
IAsyncResult.CompletedSynchronously	Získá indikaci, zda operace byla dokončena synchronně. (Zděděno od Task)

Metody rozšíření

WaitAsync(Task, TimeSpan, TimeProvider, CancellationToken)	Získá Task, který se dokončí po dokončení tohoto Task, po vypršení zadaného časového limitu nebo když zadaný CancellationToken požádá o zrušení.
WaitAsync<TResult>(Task<TResult>, TimeSpan, TimeProvider, CancellationToken)	Získá Task, který se dokončí po dokončení tohoto Task, po vypršení zadaného časového limitu nebo když zadaný CancellationToken požádá o zrušení.
DispatcherOperationWait(Task)	Čeká po neomezenou dobu, než se podkladová DispatcherOperation dokončí.
DispatcherOperationWait(Task, TimeSpan)	Čeká na dobu, po kterou se podkladová DispatcherOperation dokončí.
IsDispatcherOperationTask(Task)	Vrátí hodnotu, která určuje, zda je tato Task přidružena k DispatcherOperation.
AsAsyncAction(Task)	Vrátí asynchronní akci prostředí Windows Runtime, která představuje spuštěnou úlohu.
AsAsyncOperation<TResult>(Task<TResult>)	Vrátí asynchronní operaci prostředí Windows Runtime, která představuje spuštěnou úlohu, která vrací výsledek.

Platí pro

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

Všechny členy Task<TResult>s výjimkou Dispose()jsou bezpečné pro přístup z více vláken a mohou být použity současně z více vláken.

Viz také

Task
knihovny TPL (Task Parallel Library)
asynchronní programování založené na úlohách
ukázky pro paralelní programování s .NET Core a .NET Standard

Sdílet prostřednictvím