Task<TResult> Classe

Definizione

Spazio dei nomi:

System.Threading.Tasks

Assembly:

System.Runtime.dll

Source:

Future.cs

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à

Object

Task

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 oggetto esegue in genere in modo asincrono su un Task<TResult> thread del pool di thread anziché sincrono sul thread dell'applicazione principale, è possibile usare la Status proprietà, nonché le IsCanceledproprietà , IsCompletede IsFaulted per determinare lo stato di un'attività. Più comunemente, un'espressione lambda viene usata per specificare il lavoro che l'attività deve eseguire.

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 o Task.Run<TResult>(Func<TResult>, CancellationToken) staticoTask.Run<TResult>(Func<TResult>). 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 il 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 TaskFactory<TResult>.StartNew staticoTaskFactory.StartNew. La Task.Factory proprietà restituisce un TaskFactory oggetto e la Task<TResult>.Factory proprietà restituisce un TaskFactory<TResult> oggetto. Gli overload del metodo consentono di passare argomenti, definire le opzioni di creazione delle StartNew attività e specificare un utilità di pianificazione. Nell'esempio seguente viene usato il metodo per avviare un'attività TaskFactory<TResult>.StartNew(Func<TResult>) . È 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 altri esempi completi, vedere Programmazione asincrona basata su attività.

La Task<TResult> classe fornisce anche costruttori che inizializzano l'attività, ma che non pianificano l'esecuzione. Per motivi di prestazioni, i metodi e Task.Factory.StartNew sono i Task.Run 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 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 alle versioni di .NET Framework prima di .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, si usa la Task classe . A partire da C# 7.0, per un'attività più leggera che è un tipo di valore anziché un tipo di 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(ConfigureAwaitOptions)	Configura un elemento awaiter usato per attendere questo oggetto 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>.
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(TimeSpan)	Ottiene un Task<TResult> oggetto che verrà completato al termine o alla Task<TResult> scadenza del timeout specificato.
WaitAsync(TimeSpan, CancellationToken)	Ottiene un Task<TResult> oggetto che verrà completato al Task<TResult> termine dell'operazione, quando scade il timeout specificato o quando l'oggetto specificato CancellationToken ha richiesto l'annullamento.
WaitAsync(TimeSpan, TimeProvider)	Ottiene un Task<TResult> oggetto che verrà completato al termine o alla Task<TResult> scadenza del timeout specificato.
WaitAsync(TimeSpan, TimeProvider, CancellationToken)	Ottiene un Task<TResult> oggetto che verrà completato al Task<TResult> termine dell'operazione, quando scade il timeout specificato o quando l'oggetto specificato CancellationToken ha richiesto l'annullamento.

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

Thread safety

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

Vedi anche

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