Task<TResult> Classe

Definizione

Spazio dei nomi:: System.Threading.Tasks

Assembly:: mscorlib.dll, System.Threading.Tasks.dll

Assembly:: mscorlib.dll

Assembly:: System.Threading.Tasks.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

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>oggetto .

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 Task<TResult> oggetto viene in genere eseguito in modo asincrono su un thread del pool di thread anziché in modo sincrono sul thread dell'applicazione principale, è possibile usare la Status proprietà , nonché le IsCanceledproprietà , 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> 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 TaskFactory.StartNew staticoTaskFactory<TResult>.StartNew. La Task.Factory proprietà restituisce un TaskFactory oggetto e la Task<TResult>.Factory proprietà restituisce un TaskFactory<TResult> oggetto . Gli overload del StartNew metodo 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 pianificano 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 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 che puntano a .NET Framework 4.6, la cultura del thread che crea e invoca un compito diventa parte del contesto del thread. Ovvero, indipendentemente dalla cultura corrente del thread in cui viene eseguito il compito, la cultura corrente del compito è quella del thread chiamante. Per le app destinate alle versioni di .NET Framework precedenti a .NET Framework 4.6, la cultura dell'attività è la cultura del thread su cui viene eseguita l'attività. Per ulteriori informazioni, vedere la sezione "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 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

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

Proprietà

Nome	Descrizione
AsyncState	Ottiene l'oggetto di stato fornito quando Task è stato creato o null se non è stato specificato alcun oggetto. (Ereditato da Task)
CreationOptions	Ottiene l'oggetto TaskCreationOptions utilizzato per creare questa attività. (Ereditato da Task)
Exception	Ottiene l'oggetto AggregateException che ha causato la fine prematura dell'oggetto Task . Se l'oggetto 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 Task<TResult> istanze.
Id	Ottiene un ID per questa Task istanza. (Ereditato da Task)
IsCanceled	Ottiene un valore che indica se l'esecuzione Task dell'istanza è 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 l'oggetto è stato completato a causa di un'eccezione Task non gestita. (Ereditato da Task)
Result	Ottiene il valore del risultato dell'oggetto Task<TResult>.
Status	Ottiene l'oggetto TaskStatus di questa attività. (Ereditato da Task)

Metodi

