Task<TResult> Task<TResult> Task<TResult> Task<TResult> Class

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>Task<TResult>Task<TResult>Task<TResult>

Commenti

Il Task<TResult> classe rappresenta una singola operazione che restituisce un valore e che in genere esegue 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à introdotte inizialmente in .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> in genere viene eseguito l'oggetto in modo asincrono in un pool di thread anziché in modo sincrono sul thread principale dell'applicazione, è possibile usare il Status proprietà, nonché il IsCanceled, IsCompleted, e IsFaulted alle 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, un'espressione lambda viene utilizzata 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> è possibile creare istanze in diversi modi.Task<TResult> instances may be created in a variety of ways. L'approccio più comune, che è disponibile a partire il .NET Framework 4.5.NET Framework 4.5, è possibile chiamare il metodo statico Task.Run<TResult>(Func<TResult>) o Task.Run<TResult>(Func<TResult>, CancellationToken) (metodo).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 i parametri aggiuntivi.These methods provide a simple way to start a task by using default values and without acquiring additional parameters. L'esempio seguente usa il Task.Run<TResult>(Func<TResult>) 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

In alternativa e il modo più comune per avviare un'attività nel .NET Framework 4.NET Framework 4, è possibile chiamare il metodo statico TaskFactory.StartNew o TaskFactory<TResult>.StartNew (metodo).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. Il Task.Factory proprietà restituisce un TaskFactory oggetto e il 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 loro StartNew metodo consentono di passare argomenti, definire le opzioni di creazione di 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. L'esempio seguente usa il TaskFactory<TResult>.StartNew(Func<TResult>) metodo per avviare un'attività.The following example uses the TaskFactory<TResult>.StartNew(Func<TResult>) method to start a task. È funzionalmente equivalente al codice 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.

Il Task<TResult> classe fornisce anche i costruttori che inizializzano l'attività, ma che non si pianifica 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, la Task.Run e Task.Factory.StartNew metodi sono i meccanismi Preferiti per creare e pianificare le attività di calcolo, ma per gli scenari in cui la creazione di attività e pianificazione devono essere separati, potrebbero essere utilizzare i costruttori e i dell'attività Start metodo può quindi essere usato per pianificare l'attività per l'esecuzione 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.

Inizia con le app desktop che hanno come destinazione il .NET Framework 4.6.NET Framework 4.6, le impostazioni cultura del thread che crea e richiama un'attività entra a far 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. Indipendentemente dalle impostazioni cultura correnti del thread in cui l'attività viene eseguita, le impostazioni cultura correnti dell'attività sono la 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 a versioni di .NET Framework precedenti al .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 altre informazioni, vedere la sezione "Impostazioni cultura e operazioni asincrone basate su attività" nel CultureInfo argomento.For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic. Si noti che le app di Store seguono il Runtime di Windows nell'impostazione e il recupero delle 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, si utilizza il Task classe.For operations that do not return a value, you use the Task class. A partire da C# 7.0, per un'attività più leggera che è un tipo di valore anziché un tipo riferimento, usare il System.Threading.Tasks.ValueTask<TResult> 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) Task<TResult>(Func<Object,TResult>, Object) Task<TResult>(Func<Object,TResult>, Object) 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) Task<TResult>(Func<Object,TResult>, Object, CancellationToken) Task<TResult>(Func<Object,TResult>, Object, CancellationToken) 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) Task<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions) Task<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions) 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) Task<TResult>(Func<Object,TResult>, Object, TaskCreationOptions) Task<TResult>(Func<Object,TResult>, Object, TaskCreationOptions) 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>) Task<TResult>(Func<TResult>) Task<TResult>(Func<TResult>) 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) Task<TResult>(Func<TResult>, CancellationToken) Task<TResult>(Func<TResult>, CancellationToken) 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) Task<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions) Task<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions) 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) Task<TResult>(Func<TResult>, TaskCreationOptions) Task<TResult>(Func<TResult>, TaskCreationOptions) 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 AsyncState AsyncState 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.

(Inherited from Task)
CreationOptions CreationOptions CreationOptions CreationOptions

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

(Inherited from Task)
Exception Exception Exception 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.

(Inherited from Task)
Factory Factory Factory 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.

IAsyncResult.AsyncWaitHandle IAsyncResult.AsyncWaitHandle IAsyncResult.AsyncWaitHandle 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.

(Inherited from Task)
IAsyncResult.CompletedSynchronously IAsyncResult.CompletedSynchronously IAsyncResult.CompletedSynchronously IAsyncResult.CompletedSynchronously

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

(Inherited from Task)
Id Id Id Id

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

(Inherited from Task)
IsCanceled IsCanceled IsCanceled IsCanceled

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

(Inherited from Task)
IsCompleted IsCompleted IsCompleted IsCompleted

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

(Inherited from Task)
IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully Inherited from Task
IsFaulted IsFaulted IsFaulted 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.

(Inherited from Task)
Result Result Result Result

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

Status Status Status Status

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

(Inherited from Task)

Metodi

ConfigureAwait(Boolean) ConfigureAwait(Boolean) ConfigureAwait(Boolean) 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) ContinueWith(Action<Task,Object>, Object) ContinueWith(Action<Task,Object>, Object) 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.

(Inherited from Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken) ContinueWith(Action<Task,Object>, Object, CancellationToken) ContinueWith(Action<Task,Object>, Object, CancellationToken) 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.

(Inherited from Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) 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.

(Inherited from Task)
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions) ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions) ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions) 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.

(Inherited from Task)
ContinueWith(Action<Task,Object>, Object, TaskScheduler) ContinueWith(Action<Task,Object>, Object, TaskScheduler) ContinueWith(Action<Task,Object>, Object, TaskScheduler) 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.

