Task<TResult> Classe

Definizione

Rappresenta un'operazione asincrona in grado di restituire un valore.Represents an asynchronous operation that can return a value.

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>.The type of the result produced by this 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.The Task<TResult> class represents a single operation that returns a value and that usually executes asynchronously. Task<TResult>gli oggetti sono uno dei componenti centrali del modello asincrono basato su attività introdotto per la prima volta nel .NET Framework 4.Task<TResult> objects are one of the central components of the task-based asynchronous pattern first introduced in the .NET Framework 4. Poiché il lavoro eseguito da un Task<TResult> oggetto in genere viene eseguito in modo asincrono in un thread del pool di thread anziché in modo sincrono sul thread principale dell'applicazione Status , è possibile usare la proprietà IsCanceled, IsCompletednonché, e. IsFaulted proprietà, per determinare lo stato di un'attività.Because the work performed by a Task<TResult> object typically executes asynchronously on a thread pool thread rather than synchronously on the main application thread, you can use the Status property, as well as the IsCanceled, IsCompleted, and IsFaulted properties, to determine the state of a task. In genere, viene usata un'espressione lambda per specificare il lavoro che l'attività deve eseguire.Most commonly, a lambda expression is used to specify the work that the task is to perform.

Task<TResult>le istanze possono essere create in diversi modi.Task<TResult> instances may be created in a variety of ways. L'approccio più comune, disponibile a partire .NET Framework 4.5.NET Framework 4.5da, consiste nel chiamare il metodo statico Task.Run<TResult>(Func<TResult>) o Task.Run<TResult>(Func<TResult>, CancellationToken) .The most common approach, which is available starting with the .NET Framework 4.5.NET Framework 4.5, is to call the static Task.Run<TResult>(Func<TResult>) or Task.Run<TResult>(Func<TResult>, CancellationToken) method. Questi metodi forniscono un modo semplice per avviare un'attività usando i valori predefiniti e senza acquisire parametri aggiuntivi.These methods provide a simple way to start a task by using default values and without acquiring additional parameters. Nell'esempio seguente viene usato Task.Run<TResult>(Func<TResult>) il metodo per avviare un'attività che esegue il ciclo e quindi Visualizza il numero di iterazioni del ciclo:The following example uses the Task.Run<TResult>(Func<TResult>) method to start a task that loops and then displays the number of loop iterations:

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.NET Framework 4, consiste nel chiamare il metodo statico TaskFactory.StartNew o TaskFactory<TResult>.StartNew .An alternative, and the most common way to start a task in the .NET Framework 4.NET Framework 4, is to call the static TaskFactory.StartNew or TaskFactory<TResult>.StartNew method. La Task.Factory proprietà restituisce un TaskFactory oggetto e la Task<TResult>.Factory proprietà restituisce un TaskFactory<TResult> oggetto.The Task.Factory property returns a TaskFactory object, and the Task<TResult>.Factory property returns a TaskFactory<TResult> object. Gli overload del metodo consentono StartNew di passare gli argomenti, definire le opzioni di creazione delle attività e specificare un'utilità di pianificazione.Overloads of their StartNew method let you pass arguments, define task creation options, and specify a task scheduler. Nell'esempio seguente viene usato TaskFactory<TResult>.StartNew(Func<TResult>) il metodo per avviare un'attività.The following example uses the TaskFactory<TResult>.StartNew(Func<TResult>) method to start a task. Dal punto di vista funzionale equivale al codice riportato nell'esempio precedente.It is functionally equivalent to the code in the previous example.

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à.For more complete examples, see Task-based Asynchronous Programming.

La Task<TResult> classe fornisce inoltre costruttori che inizializzano l'attività ma che non la pianificano per l'esecuzione.The Task<TResult> class also provides constructors that initialize the task but that do not schedule it for execution. Per motivi di prestazioni, Task.Run i Task.Factory.StartNew metodi e sono i meccanismi preferiti per la creazione e la pianificazione di attività di calcolo, ma per gli scenari in cui è necessario separare la creazione e la pianificazione delle attività, è possibile utilizzare i costruttori e il Start il metodo dell'attività può quindi essere utilizzato per pianificare l'esecuzione dell'attività in un secondo momento.For performance reasons, the Task.Run and Task.Factory.StartNew methods are the preferred mechanisms for creating and scheduling computational tasks, but for scenarios where task creation and scheduling must be separated, the constructors may be used, and the task's Start method may then be used to schedule the task for execution at a later time.

