Task<TResult> Classe

Definizione

Rappresenta un'operazione asincrona in grado di 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 oggetto Task<TResult>.

Ereditarietà
Task<TResult>

Commenti

La Task<TResult> classe rappresenta una singola operazione che restituisce un valore e che in genere viene eseguita in modo asincrono. Task<TResult> gli oggetti sono uno dei componenti centrali del modello asincrono basato su attività introdotto in .NET Framework 4. Poiché il lavoro eseguito da un Task<TResult> oggetto 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 Status proprietà , nonché le IsCanceledproprietà , IsCompletede IsFaulted per determinare lo stato di un'attività. In genere, viene usata un'espressione lambda per specificare il lavoro che deve essere eseguito dall'attività.

Task<TResult> Le 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 Task.Run<TResult>(Func<TResult>) metodo 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 o statico TaskFactory.StartNew TaskFactory<TResult>.StartNew . La Task.Factory proprietà restituisce un TaskFactory oggetto e la Task<TResult>.Factory proprietà restituisce un TaskFactory<TResult> oggetto . 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 TaskFactory<TResult>.StartNew(Func<TResult>) metodo 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 Task<TResult> classe fornisce anche costruttori che inizializzano l'attività, ma che non lo pianificare per l'esecuzione. Per motivi di prestazioni, i Task.Run metodi 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 separati, è possibile usare i costruttori e il metodo dell'attività Start 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 a 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 . Si noti che le app dello Store seguono le Windows Runtime nell'impostazione e ottenere le impostazioni cultura predefinite.

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

Costruttori

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

Inizializza un nuovo oggetto Task<TResult> con la funzione e lo stato specificati.

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

Inizializza un nuovo oggetto Task<TResult> con l'azione, lo stato e le opzioni specificati.

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

Inizializza un nuovo oggetto Task<TResult> con l'azione, lo stato e le opzioni specificati.

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

Inizializza un nuovo oggetto Task<TResult> con l'azione, lo stato e le opzioni specificati.

Task<TResult>(Func<TResult>)

Inizializza un nuovo oggetto Task<TResult> con la funzione specificata.

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

Inizializza un nuovo oggetto Task<TResult> con la funzione specificata.

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

Inizializza un nuovo oggetto Task<TResult> con la funzione e le opzioni di creazione specificate.

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

Inizializza un nuovo oggetto Task<TResult> con la funzione e le opzioni di creazione specificate.

Proprietà

AsyncState

Ottiene l'oggetto stato fornito quando è stato creato Task oppure null se non ne è stato fornito alcuno.

(Ereditato da Task)
CreationOptions

Ottiene l'oggetto TaskCreationOptions usato per creare questa attività.

(Ereditato da Task)
Exception

Ottiene l'oggetto AggregateException che ha causato l'interruzione anomala di Task. Se l'oggetto Task è stato completato correttamente o non ha ancora generato alcuna eccezione, verrà restituito null.

(Ereditato da Task)
Factory

Ottiene un metodo factory per la creazione e la configurazione di Task<TResult> istanze.

Id

Ottiene un ID per questa istanza di Task.

(Ereditato da Task)
IsCanceled

Ottiene un valore che indica se l'esecuzione di questa istanza di Task è stata completata perché annullata.

(Ereditato da Task)
IsCompleted

Ottiene un valore che indica l'eventuale completamento dell'attività.

(Ereditato da Task)
IsCompletedSuccessfully

Ottiene un valore che indica se l'esecuzione dell'attività è stata completata.

(Ereditato da Task)
IsFaulted

Ottiene un valore che indica se l'oggetto Task è stato completato a causa di un'eccezione non gestita.

(Ereditato da Task)
Result

Ottiene il valore del risultato di Task<TResult>.

Status

Ottiene l'oggetto TaskStatus di questa attività.

(Ereditato da Task)

Metodi

ConfigureAwait(Boolean)

Configura un elemento awaiter usato per attendere questo oggetto Task<TResult>.

ConfigureAwait(Boolean)

Configura un elemento awaiter usato per attendere questo oggetto Task.

(Ereditato da Task)
ContinueWith(Action<Task,Object>, Object)

Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e viene eseguita al completamento dell'oggetto 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 dell'oggetto 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 e che viene eseguita al completamento dell'oggetto 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 completamento dell'oggetto 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 completamento dell'oggetto Task di destinazione. La continuazione usa un'utilità di pianificazione specificata.

(Ereditato da Task)
ContinueWith(Action<Task<TResult>,Object>, Object)

Crea una continuazione che riceve informazioni sullo stato e viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

ContinueWith(Action<Task<TResult>>)

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'attività di destinazione.

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

Crea una continuazione annullabile che viene eseguita in modo asincrono al completamento dell'oggetto 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 completamento dell'oggetto Task<TResult> di destinazione.

ContinueWith(Action<Task>)

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione.

(Ereditato da Task)
ContinueWith(Action<Task>, CancellationToken)

Crea una continuazione che riceve un token di annullamento e viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione.

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

Crea una continuazione che viene eseguita al completamento dell'attività di destinazione in base all'oggetto TaskContinuationOptions specificato. 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 al completamento dell'attività di destinazione in base all'oggetto TaskContinuationOptions specificato.