(Inherited from Task)
ContinueWith(Action<Task<TResult>,Object>, Object) ContinueWith(Action<Task<TResult>,Object>, Object) ContinueWith(Action<Task<TResult>,Object>, Object) 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) ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken) ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken) 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) ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) 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) ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions) ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions) 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) ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler) ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler) 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>>) ContinueWith(Action<Task<TResult>>) ContinueWith(Action<Task<TResult>>) 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) ContinueWith(Action<Task<TResult>>, CancellationToken) ContinueWith(Action<Task<TResult>>, CancellationToken) 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) ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler) 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) ContinueWith(Action<Task<TResult>>, TaskContinuationOptions) ContinueWith(Action<Task<TResult>>, TaskContinuationOptions) 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) ContinueWith(Action<Task<TResult>>, TaskScheduler) ContinueWith(Action<Task<TResult>>, TaskScheduler) 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>) ContinueWith(Action<Task>) ContinueWith(Action<Task>) 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.

(Inherited from Task)
ContinueWith(Action<Task>, CancellationToken) ContinueWith(Action<Task>, CancellationToken) ContinueWith(Action<Task>, CancellationToken) 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.

(Inherited from Task)
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler) 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.

(Inherited from Task)
ContinueWith(Action<Task>, TaskContinuationOptions) ContinueWith(Action<Task>, TaskContinuationOptions) ContinueWith(Action<Task>, TaskContinuationOptions) 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.

(Inherited from Task)
ContinueWith(Action<Task>, TaskScheduler) ContinueWith(Action<Task>, TaskScheduler) ContinueWith(Action<Task>, TaskScheduler) 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.

(Inherited from Task)
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object) ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object) ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object) 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) ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken) ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken) 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) ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) 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) ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions) ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions) 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) ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler) ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler) 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>) ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>) ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>) 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) ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken) ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken) 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) ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken, TaskContinuationOptions, TaskScheduler) 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) ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions) ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions) 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) ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskScheduler) ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskScheduler) 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) ContinueWith<TResult>(Func<Task,Object,TResult>, Object) ContinueWith<TResult>(Func<Task,Object,TResult>, Object) 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.

(Inherited from Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken) 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.

(Inherited from Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) 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.

(Inherited from Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions) 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.

(Inherited from Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler) 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.

(Inherited from Task)
ContinueWith<TResult>(Func<Task,TResult>) ContinueWith<TResult>(Func<Task,TResult>) ContinueWith<TResult>(Func<Task,TResult>) 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.

(Inherited from Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken) 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.

(Inherited from Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler) 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.

(Inherited from Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions) 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.

(Inherited from Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler) ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler) ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler) 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.

(Inherited from Task)
Dispose() Dispose() Dispose() Dispose()

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

(Inherited from Task)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

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

(Inherited from Task)
Equals(Object) Equals(Object) Equals(Object) Equals(Object)

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

(Inherited from Object)
GetAwaiter() GetAwaiter() GetAwaiter() GetAwaiter()

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

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

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

(Inherited from Object)
GetType() GetType() GetType() GetType()

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

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

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

(Inherited from Object)
RunSynchronously() RunSynchronously() RunSynchronously() RunSynchronously()

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

(Inherited from Task)
RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler)

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

(Inherited from Task)
Start() Start() Start() Start()

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

(Inherited from Task)
Start(TaskScheduler) Start(TaskScheduler) Start(TaskScheduler) Start(TaskScheduler)

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

(Inherited from Task)
ToString() ToString() ToString() ToString()

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

(Inherited from Object)
Wait() Wait() Wait() Wait()

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

(Inherited from Task)
Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken) 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.

(Inherited from Task)
Wait(Int32) Wait(Int32) Wait(Int32) 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.

(Inherited from Task)
Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) 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.

(Inherited from Task)
Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan) 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.

(Inherited from Task)

Extension Methods

Unwrap(Task<Task>) Unwrap(Task<Task>) Unwrap(Task<Task>) Unwrap(Task<Task>)

Crea un oggetto proxy Task che rappresenta l'operazione asincrona di un oggetto TryExecuteTaskInline(Task, Boolean).Creates a proxy Task that represents the asynchronous operation of a TryExecuteTaskInline(Task, Boolean).

Unwrap<TResult>(Task<Task<TResult>>) Unwrap<TResult>(Task<Task<TResult>>) Unwrap<TResult>(Task<Task<TResult>>) Unwrap<TResult>(Task<Task<TResult>>)

Crea un oggetto Task proxy che rappresenta l'operazione asincrona di un oggetto Task<Task<T>> (C#) o Task (Of Task(Of T)) (Visual Basic).Creates a proxy Task that represents the asynchronous operation of a Task<Task<T>> (C#) or Task (Of Task(Of T)) (Visual Basic).

DispatcherOperationWait(Task) DispatcherOperationWait(Task) DispatcherOperationWait(Task) DispatcherOperationWait(Task)

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

DispatcherOperationWait(Task, TimeSpan) DispatcherOperationWait(Task, TimeSpan) DispatcherOperationWait(Task, TimeSpan) 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) IsDispatcherOperationTask(Task) IsDispatcherOperationTask(Task) 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) AsAsyncAction(Task) AsAsyncAction(Task) 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>) AsAsyncOperation<TResult>(Task<TResult>) AsAsyncOperation<TResult>(Task<TResult>) 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 del Task<TResult>, ad eccezione di Dispose(), sono thread-safe e possono essere utilizzati da più thread contemporaneamente.All members of Task<TResult>, except for Dispose(), are thread-safe and may be used from multiple threads concurrently.

Vedi anche