A partire dalle applicazioni desktop destinate .NET Framework 4.6.NET Framework 4.6a, le impostazioni cultura del thread che crea e richiama un'attività diventano parte del contesto del thread.Starting with desktop apps that target the .NET Framework 4.6.NET Framework 4.6, the culture of the thread that creates and invokes a task becomes part of the thread's context. 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.That is, regardless of the current culture of the thread on which the task executes, the current culture of the task is the culture of the calling thread. Per le app destinate alle versioni del .NET Framework precedenti a .NET Framework 4.6.NET Framework 4.6, le impostazioni cultura dell'attività sono le impostazioni cultura del thread in cui viene eseguita l'attività.For apps that target versions of the .NET Framework prior to the .NET Framework 4.6.NET Framework 4.6, the culture of the task is the culture of the thread on which the task executes. Per ulteriori informazioni, vedere la sezione "impostazioni cultura e operazioni asincrone basate su attività" nell' CultureInfo argomento.For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic. Si noti che le app dello Store seguono il Windows Runtime nell'impostazione e ottenere le impostazioni cultura predefinite.Note that Store apps follow the Windows Runtime in setting and getting the default culture.

Per le operazioni che non restituiscono un valore, usare la Task classe.For operations that do not return a value, you use the Task class. A partire C# da 7,0, per un'attività più leggera che è un tipo di valore anziché un tipo riferimento, usare System.Threading.Tasks.ValueTask<TResult> la struttura.Starting with C# 7.0, for a more lightweight task that is a value type rather than a reference type, use the System.Threading.Tasks.ValueTask<TResult> structure.

Costruttori

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

Inizializza un nuovo oggetto Task<TResult> con la funzione e lo stato specificati.Initializes a new Task<TResult> with the specified function and state.

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

Inizializza un nuovo oggetto Task<TResult> con l'azione, lo stato e le opzioni specificati.Initializes a new Task<TResult> with the specified action, state, and options.

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

Inizializza un nuovo oggetto Task<TResult> con l'azione, lo stato e le opzioni specificati.Initializes a new Task<TResult> with the specified action, state, and options.

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

Inizializza un nuovo oggetto Task<TResult> con l'azione, lo stato e le opzioni specificati.Initializes a new Task<TResult> with the specified action, state, and options.

Task<TResult>(Func<TResult>)

Inizializza un nuovo oggetto Task<TResult> con la funzione specificata.Initializes a new Task<TResult> with the specified function.

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

Inizializza un nuovo oggetto Task<TResult> con la funzione specificata.Initializes a new Task<TResult> with the specified function.

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

Inizializza un nuovo oggetto Task<TResult> con la funzione e le opzioni di creazione specificate.Initializes a new Task<TResult> with the specified function and creation options.

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

Inizializza un nuovo oggetto Task<TResult> con la funzione e le opzioni di creazione specificate.Initializes a new Task<TResult> with the specified function and creation options.

Proprietà

AsyncState

Ottiene l'oggetto stato fornito quando è stato creato Task oppure null se non ne è stato fornito alcuno.Gets the state object supplied when the Task was created, or null if none was supplied.

(Ereditato da Task)
CreationOptions

Ottiene l'oggetto TaskCreationOptions usato per creare questa attività.Gets the TaskCreationOptions used to create this task.

(Ereditato da Task)
Exception

Ottiene l'oggetto AggregateException che ha causato l'interruzione anomala di Task.Gets the AggregateException that caused the Task to end prematurely. Se l'oggetto Task è stato completato correttamente o non ha ancora generato alcuna eccezione, verrà restituito null.If the Task completed successfully or has not yet thrown any exceptions, this will return null.

(Ereditato da Task)
Factory

Fornisce l'accesso ai metodi factory per la creazione e la configurazione delle istanze di Task<TResult>.Provides access to factory methods for creating and configuring Task<TResult> instances.

Id

Ottiene un ID per questa istanza di Task.Gets an ID for this Task instance.

(Ereditato da Task)
IsCanceled

Ottiene un valore che indica se l'esecuzione di questa istanza di Task è stata completata perché annullata.Gets whether this Task instance has completed execution due to being canceled.

(Ereditato da Task)
IsCompleted

Ottiene un valore che indica l'eventuale completamento dell'attività.Gets a value that indicates whether the task has completed.

(Ereditato da Task)
IsCompletedSuccessfully

Ottiene un valore che indica se l'esecuzione dell'attività è stata completata.Gets whether the task ran to completion.

(Ereditato da Task)
IsFaulted

Ottiene un valore che indica se l'oggetto Task è stato completato a causa di un'eccezione non gestita.Gets whether the Task completed due to an unhandled exception.

(Ereditato da Task)
Result

Ottiene il valore del risultato di Task<TResult>.Gets the result value of this Task<TResult>.

Status