(Ereditato da Task)
ContinueWith(Action<Task>, TaskScheduler)

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto 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 completamento dell'oggetto Task<TResult> di destinazione.

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

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task<TResult> di destinazione.

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

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto 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 completamento dell'oggetto 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 al completamento dell'oggetto Task di destinazione, quindi restituisce un valore.

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

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione 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 specificate per la continuazione delle attività al completamento dell'oggetto Task di destinazione, quindi restituisce un valore. La continuazione riceve informazioni sullo stato fornite dal chiamante e un token di annullamento, quindi usa l'utilità di pianificazione specificata.

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

Crea una continuazione che viene eseguita in base alle opzioni specificate per la continuazione delle attività al completamento dell'oggetto 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 completamento dell'oggetto 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 che viene eseguita in modo asincrono al completamento dell'oggetto Task<TResult> di destinazione e restituisce un valore.

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

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione 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 che viene eseguita in base alle opzioni di continuazione specificate e restituisce un valore. La continuazione riceve un token di annullamento e usa un'utilità di pianificazione specificata.

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

Crea una continuazione che viene eseguita in base alle opzioni di continuazione specificate e restituisce un valore.

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

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione 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 Task, rilasciandone tutte le risorse non gestite.

(Ereditato da Task)
Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetAwaiter()

Ottiene un elemento awaiter usato per attendere questo oggetto Task<TResult>.

GetAwaiter()

Ottiene un elemento awaiter usato per attendere questo oggetto Task.

(Ereditato da Task)
GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
RunSynchronously()

Esegue Task in modo sincrono nell'oggetto TaskScheduler corrente.

(Ereditato da Task)
RunSynchronously(TaskScheduler)

Esegue Task in modo sincrono nell'oggetto TaskScheduler fornito.

(Ereditato da Task)
Start()

Avvia Task, pianificandone l'esecuzione nell'oggetto TaskScheduler corrente.

(Ereditato da Task)
Start(TaskScheduler)

Avvia Task, pianificandone l'esecuzione nell'oggetto TaskScheduler specificato.

(Ereditato da Task)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)
Wait()

Attende il completamento dell'esecuzione di Task.

(Ereditato da Task)
Wait(CancellationToken)

Attende il completamento dell'esecuzione di Task. L'attesa termina se un token di annullamento viene annullato prima del completamento dell'attività.

(Ereditato da Task)
Wait(Int32)

Attende il completamento dell'esecuzione di Task entro un numero specificato di millisecondi.

(Ereditato da Task)
Wait(Int32, CancellationToken)

Attende il completamento dell'esecuzione di Task. L'attesa termina se si esaurisce l'intervallo di timeout o se un token di annullamento viene annullato prima del completamento dell'attività.

(Ereditato da Task)
Wait(TimeSpan)

Attende il completamento dell'esecuzione di Task entro un intervallo di tempo specificato.

(Ereditato da Task)
Wait(TimeSpan, CancellationToken)

Attende il completamento dell'esecuzione di Task.

(Ereditato da Task)
WaitAsync(CancellationToken)

Ottiene un Task<TResult> oggetto che verrà completato al termine o al Task<TResult> termine dell'annullamento specificato CancellationToken .

WaitAsync(CancellationToken)

Ottiene un Task oggetto che verrà completato al termine o al Task termine dell'annullamento specificato CancellationToken .

(Ereditato da Task)
WaitAsync(TimeSpan)

Ottiene un Task<TResult> oggetto che verrà completato al termine o alla Task<TResult> scadenza del timeout specificato.

WaitAsync(TimeSpan)

Ottiene un Task oggetto che verrà completato al termine o alla Task scadenza del timeout specificato.

(Ereditato da Task)
WaitAsync(TimeSpan, CancellationToken)

Ottiene un Task<TResult> oggetto che verrà completato al Task<TResult> termine, quando scade il timeout specificato o quando l'oggetto specificato CancellationToken ha richiesto l'annullamento.

WaitAsync(TimeSpan, CancellationToken)

Ottiene un Task oggetto che verrà completato al Task termine, quando scade il timeout specificato o quando l'oggetto specificato CancellationToken ha richiesto l'annullamento.

(Ereditato da Task)

Implementazioni dell'interfaccia esplicita

IAsyncResult.AsyncWaitHandle

Ottiene un oggetto WaitHandle che può essere usato per attendere il completamento dell'attività.

(Ereditato da Task)
IAsyncResult.CompletedSynchronously

Ottiene un valore che indica se l'operazione è stata completata in modo sincrono.

(Ereditato da Task)

Metodi di estensione

DispatcherOperationWait(Task)

Attende in modo indefinito il completamento di DispatcherOperation.

DispatcherOperationWait(Task, TimeSpan)

Attende il tempo specificato per il completamento della DispatcherOperation sottostante.

IsDispatcherOperationTask(Task)

Restituisce un valore che indica se Task è associato a un DispatcherOperation.

AsAsyncAction(Task)

Restituisce un'azione asincrona di Windows Runtime che rappresenta un'attività avviata.

AsAsyncOperation<TResult>(Task<TResult>)

Restituisce un'operazione asincrona di Windows Runtime che rappresenta un'attività avviata che restituisce un risultato.

Si applica a

Thread safety

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

Vedi anche