Nome	Descrizione
ConfigureAwait(Boolean)	Configura un awaiter usato per attendere questo Task<TResult>oggetto .
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 della destinazione Task . 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, CancellationToken)	Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e un token di annullamento che viene eseguito in modo asincrono al termine della destinazione Task . (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 della destinazione Task . 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 della destinazione Task . La continuazione usa un'utilità di pianificazione specificata. (Ereditato da Task)
ContinueWith(Action<Task,Object>, Object)	Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e viene eseguita al termine della destinazione Task . (Ereditato da Task)
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita al termine della destinazione Task<TResult> .
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken)	Crea una continuazione che viene eseguita al termine della destinazione Task<TResult> .
ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions)	Crea una continuazione che viene eseguita al termine della destinazione Task<TResult> .
ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler)	Crea una continuazione che viene eseguita al termine della destinazione Task<TResult> .
ContinueWith(Action<Task<TResult>,Object>, Object)	Crea una continuazione che viene passata alle informazioni sullo stato e che viene eseguita al termine della destinazione Task<TResult> .
ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita in base alla condizione specificata in `continuationOptions`.
ContinueWith(Action<Task<TResult>>, CancellationToken)	Crea una continuazione annullabile che viene eseguita in modo asincrono al termine della destinazione Task<TResult> .
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 della destinazione Task<TResult> .
ContinueWith(Action<Task<TResult>>)	Crea una continuazione che viene eseguita in modo asincrono al termine dell'attività di destinazione.
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita quando l'attività di destinazione compete in base all'oggetto specificato TaskContinuationOptions. La continuazione riceve un token di annullamento e usa un'utilità di pianificazione specificata. (Ereditato da Task)
ContinueWith(Action<Task>, CancellationToken)	Crea una continuazione che riceve un token di annullamento ed esegue in modo asincrono al termine della destinazione Task . (Ereditato da Task)
ContinueWith(Action<Task>, TaskContinuationOptions)	Crea una continuazione che viene eseguita quando l'attività di destinazione viene completata in base all'oggetto specificato TaskContinuationOptions. (Ereditato da Task)
ContinueWith(Action<Task>, TaskScheduler)	Crea una continuazione che viene eseguita in modo asincrono al termine della destinazione Task . La continuazione usa un'utilità di pianificazione specificata. (Ereditato da Task)
ContinueWith(Action<Task>)	Crea una continuazione che viene eseguita in modo asincrono al termine della destinazione Task . (Ereditato da Task)
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita al termine della destinazione Task<TResult> .
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken)	Crea una continuazione che viene eseguita al termine della destinazione Task<TResult> .
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions)	Crea una continuazione che viene eseguita al termine della destinazione Task<TResult> .
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler)	Crea una continuazione che viene eseguita al termine della destinazione Task<TResult> .
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object)	Crea una continuazione che viene eseguita al termine della destinazione Task<TResult> .
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>, CancellationToken)	Crea una continuazione che viene eseguita in modo asincrono al termine della destinazione Task<TResult> .
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 della destinazione Task<TResult> .
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)	Crea una continuazione che viene eseguita in modo asincrono al termine della destinazione Task<TResult> .
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione eseguita in base alle opzioni di continuazione dell'attività specificate al termine della destinazione Task 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, CancellationToken)	Crea una continuazione che viene eseguita in modo asincrono al termine della destinazione Task 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, TaskContinuationOptions)	Crea una continuazione che viene eseguita in base alle opzioni di continuazione dell'attività specificate al termine della destinazione Task . 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 della destinazione Task . La continuazione riceve informazioni sullo stato fornite dal chiamante e usa un'utilità di pianificazione specificata. (Ereditato da Task)
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 termine della destinazione Task e restituisce un valore. (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>, CancellationToken)	Crea una continuazione che viene eseguita in modo asincrono al termine della destinazione Task e restituisce un valore. La continuazione riceve un token di annullamento. (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 che viene eseguita in modo asincrono al termine della destinazione Task e restituisce un valore. La continuazione usa un'utilità di pianificazione specificata. (Ereditato da Task)
ContinueWith<TResult>(Func<Task,TResult>)	Crea una continuazione che viene eseguita in modo asincrono al termine della destinazione Task<TResult> e restituisce un valore. (Ereditato da Task)
Dispose()	Rilascia tutte le risorse usate dall'istanza corrente della Task classe . (Ereditato da Task)
Dispose(Boolean)	Elimina , Taskrilasciando 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 awaiter utilizzato per attendere questo Task<TResult>oggetto .
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 in Task modo sincrono sull'oggetto corrente TaskScheduler. (Ereditato da Task)
RunSynchronously(TaskScheduler)	Esegue l'oggetto Task in modo sincrono sull'oggetto TaskScheduler fornito. (Ereditato da Task)
Start()	Avvia , Taskpianificandolo per l'esecuzione nell'oggetto corrente TaskScheduler. (Ereditato da Task)
Start(TaskScheduler)	Avvia , Taskpianificandolo per l'esecuzione nell'oggetto specificato TaskScheduler. (Ereditato da Task)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
Wait()	Attende il completamento dell'esecuzione Task . (Ereditato da Task)
Wait(CancellationToken)	Attende il completamento dell'esecuzione Task . L'attesa termina se un token di annullamento viene annullato prima del completamento dell'attività. (Ereditato da Task)
Wait(Int32, CancellationToken)	Attende il completamento dell'esecuzione 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(Int32)	Attende il completamento dell'esecuzione Task entro un numero specificato di millisecondi. (Ereditato da Task)
Wait(TimeSpan)	Attende il completamento dell'esecuzione Task entro un intervallo di tempo specificato. (Ereditato da Task)

Implementazioni dell'interfaccia esplicita

Nome	Descrizione
IAsyncResult.AsyncWaitHandle	Ottiene un WaitHandle oggetto 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

Nome	Descrizione
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.
DispatcherOperationWait(Task, TimeSpan)	Attende il tempo specificato per il completamento dell'oggetto sottostante DispatcherOperation .
DispatcherOperationWait(Task)	Attende il completamento indefinito dell'oggetto sottostante DispatcherOperation .
IsDispatcherOperationTask(Task)	Restituisce un valore che indica se l'oggetto Task è associato a un oggetto DispatcherOperation.

Si applica a

Thread safety

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

Vedi anche

Commenti e suggerimenti

Questa pagina è stata utile?