Ottiene l'oggetto TaskStatus di questa attività.Gets the TaskStatus of this task.

(Ereditato da Task)

Metodi

ConfigureAwait(Boolean)

Configura un elemento awaiter usato per attendere questo oggetto Task<TResult>.Configures an awaiter used to await this Task<TResult>.

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.Creates a continuation that receives caller-supplied state information and executes when the target Task completes.

(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.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes asynchronously when the target Task completes.

(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.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes when the target Task completes. La continuazione viene eseguita in base a un set di condizioni specificate e usa un'utilità di pianificazione specificata.The continuation executes based on a set of specified conditions and uses a specified scheduler.

(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.Creates a continuation that receives caller-supplied state information and executes when the target Task completes. La continuazione viene eseguita in base a un set di condizioni specificate.The continuation executes based on a set of specified conditions.

(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.Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. La continuazione usa un'utilità di pianificazione specificata.The continuation uses a specified scheduler.

(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.Creates a continuation that is passed state information and that executes when the target Task<TResult> completes.

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

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.Creates a continuation that executes when the target Task<TResult> completes.

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

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.Creates a continuation that executes when the target Task<TResult> completes.

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

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.Creates a continuation that executes when the target Task<TResult> completes.

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

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.Creates a continuation that executes when the target Task<TResult> completes.

ContinueWith(Action<Task<TResult>>)

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'attività di destinazione.Creates a continuation that executes asynchronously when the target task completes.

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

Crea una continuazione annullabile che viene eseguita in modo asincrono al completamento dell'oggetto Task<TResult> di destinazione.Creates a cancelable continuation that executes asynchronously when the target Task<TResult> completes.

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

Crea una continuazione che viene eseguita in base alla condizione specificata in continuationOptions.Creates a continuation that executes according the condition specified in continuationOptions.

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

Crea una continuazione che viene eseguita in base alla condizione specificata in continuationOptions.Creates a continuation that executes according the condition specified in continuationOptions.

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

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task<TResult> di destinazione.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

ContinueWith(Action<Task>)

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione.Creates a continuation that executes asynchronously when the target Task completes.

(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.Creates a continuation that receives a cancellation token and executes asynchronously when the target Task completes.

(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.Creates a continuation that executes when the target task competes according to the specified TaskContinuationOptions. La continuazione riceve un token di annullamento e usa un'utilità di pianificazione specificata.The continuation receives a cancellation token and uses a specified scheduler.

(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.Creates a continuation that executes when the target task completes according to the specified TaskContinuationOptions.

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

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione.Creates a continuation that executes asynchronously when the target Task completes. La continuazione usa un'utilità di pianificazione specificata.The continuation uses a specified scheduler.

(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.Creates a continuation that executes when the target Task<TResult> completes.

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

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.Creates a continuation that executes when the target Task<TResult> completes.

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.Creates a continuation that executes when the target Task<TResult> completes.

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

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.Creates a continuation that executes when the target Task<TResult> completes.

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

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.Creates a continuation that executes when the target Task<TResult> completes.

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

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task<TResult> di destinazione.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

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

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task<TResult> di destinazione.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

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

Crea una continuazione che viene eseguita in base alla condizione specificata in continuationOptions.Creates a continuation that executes according the condition specified in continuationOptions.

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

Crea una continuazione che viene eseguita in base alla condizione specificata in continuationOptions.Creates a continuation that executes according the condition specified 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.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

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.Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes and returns a value.

(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.Creates a continuation that executes asynchronously when the target Task completes and returns a value. La continuazione riceve informazioni sullo stato fornite dal chiamante e un token di annullamento.The continuation receives caller-supplied state information and a cancellation token.

(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.Creates a continuation that executes based on the specified task continuation options when the target Task completes and returns a value. La continuazione riceve informazioni sullo stato fornite dal chiamante e un token di annullamento, quindi usa l'utilità di pianificazione specificata.The continuation receives caller-supplied state information and a cancellation token and uses the specified scheduler.

(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.Creates a continuation that executes based on the specified task continuation options when the target Task completes. La continuazione riceve informazioni sullo stato fornite dal chiamante.The continuation receives caller-supplied state information.

(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.Creates a continuation that executes asynchronously when the target Task completes. La continuazione riceve informazioni sullo stato fornite dal chiamante e usa un'utilità di pianificazione specificata.The continuation receives caller-supplied state information and uses a specified scheduler.

(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.Creates a continuation that executes asynchronously when the target Task<TResult> completes and returns a value.

(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.Creates a continuation that executes asynchronously when the target Task completes and returns a value. La continuazione riceve un token di annullamento.The continuation receives a cancellation token.

(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.Creates a continuation that executes according to the specified continuation options and returns a value. La continuazione riceve un token di annullamento e usa un'utilità di pianificazione specificata.The continuation is passed a cancellation token and uses a specified scheduler.

(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.Creates a continuation that executes according to the specified continuation options and returns a value.

(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.Creates a continuation that executes asynchronously when the target Task completes and returns a value. La continuazione usa un'utilità di pianificazione specificata.The continuation uses a specified scheduler.

(Ereditato da Task)
Dispose()

Rilascia tutte le risorse usate dall'istanza corrente della classe Task.Releases all resources used by the current instance of the Task class.

(Ereditato da Task)
Dispose(Boolean)

Elimina Task, rilasciandone tutte le risorse non gestite.Disposes the Task, releasing all of its unmanaged resources.

(Ereditato da Task)
Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetAwaiter()

Ottiene un awaiter utilizzato per attendere questo Task<TResult>.Gets an awaiter used to await this Task<TResult>.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
RunSynchronously()

Esegue Task in modo sincrono nell'oggetto TaskScheduler corrente.Runs the Task synchronously on the current TaskScheduler.

(Ereditato da Task)
RunSynchronously(TaskScheduler)

Esegue Task in modo sincrono nell'oggetto TaskScheduler fornito.Runs the Task synchronously on the TaskScheduler provided.

(Ereditato da Task)
Start()

Avvia Task, pianificandone l'esecuzione nell'oggetto TaskScheduler corrente.Starts the Task, scheduling it for execution to the current TaskScheduler.

(Ereditato da Task)
Start(TaskScheduler)

Avvia Task, pianificandone l'esecuzione nell'oggetto TaskScheduler specificato.Starts the Task, scheduling it for execution to the specified TaskScheduler.

(Ereditato da Task)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)
Wait()

Attende il completamento dell'esecuzione di Task.Waits for the Task to complete execution.

(Ereditato da Task)
Wait(CancellationToken)

Attende il completamento dell'esecuzione di Task.Waits for the Task to complete execution. L'attesa termina se un token di annullamento viene annullato prima del completamento dell'attività.The wait terminates if a cancellation token is canceled before the task completes.

(Ereditato da Task)
Wait(Int32)

Attende il completamento dell'esecuzione di Task entro un numero specificato di millisecondi.Waits for the Task to complete execution within a specified number of milliseconds.

(Ereditato da Task)
Wait(Int32, CancellationToken)

Attende il completamento dell'esecuzione di Task.Waits for the Task to complete execution. L'attesa termina se si esaurisce l'intervallo di timeout o se un token di annullamento viene annullato prima del completamento dell'attività.The wait terminates if a timeout interval elapses or a cancellation token is canceled before the task completes.

(Ereditato da Task)
Wait(TimeSpan)

Attende il completamento dell'esecuzione di Task entro un intervallo di tempo specificato.Waits for the Task to complete execution within a specified time interval.

(Ereditato da Task)

Implementazioni dell'interfaccia esplicita

IAsyncResult.AsyncWaitHandle

Ottiene un oggetto WaitHandle che può essere usato per attendere il completamento dell'attività.Gets a WaitHandle that can be used to wait for the task to complete.

(Ereditato da Task)
IAsyncResult.CompletedSynchronously

Ottiene un valore che indica se l'operazione è stata completata in modo sincrono.Gets an indication of whether the operation completed synchronously.

(Ereditato da Task)

Metodi di estensione

DispatcherOperationWait(Task)

Attende in modo indefinito il completamento di DispatcherOperation.Waits indefinitely for the underlying DispatcherOperation to complete.

DispatcherOperationWait(Task, TimeSpan)

Attende il tempo specificato per il completamento della DispatcherOperation sottostante.Waits for the specified amount of time for the underlying DispatcherOperation to complete.

IsDispatcherOperationTask(Task)

Restituisce un valore che indica se Task è associato a un DispatcherOperation.Returns a value that indicates whether this Task is associated with a DispatcherOperation.

AsAsyncAction(Task)

Restituisce un'azione asincrona di Windows Runtime che rappresenta un'attività avviata.Returns a Windows Runtime asynchronous action that represents a started task.

AsAsyncOperation<TResult>(Task<TResult>)

Restituisce un'operazione asincrona di Windows Runtime che rappresenta un'attività avviata che restituisce un risultato.Returns a Windows Runtime asynchronous operation that represents a started task that returns a result.

Si applica a

Thread safety

Tutti i membri Task<TResult>di, ad Dispose()eccezione di, sono thread-safe e possono essere usati contemporaneamente da più thread.All members of Task<TResult>, except for Dispose(), are thread-safe and may be used from multiple threads concurrently.

Vedi anche