Task<TResult> Classe

Definizione

Spazio dei nomi:

System.Threading.Tasks

Assembly:

System.Runtime.dll

Origine:

Future.cs

Rappresenta un'operazione asincrona che può restituire un valore.

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

Parametri di tipo

TResult

Tipo del risultato prodotto da questo Task<TResult>.

Ereditarietà

Object

Task

Task<TResult>

Commenti

La classe Task<TResult> rappresenta una singola operazione che restituisce un valore e che in genere viene eseguita in modo asincrono. Task<TResult> oggetti sono uno dei componenti centrali del modello asincrono basato su attività introdotto per la prima volta in .NET Framework 4. Poiché il lavoro eseguito da un oggetto Task<TResult> viene in genere eseguito in modo asincrono in un thread del pool di thread anziché in modo sincrono nel thread dell'applicazione principale, è possibile usare la proprietà Status, nonché le proprietà IsCanceled, IsCompletede IsFaulted, per determinare lo stato di un'attività. In genere, un'espressione lambda viene usata per specificare il lavoro che l'attività deve eseguire.

Task<TResult> istanze possono essere create in diversi modi. L'approccio più comune, disponibile a partire da .NET Framework 4.5, consiste nel chiamare il metodo statico Task.Run<TResult>(Func<TResult>) o Task.Run<TResult>(Func<TResult>, CancellationToken). Questi metodi offrono un modo semplice per avviare un'attività usando i valori predefiniti e senza acquisire parametri aggiuntivi. Nell'esempio seguente viene usato il metodo Task.Run<TResult>(Func<TResult>) per avviare un'attività che esegue un ciclo e quindi viene visualizzato il numero di iterazioni del ciclo:

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

Un'alternativa e il modo più comune per avviare un'attività in .NET Framework 4 consiste nel chiamare il metodo statico TaskFactory.StartNew o TaskFactory<TResult>.StartNew. La proprietà Task.Factory restituisce un oggetto TaskFactory e la proprietà Task<TResult>.Factory restituisce un oggetto TaskFactory<TResult>. Gli overload del metodo StartNew consentono di passare argomenti, definire le opzioni di creazione delle attività e specificare un'utilità di pianificazione. Nell'esempio seguente viene utilizzato il metodo TaskFactory<TResult>.StartNew(Func<TResult>) per avviare un'attività. È funzionalmente equivalente al codice nell'esempio precedente.

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

Per esempi più completi, vedere programmazione asincrona basata su attività.

La classe Task<TResult> fornisce anche costruttori che inizializzano l'attività, ma che non lo pianificano per l'esecuzione. Per motivi di prestazioni, i metodi Task.Run e Task.Factory.StartNew sono i meccanismi preferiti per la creazione e la pianificazione delle attività di calcolo, ma per gli scenari in cui la creazione e la pianificazione delle attività devono essere separate, i costruttori possono essere usati e il metodo Start dell'attività può quindi essere usato per pianificare l'attività per l'esecuzione in un secondo momento.

A partire dalle app desktop destinate a .NET Framework 4.6, le impostazioni cultura del thread che crea e richiama un'attività diventano parte del contesto del thread. Ovvero, indipendentemente dalle impostazioni cultura correnti del thread in cui viene eseguita l'attività, le impostazioni cultura correnti dell'attività sono le impostazioni cultura del thread chiamante. Per le app destinate alle versioni di .NET Framework precedenti a .NET Framework 4.6, le impostazioni cultura dell'attività sono le impostazioni cultura del thread in cui viene eseguita l'attività. Per altre informazioni, vedere la sezione "Impostazioni cultura e operazioni asincrone basate su attività" nell'argomento CultureInfo. Tieni presente che le app dello Store seguono Windows Runtime nell'impostazione e ottengono le impostazioni cultura predefinite.

Per le operazioni che non restituiscono un valore, usare la classe Task. A partire da C# 7.0, per un'attività più leggera che è un tipo valore anziché un tipo riferimento, usare la struttura System.Threading.Tasks.ValueTask<TResult>.

Costruttori

Task<TResult>(Func<Object,TResult>, Object)	Inizializza una nuova Task<TResult> con la funzione e lo stato specificati.
Task<TResult>(Func<Object,TResult>, Object, CancellationToken)	Inizializza una nuova Task<TResult> con l'azione, lo stato e le opzioni specificati.
Task<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions)	Inizializza una nuova Task<TResult> con l'azione, lo stato e le opzioni specificati.
Task<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	Inizializza una nuova Task<TResult> con l'azione, lo stato e le opzioni specificati.
Task<TResult>(Func<TResult>)	Inizializza una nuova Task<TResult> con la funzione specificata.
Task<TResult>(Func<TResult>, CancellationToken)	Inizializza una nuova Task<TResult> con la funzione specificata.
Task<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions)	Inizializza una nuova Task<TResult> con le opzioni di creazione e funzione specificate.
Task<TResult>(Func<TResult>, TaskCreationOptions)	Inizializza una nuova Task<TResult> con le opzioni di creazione e funzione specificate.

Proprietà

AsyncState	Ottiene l'oggetto di stato fornito quando è stato creato il Task oppure null se non è stato specificato alcun oggetto. (Ereditato da Task)
CreationOptions	Ottiene il TaskCreationOptions utilizzato per creare questa attività. (Ereditato da Task)
Exception	Ottiene il AggregateException che ha causato la fine prematura del Task. Se il Task completato correttamente o non ha ancora generato eccezioni, verrà restituito null. (Ereditato da Task)
Factory	Ottiene un metodo factory per la creazione e la configurazione di istanze di Task<TResult>.
Id	Ottiene un ID per questa istanza di Task. (Ereditato da Task)
IsCanceled	Ottiene un valore che indica se l'istanza di Task è stata completata a causa dell'annullamento. (Ereditato da Task)
IsCompleted	Ottiene un valore che indica se l'attività è stata completata. (Ereditato da Task)
IsCompletedSuccessfully	Ottiene un valore che indica se l'attività è stata eseguita fino al completamento. (Ereditato da Task)
IsFaulted	Ottiene un valore che indica se il Task è stato completato a causa di un'eccezione non gestita. (Ereditato da Task)
Result	Ottiene il valore del risultato di questa Task<TResult>.
Status	Ottiene il TaskStatus di questa attività. (Ereditato da Task)

Metodi

ConfigureAwait(Boolean)	Configura un awaiter usato per attendere questo Task<TResult>.
ConfigureAwait(ConfigureAwaitOptions)	Configura un awaiter usato per attendere questo Task.
ContinueWith(Action<Task,Object>, Object)	Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e viene eseguita al termine dell'Task di destinazione. (Ereditato da Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken)	Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e un token di annullamento e che viene eseguita in modo asincrono al completamento del Task di destinazione. (Ereditato da Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e un token di annullamento che viene eseguito al termine dell'Task di destinazione. La continuazione viene eseguita in base a un set di condizioni specificate e usa un'utilità di pianificazione specificata. (Ereditato da Task)
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)	Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e viene eseguita al termine dell'Task di destinazione. La continuazione viene eseguita in base a un set di condizioni specificate. (Ereditato da Task)
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e viene eseguita in modo asincrono al termine dell'Task di destinazione. La continuazione usa un'utilità di pianificazione specificata. (Ereditato da Task)
ContinueWith(Action<Task<TResult>,Object>, Object)	Crea una continuazione che viene passata alle informazioni sullo stato e che viene eseguita al termine dell'Task<TResult> di destinazione.
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken)	Crea una continuazione che viene eseguita al termine dell'Task<TResult> di destinazione.
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita al termine dell'Task<TResult> di destinazione.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions)	Crea una continuazione che viene eseguita al termine dell'Task<TResult> di destinazione.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler)	Crea una continuazione che viene eseguita al termine dell'Task<TResult> di destinazione.
ContinueWith(Action<Task<TResult>>)	Crea una continuazione che viene eseguita in modo asincrono al termine dell'attività di destinazione.
ContinueWith(Action<Task<TResult>>, CancellationToken)	Crea una continuazione annullabile che viene eseguita in modo asincrono al completamento del Task<TResult> di destinazione.
ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita in base alla condizione specificata in continuationOptions.
ContinueWith(Action<Task<TResult>>, TaskContinuationOptions)	Crea una continuazione che viene eseguita in base alla condizione specificata in continuationOptions.
ContinueWith(Action<Task<TResult>>, TaskScheduler)	Crea una continuazione che viene eseguita in modo asincrono al termine del Task<TResult> di destinazione.
ContinueWith(Action<Task>)	Crea una continuazione che viene eseguita in modo asincrono al termine del Task di destinazione. (Ereditato da Task)
ContinueWith(Action<Task>, CancellationToken)	Crea una continuazione che riceve un token di annullamento ed viene eseguita in modo asincrono al termine dell'Task di destinazione. (Ereditato da Task)
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione eseguita quando l'attività di destinazione compete in base al TaskContinuationOptionsspecificato. La continuazione riceve un token di annullamento e usa un'utilità di pianificazione specificata. (Ereditato da Task)
ContinueWith(Action<Task>, TaskContinuationOptions)	Crea una continuazione che viene eseguita quando l'attività di destinazione viene completata in base al TaskContinuationOptionsspecificato. (Ereditato da Task)
ContinueWith(Action<Task>, TaskScheduler)	Crea una continuazione che viene eseguita in modo asincrono al termine del Task di destinazione. La continuazione usa un'utilità di pianificazione specificata. (Ereditato da Task)
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object)	Crea una continuazione che viene eseguita al termine dell'Task<TResult> di destinazione.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken)	Crea una continuazione che viene eseguita al termine dell'Task<TResult> di destinazione.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita al termine dell'Task<TResult> di destinazione.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions)	Crea una continuazione che viene eseguita al termine dell'Task<TResult> di destinazione.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler)	Crea una continuazione che viene eseguita al termine dell'Task<TResult> di destinazione.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)	Crea una continuazione che viene eseguita in modo asincrono al termine del Task<TResult> di destinazione.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken)	Crea una continuazione che viene eseguita in modo asincrono al termine del Task<TResult> di destinazione.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita in base alla condizione specificata in continuationOptions.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions)	Crea una continuazione che viene eseguita in base alla condizione specificata in continuationOptions.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskScheduler)	Crea una continuazione che viene eseguita in modo asincrono al termine del Task<TResult> di destinazione.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e viene eseguita in modo asincrono quando il Task di destinazione viene completato e restituisce un valore. (Ereditato da Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	Crea una continuazione eseguita in modo asincrono quando il Task di destinazione viene completato e restituisce un valore. La continuazione riceve informazioni sullo stato fornite dal chiamante e un token di annullamento. (Ereditato da Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita in base alle opzioni di continuazione dell'attività specificate quando il Task di destinazione viene completato e restituisce un valore. La continuazione riceve informazioni sullo stato fornite dal chiamante e un token di annullamento e usa l'utilità di pianificazione specificata. (Ereditato da Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	Crea una continuazione eseguita in base alle opzioni di continuazione dell'attività specificate al termine dell'Task di destinazione. La continuazione riceve informazioni sullo stato fornite dal chiamante. (Ereditato da Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	Crea una continuazione che viene eseguita in modo asincrono al termine del Task di destinazione. La continuazione riceve informazioni sullo stato fornite dal chiamante e usa un'utilità di pianificazione specificata. (Ereditato da Task)
ContinueWith<TResult>(Func<Task,TResult>)	Crea una continuazione eseguita in modo asincrono quando il Task<TResult> di destinazione viene completato e restituisce un valore. (Ereditato da Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	Crea una continuazione eseguita in modo asincrono quando il Task di destinazione viene completato e restituisce un valore. La continuazione riceve un token di annullamento. (Ereditato da Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione eseguita in base alle opzioni di continuazione specificate e restituisce un valore. La continuazione viene passata a un token di annullamento e usa un'utilità di pianificazione specificata. (Ereditato da Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)	Crea una continuazione eseguita in base alle opzioni di continuazione specificate e restituisce un valore. (Ereditato da Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	Crea una continuazione eseguita in modo asincrono quando il Task di destinazione viene completato e restituisce un valore. La continuazione usa un'utilità di pianificazione specificata. (Ereditato da Task)
Dispose()	Rilascia tutte le risorse usate dall'istanza corrente della classe Task. (Ereditato da Task)
Dispose(Boolean)	Elimina il Task, rilasciando tutte le relative risorse non gestite. (Ereditato da Task)
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetAwaiter()	Ottiene un awaiter utilizzato per attendere questo Task<TResult>.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene il Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
RunSynchronously()	Esegue il Task in modo sincrono sul TaskSchedulercorrente. (Ereditato da Task)
RunSynchronously(TaskScheduler)	Esegue il Task in modo sincrono sul TaskScheduler fornito. (Ereditato da Task)
Start()	Avvia il Task, pianificandolo per l'esecuzione nel TaskSchedulercorrente. (Ereditato da Task)
Start(TaskScheduler)	Avvia il Task, pianificandolo per l'esecuzione nel TaskSchedulerspecificato. (Ereditato da Task)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
Wait()	Attende il completamento dell'esecuzione del Task. (Ereditato da Task)
Wait(CancellationToken)	Attende il completamento dell'esecuzione del Task. L'attesa termina se un token di annullamento viene annullato prima del completamento dell'attività. (Ereditato da Task)
Wait(Int32)	Attende che il Task completi l'esecuzione entro un numero specificato di millisecondi. (Ereditato da Task)
Wait(Int32, CancellationToken)	Attende il completamento dell'esecuzione del Task. L'attesa termina se un intervallo di timeout è trascorso o un token di annullamento viene annullato prima del completamento dell'attività. (Ereditato da Task)
Wait(TimeSpan)	Attende che il Task completi l'esecuzione entro un intervallo di tempo specificato. (Ereditato da Task)
Wait(TimeSpan, CancellationToken)	Attende il completamento dell'esecuzione del Task. (Ereditato da Task)
WaitAsync(CancellationToken)	Ottiene un Task<TResult> che verrà completato al termine dell'Task<TResult> o quando è stato richiesto l'annullamento dell'CancellationToken specificato.
WaitAsync(TimeSpan)	Ottiene un Task<TResult> che verrà completato al termine dell'Task<TResult> o alla scadenza del timeout specificato.
WaitAsync(TimeSpan, CancellationToken)	Ottiene un Task<TResult> che verrà completato al termine dell'Task<TResult>, alla scadenza del timeout specificato o alla richiesta di annullamento dell'CancellationToken specificato.
WaitAsync(TimeSpan, TimeProvider)	Ottiene un Task<TResult> che verrà completato al termine dell'Task<TResult> o alla scadenza del timeout specificato.
WaitAsync(TimeSpan, TimeProvider, CancellationToken)	Ottiene un Task<TResult> che verrà completato al termine dell'Task<TResult>, alla scadenza del timeout specificato o alla richiesta di annullamento dell'CancellationToken specificato.

Implementazioni dell'interfaccia esplicita

IAsyncResult.AsyncWaitHandle	Ottiene un WaitHandle che può essere utilizzato per attendere il completamento dell'attività. (Ereditato da Task)
IAsyncResult.CompletedSynchronously	Ottiene un'indicazione di se l'operazione è stata completata in modo sincrono. (Ereditato da Task)

Metodi di estensione

WaitAsync(Task, TimeSpan, TimeProvider, CancellationToken)	Ottiene un Task che verrà completato al termine dell'Task, alla scadenza del timeout specificato o alla richiesta di annullamento dell'CancellationToken specificato.
WaitAsync<TResult>(Task<TResult>, TimeSpan, TimeProvider, CancellationToken)	Ottiene un Task che verrà completato al termine dell'Task, alla scadenza del timeout specificato o alla richiesta di annullamento dell'CancellationToken specificato.

Thread safety

Tutti i membri di Task<TResult>, ad eccezione di Dispose(), sono thread-safe e possono essere usati da più thread contemporaneamente.

Vedi anche

• Task
• Task Parallel Library (TPL)
• di programmazione asincrona basata su attività
• esempi per la programmazione parallela con .NET Core e .NET Standard