Task Task Task Task Class

Definizione

Rappresenta un'operazione asincrona.Represents an asynchronous operation.

public ref class Task : IAsyncResult, IDisposable
public class Task : IAsyncResult, IDisposable
type Task = class
    interface IAsyncResult
    interface IDisposable
Public Class Task
Implements IAsyncResult, IDisposable
Ereditarietà
TaskTaskTaskTask
Derivato
Implementazioni

Commenti

La Task classe rappresenta una singola operazione che non restituisce un valore e che in genere viene eseguita in modo asincrono.The Task class represents a single operation that does not return a value and that usually executes asynchronously. Taskgli oggetti sono uno dei componenti centrali del modello asincrono basato su attività introdotto per la prima volta nel .NET Framework 4.Task 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 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 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.

Per le operazioni che restituiscono valori, usare Task<TResult> la classe.For operations that return values, you use the Task<TResult> class.

Contenuto della sezione:In this section:

Esempi di creazione di istanze di attività Task instantiation examples
Creazione ed esecuzione di un'attività Creating and executing a task
Separazione della creazione e dell'esecuzione delle attività Separating task creation and execution
In attesa del completamento di una o più attività Waiting for one or more tasks to complete
Attività e impostazioni cultura Tasks and culture
Per gli sviluppatori del debuggerFor debugger developers

Creazione di istanze attivitàTask instantiation

Nell'esempio seguente vengono create ed eseguite quattro attività.The following example creates and executes four tasks. Tre attività eseguono un Action<T> delegato denominato action, che accetta un argomento di tipo Object.Three tasks execute an Action<T> delegate named action, which accepts an argument of type Object. Una quarta attività esegue un'espressione lambda (un Action delegato) definita inline nella chiamata al metodo di creazione dell'attività.A fourth task executes a lambda expression (an Action delegate) that is defined inline in the call to the task creation method. Viene creata un'istanza di ogni attività ed eseguita in modo diverso:Each task is instantiated and run in a different way:

  • Viene t1 creata un'istanza dell'attività chiamando un costruttore della classe di attività, ma viene avviata chiamando il relativo t2 metodo solo dopo l' Start() avvio dell'attività.Task t1 is instantiated by calling a Task class constructor, but is started by calling its Start() method only after task t2 has started.

  • Viene t2 creata un'istanza dell'attività che viene avviata in una singola chiamata TaskFactory.StartNew(Action<Object>, Object) al metodo chiamando il metodo.Task t2 is instantiated and started in a single method call by calling the TaskFactory.StartNew(Action<Object>, Object) method.

  • Viene t3 creata un'istanza dell'attività che viene avviata in una singola chiamata Run(Action) al metodo chiamando il metodo.Task t3 is instantiated and started in a single method call by calling the Run(Action) method.

  • L' t4 attività viene eseguita in modo sincrono sul thread principale chiamando RunSynchronously() il metodo.Task t4 is executed synchronously on the main thread by calling the RunSynchronously() method.

Poiché l' t4 attività viene eseguita in modo sincrono, viene eseguita nel thread dell'applicazione principale.Because task t4 executes synchronously, it executes on the main application thread. Le attività rimanenti vengono eseguite in modo asincrono in uno o più thread del pool di thread.The remaining tasks execute asynchronously typically on one or more thread pool threads.

using System;
using System.Threading;
using System.Threading.Tasks;

class Example
{
    static void Main()
    {
        Action<object> action = (object obj) =>
                                {
                                   Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                   Task.CurrentId, obj,
                                   Thread.CurrentThread.ManagedThreadId);
                                };

        // Create a task but do not start it.
        Task t1 = new Task(action, "alpha");

        // Construct a started task
        Task t2 = Task.Factory.StartNew(action, "beta");
        // Block the main thread to demonstrate that t2 is executing
        t2.Wait();

        // Launch t1 
        t1.Start();
        Console.WriteLine("t1 has been launched. (Main Thread={0})",
                          Thread.CurrentThread.ManagedThreadId);
        // Wait for the task to finish.
        t1.Wait();

        // Construct a started task using Task.Run.
        String taskData = "delta";
        Task t3 = Task.Run( () => {Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                                     Task.CurrentId, taskData,
                                                      Thread.CurrentThread.ManagedThreadId);
                                   });
        // Wait for the task to finish.
        t3.Wait();

        // Construct an unstarted task
        Task t4 = new Task(action, "gamma");
        // Run it synchronously
        t4.RunSynchronously();
        // Although the task was run synchronously, it is a good practice
        // to wait for it in the event exceptions were thrown by the task.
        t4.Wait();
    }
}
// The example displays output like the following:
//       Task=1, obj=beta, Thread=3
//       t1 has been launched. (Main Thread=1)
//       Task=2, obj=alpha, Thread=4
//       Task=3, obj=delta, Thread=3
//       Task=4, obj=gamma, Thread=1
Imports System.Threading
Imports System.Threading.Tasks

Module Example
    Public Sub Main()
        Dim action As Action(Of Object) = 
              Sub(obj As Object)
                 Console.WriteLine("Task={0}, obj={1}, Thread={2}", 
                 Task.CurrentId, obj,
                 Thread.CurrentThread.ManagedThreadId)
              End Sub

        ' Construct an unstarted task
        Dim t1 As New Task(action, "alpha")

        ' Construct a started task
        Dim t2 As Task = Task.Factory.StartNew(action, "beta")
        ' Block the main thread to demonstrate that t2 is executing
        t2.Wait()

        ' Launch t1 
        t1.Start()
        Console.WriteLine("t1 has been launched. (Main Thread={0})",
                          Thread.CurrentThread.ManagedThreadId)
        ' Wait for the task to finish.
        t1.Wait()

        ' Construct a started task using Task.Run.
        Dim taskData As String = "delta"
        Dim t3 As Task = Task.Run(Sub()
                                     Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                     Task.CurrentId, taskData,
                                     Thread.CurrentThread.ManagedThreadId)
                                  End Sub)
        ' Wait for the task to finish.
        t3.Wait()
        
        ' Construct an unstarted task
        Dim t4 As New Task(action, "gamma")
        ' Run it synchronously
        t4.RunSynchronously()
        ' Although the task was run synchronously, it is a good practice
        ' to wait for it in the event exceptions were thrown by the task.
        t4.Wait()
    End Sub
End Module
' The example displays output like the following:
'       Task=1, obj=beta, Thread=3
'       t1 has been launched. (Main Thread=1)
'       Task=2, obj=alpha, Thread=3
'       Task=3, obj=delta, Thread=3
'       Task=4, obj=gamma, Thread=1

Creazione ed esecuzione di un'attivitàCreating and executing a task

Taskle istanze possono essere create in diversi modi.Task 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. RunThe most common approach, which is available starting with the .NET Framework 4.5.NET Framework 4.5, is to call the static Run method. Il Run metodo fornisce un modo semplice per avviare un'attività usando i valori predefiniti e senza richiedere parametri aggiuntivi.The Run method provides a simple way to start a task using default values and without requiring additional parameters. Nell'esempio seguente viene usato Run(Action) il metodo per avviare un'attività che esegue il ciclo e quindi Visualizza il numero di iterazioni del ciclo:The following example uses the Run(Action) 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 async Task Main()
   {
      await Task.Run( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Run(Sub()
                                  ' Just loop.
                                  Dim ctr As Integer = 0
                                  For ctr = 0 to 1000000
                                  Next
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr)
                               End Sub)
      t.Wait()
   End Sub
End Module
' The example displays the following output:
'       Finished 1000001 loop iterations

Un'alternativa e il metodo più comune per avviare un'attività in .NET Framework 4.NET Framework 4sono il metodo statico. TaskFactory.StartNewAn alternative, and the most common method to start a task in .NET Framework 4.NET Framework 4, is the static TaskFactory.StartNew method. La Task.Factory proprietà restituisce un TaskFactory oggetto.The Task.Factory property returns a TaskFactory object. Gli TaskFactory.StartNew overload del metodo consentono di specificare i parametri da passare alle opzioni di creazione dell'attività e a un'utilità di pianificazione.Overloads of the TaskFactory.StartNew method let you specify parameters to pass to the task creation options and a task scheduler. Nell'esempio seguente viene usato TaskFactory.StartNew il metodo per avviare un'attività.The following example uses the TaskFactory.StartNew 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()
   {
      Task t = Task.Factory.StartNew( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
      t.Wait();
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Factory.StartNew(Sub()
                                  ' Just loop.
                                  Dim ctr As Integer = 0
                                  For ctr = 0 to 1000000
                                  Next
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr)
                               End Sub)
      t.Wait()
   End Sub
End Module
' The example displays the following output:
'       Finished 1000001 loop iterations

Per esempi più completi, vedere programmazione asincrona basata su attività.For more complete examples, see Task-based Asynchronous Programming.

Separazione della creazione e dell'esecuzione delle attivitàSeparating task creation and execution

La Task classe fornisce inoltre costruttori che inizializzano l'attività ma che non la pianificano per l'esecuzione.The Task class also provides constructors that initialize the task but that do not schedule it for execution. Per motivi di prestazioni, Task.Run il TaskFactory.StartNew metodo o rappresenta il meccanismo preferito per la creazione e la pianificazione di attività di calcolo, ma per gli scenari in cui è necessario separare la creazione e la pianificazione, è possibile utilizzare i costruttori e quindi chiamare il metodo Task.Start metodo per pianificare l'esecuzione dell'attività in un secondo momento.For performance reasons, the Task.Run or TaskFactory.StartNew method is the preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation and scheduling must be separated, you can use the constructors and then call the Task.Start method to schedule the task for execution at a later time.

In attesa del completamento di una o più attivitàWaiting for one or more tasks to complete

Poiché le attività vengono in genere eseguite in modo asincrono in un thread del pool di thread, il thread che crea e avvia l'attività continua l'esecuzione non appena è stata creata un'istanza dell'attività.Because tasks typically run asynchronously on a thread pool thread, the thread that creates and starts the task continues execution as soon as the task has been instantiated. In alcuni casi, quando il thread chiamante è il thread principale dell'applicazione, l'applicazione può terminare prima che l'attività inizi effettivamente l'esecuzione.In some cases, when the calling thread is the main application thread, the app may terminate before any the task actually begins execution. In altre, la logica dell'applicazione può richiedere che il thread chiamante continui l'esecuzione solo quando una o più attività hanno completato l'esecuzione.In others, your application's logic may require that the calling thread continue execution only when one or more tasks has completed execution. È possibile sincronizzare l'esecuzione del thread chiamante e le attività asincrone avviate chiamando un Wait metodo per attendere il completamento di una o più attività.You can synchronize the execution of the calling thread and the asynchronous tasks it launches by calling a Wait method to wait for one or more tasks to complete.

Per attendere il completamento di una singola attività, è possibile chiamare il Task.Wait relativo metodo.To wait for a single task to complete, you can call its Task.Wait method. Una chiamata al Wait metodo blocca il thread chiamante finché l'esecuzione dell'istanza della classe singola non è stata completata.A call to the Wait method blocks the calling thread until the single class instance has completed execution.

Nell'esempio seguente viene chiamato il Wait() metodo senza parametri per attendere in modo incondizionato fino al completamento di un'attività.The following example calls the parameterless Wait() method to wait unconditionally until a task completes. L'attività simula il lavoro chiamando il metodo Thread.Sleep per la sospensione per due secondi.The task simulates work by calling the Thread.Sleep method to sleep for two seconds.

using System;   
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static Random rand = new Random();

    static void Main()
    {
        // Wait on a single task with no timeout specified.
        Task taskA = Task.Run( () => Thread.Sleep(2000));
        Console.WriteLine("taskA Status: {0}", taskA.Status);
        try {
          taskA.Wait();
          Console.WriteLine("taskA Status: {0}", taskA.Status);
       } 
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }   
    }    
}
// The example displays output like the following:
//     taskA Status: WaitingToRun
//     taskA Status: RanToCompletion
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait on a single task with no timeout specified.
      Dim taskA = Task.Run( Sub() Thread.Sleep(2000))
      Console.WriteLine("taskA Status: {0}", taskA.Status)
      Try
        taskA.Wait()
        Console.WriteLine("taskA Status: {0}", taskA.Status)
      Catch e As AggregateException
         Console.WriteLine("Exception in taskA.")
      End Try
   End Sub
End Module
' The example displays output like the following:
'     taskA Status: WaitingToRun
'     taskA Status: RanToCompletion

È anche possibile attendere in modo condizionale il completamento di un'attività.You can also conditionally wait for a task to complete. I Wait(Int32) metodi Wait(TimeSpan) e bloccano il thread chiamante finché l'attività non viene completata o scade un intervallo di timeout, a seconda del valore che viene raggiunto per primo.The Wait(Int32) and Wait(TimeSpan) methods block the calling thread until the task finishes or a timeout interval elapses, whichever comes first. Poiché nell'esempio seguente viene avviata un'attività che dorme per due secondi ma definisce un valore di timeout di un secondo, il thread chiamante si blocca fino alla scadenza del timeout e prima del completamento dell'esecuzione dell'attività.Since the following example launches a task that sleeps for two seconds but defines a one-second timeout value, the calling thread blocks until the timeout expires and before the task has completed execution.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Wait on a single task with a timeout specified.
      Task taskA = Task.Run( () => Thread.Sleep(2000));
      try {
        taskA.Wait(1000);       // Wait for 1 second.
        bool completed = taskA.IsCompleted;
        Console.WriteLine("Task A completed: {0}, Status: {1}",
                         completed, taskA.Status);
        if (! completed)
           Console.WriteLine("Timed out before task A completed.");                 
       }
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }   
   }
}
// The example displays output like the following:
//     Task A completed: False, Status: Running
//     Timed out before task A completed.
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait on a single task with a timeout specified.
      Dim taskA As Task = Task.Run( Sub() Thread.Sleep(2000))
      Try
         taskA.Wait(1000)        ' Wait for 1 second.
         Dim completed As Boolean = taskA.IsCompleted
         Console.WriteLine("Task.Completed: {0}, Status: {1}",
                           completed, taskA.Status)
         If Not completed Then 
            Console.WriteLine("Timed out before task A completed.")
         End If                     
      Catch e As AggregateException
         Console.WriteLine("Exception in taskA.")
      End Try
   End Sub
End Module
' The example displays the following output:
'     Task A completed: False, Status: Running
'     Timed out before task A completed.

È anche possibile fornire un token di annullamento chiamando i Wait(CancellationToken) metodi Wait(Int32, CancellationToken) e.You can also supply a cancellation token by calling the Wait(CancellationToken) and Wait(Int32, CancellationToken) methods. IsCancellationRequested Se la proprietà del token è true o diventa true mentre è Wait in esecuzione il metodo, il metodo genera un' OperationCanceledExceptioneccezione.If the token's IsCancellationRequested property is true or becomes true while the Wait method is executing, the method throws an OperationCanceledException.

In alcuni casi, potrebbe essere necessario attendere il completamento della prima di una serie di attività in esecuzione, ma non è importante sapere quale attività è.In some cases, you may want to wait for the first of a series of executing tasks to complete, but don't care which task it is. A questo scopo, è possibile chiamare uno degli overload del Task.WaitAny metodo.For this purpose, you can call one of the overloads of the Task.WaitAny method. Nell'esempio seguente vengono create tre attività, ognuna delle quali dorme per un intervallo determinato da un generatore di numeri casuali.The following example creates three tasks, each of which sleeps for an interval determine by a random number generator. Il WaitAny(Task[]) metodo attende il completamento della prima attività.The WaitAny(Task[]) method waits for the first task to complete. Nell'esempio vengono quindi visualizzate informazioni sullo stato di tutte e tre le attività.The example then displays information about the status of all three tasks.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var tasks = new Task[3];
      var rnd = new Random();
      for (int ctr = 0; ctr <= 2; ctr++)
         tasks[ctr] = Task.Run( () => Thread.Sleep(rnd.Next(500, 3000)));

      try {
         int index = Task.WaitAny(tasks);
         Console.WriteLine("Task #{0} completed first.\n", tasks[index].Id);
         Console.WriteLine("Status of all tasks:");
         foreach (var t in tasks)
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
      }
      catch (AggregateException) {
         Console.WriteLine("An exception occurred.");
      }
   }
}
// The example displays output like the following:
//     Task #1 completed first.
//     
//     Status of all tasks:
//        Task #3: Running
//        Task #1: RanToCompletion
//        Task #4: Running
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks(2) As Task
      Dim rnd As New Random()
      For ctr As Integer = 0 To 2
         tasks(ctr) = Task.Run( Sub()  Thread.Sleep(rnd.Next(500, 3000)))
      Next
      
      Try 
         Dim index As Integer= Task.WaitAny(tasks)
         Console.WriteLine("Task #{0} completed first.", tasks(index).Id)
         Console.WriteLine()
         Console.WriteLine("Status of all tasks:")
         For Each t in tasks
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
         Next   
      Catch e As AggregateException
         Console.WriteLine("An exception occurred.")
      End Try
   End Sub
End Module
' The example displays output like the following:
'     Task #1 completed first.
'     
'     Status of all tasks:
'        Task #3: Running
'        Task #1: RanToCompletion
'        Task #4: Running

È anche possibile attendere il completamento di tutte le serie di attività chiamando il WaitAll metodo.You can also wait for all of a series of tasks to complete by calling the WaitAll method. L'esempio seguente crea dieci attività, attende il completamento di tutti i dieci, quindi ne Visualizza lo stato.The following example creates ten tasks, waits for all ten to complete, and then displays their status.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Wait for all tasks to complete.
      Task[] tasks = new Task[10];
      for (int i = 0; i < 10; i++)
      {
          tasks[i] = Task.Run(() => Thread.Sleep(2000));
      }
      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
         Console.WriteLine("One or more exceptions occurred: ");
         foreach (var ex in ae.Flatten().InnerExceptions)
            Console.WriteLine("   {0}", ex.Message);
      }   

      Console.WriteLine("Status of completed tasks:");
      foreach (var t in tasks)
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
   }
}
// The example displays the following output:
//     Status of completed tasks:
//        Task #2: RanToCompletion
//        Task #1: RanToCompletion
//        Task #3: RanToCompletion
//        Task #4: RanToCompletion
//        Task #6: RanToCompletion
//        Task #5: RanToCompletion
//        Task #7: RanToCompletion
//        Task #8: RanToCompletion
//        Task #9: RanToCompletion
//        Task #10: RanToCompletion
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait for all tasks to complete.
      Dim tasks(9) As Task
      For i As Integer = 0 To 9
          tasks(i) = Task.Run( Sub() Thread.Sleep(2000) )
      Next
      Try 
         Task.WaitAll(tasks)
      Catch ae As AggregateException
         Console.WriteLine("One or more exceptions occurred: ")
         For Each ex In ae.Flatten().InnerExceptions
            Console.WriteLine("   {0}", ex.Message)
         Next
      End Try   

      Console.WriteLine("Status of completed tasks:")
      For Each t in tasks
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
      Next   
   End Sub
End Module
' The example displays the following output:
'     Status of completed tasks:
'        Task #2: RanToCompletion
'        Task #1: RanToCompletion
'        Task #3: RanToCompletion
'        Task #4: RanToCompletion
'        Task #6: RanToCompletion
'        Task #5: RanToCompletion
'        Task #7: RanToCompletion
'        Task #8: RanToCompletion
'        Task #9: RanToCompletion
'        Task #10: RanToCompletion

Si noti che quando si attende il completamento di una o più attività, tutte le eccezioni generate nelle attività in esecuzione vengono propagate nel thread Wait che chiama il metodo, come illustrato nell'esempio seguente.Note that when you wait for one or more tasks to complete, any exceptions thrown in the running tasks are propagated on the thread that calls the Wait method, as the following example shows. Vengono avviate 12 attività, tre delle quali vengono completate normalmente e tre delle quali generano un'eccezione.It launches 12 tasks, three of which complete normally and three of which throw an exception. Delle sei attività rimanenti, tre vengono annullate prima dell'avvio e tre vengono annullate durante l'esecuzione.Of the remaining six tasks, three are cancelled before they start, and three are cancelled while they are executing. Le eccezioni vengono generate WaitAll nella chiamata al metodo e vengono gestite try da un / catch blocco.Exceptions are thrown in the WaitAll method call and are handled by a try/catch block.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Create a cancellation token and cancel it.
      var source1 = new CancellationTokenSource();
      var token1 = source1.Token;
      source1.Cancel();
      // Create a cancellation token for later cancellation.
      var source2 = new CancellationTokenSource();
      var token2 = source2.Token;
       
      // Create a series of tasks that will complete, be cancelled, 
      // timeout, or throw an exception.
      Task[] tasks = new Task[12];
      for (int i = 0; i < 12; i++)
      {
          switch (i % 4) 
          {
             // Task should run to completion.
             case 0:
                tasks[i] = Task.Run(() => Thread.Sleep(2000));
                break;
             // Task should be set to canceled state.
             case 1:   
                tasks[i] = Task.Run( () => Thread.Sleep(2000),
                         token1);
                break;         
             case 2:
                // Task should throw an exception.
                tasks[i] = Task.Run( () => { throw new NotSupportedException(); } );
                break;
             case 3:
                // Task should examine cancellation token.
                tasks[i] = Task.Run( () => { Thread.Sleep(2000); 
                                             if (token2.IsCancellationRequested)
                                                token2.ThrowIfCancellationRequested();
                                             Thread.Sleep(500); }, token2);   
                break;
          }
      }
      Thread.Sleep(250);
      source2.Cancel();
       
      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
          Console.WriteLine("One or more exceptions occurred:");
          foreach (var ex in ae.InnerExceptions)
             Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message);
       }   

      Console.WriteLine("\nStatus of tasks:");
      foreach (var t in tasks) {
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
         if (t.Exception != null) {
            foreach (var ex in t.Exception.InnerExceptions)
               Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                 ex.Message);
         }
      }
   }
}
// The example displays output like the following:
//   One or more exceptions occurred:
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//   
//   Status of tasks:
//      Task #13: RanToCompletion
//      Task #1: Canceled
//      Task #3: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #8: Canceled
//      Task #14: RanToCompletion
//      Task #4: Canceled
//      Task #6: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #7: Canceled
//      Task #15: RanToCompletion
//      Task #9: Canceled
//      Task #11: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #12: Canceled
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Create a cancellation token and cancel it.
      Dim source1 As New CancellationTokenSource()
      Dim token1 As CancellationToken = source1.Token
      source1.Cancel()
      ' Create a cancellation token for later cancellation.
      Dim source2 As New CancellationTokenSource()
      Dim token2 As CancellationToken = source2.Token
       
      ' Create a series of tasks that will complete, be cancelled, 
      ' timeout, or throw an exception.
      Dim tasks(11) As Task
      For i As Integer = 0 To 11
          Select Case i Mod 4 
             ' Task should run to completion.
             Case 0
                tasks(i) = Task.Run( Sub() Thread.Sleep(2000))
             ' Task should be set to canceled state.
             Case 1   
                tasks(i) = Task.Run( Sub() Thread.Sleep(2000), token1)
             Case 2
                ' Task should throw an exception.
                tasks(i) = Task.Run( Sub() 
                                        Throw New NotSupportedException() 
                                     End Sub)
             Case 3
                ' Task should examine cancellation token.
                tasks(i) = Task.Run( Sub() 
                                        Thread.Sleep(2000) 
                                        If token2.IsCancellationRequested
                                           token2.ThrowIfCancellationRequested()
                                        End If
                                        Thread.Sleep(500) 
                                     End Sub, token2)   
          End Select
      Next
      Thread.Sleep(250)
      source2.Cancel()
       
      Try 
         Task.WaitAll(tasks)
      Catch ae As AggregateException
         Console.WriteLine("One or more exceptions occurred:")
         For Each ex in ae.InnerExceptions
             Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message)
         Next
      End Try   
      Console.WriteLine()
      
      Console.WriteLine("Status of tasks:")
      For Each t in tasks
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
         If t.Exception IsNot Nothing Then
            For Each ex in t.Exception.InnerExceptions
               Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                 ex.Message)
            Next
         End If
      Next
   End Sub
End Module
' The example displays output like the following:
'   One or more exceptions occurred:
'      TaskCanceledException: A task was canceled.
'      NotSupportedException: Specified method is not supported.
'      TaskCanceledException: A task was canceled.
'      TaskCanceledException: A task was canceled.
'      NotSupportedException: Specified method is not supported.
'      TaskCanceledException: A task was canceled.
'      TaskCanceledException: A task was canceled.
'      NotSupportedException: Specified method is not supported.
'      TaskCanceledException: A task was canceled.
'   
'   Status of tasks:
'      Task #13: RanToCompletion
'      Task #1: Canceled
'      Task #3: Faulted
'         NotSupportedException: Specified method is not supported.
'      Task #8: Canceled
'      Task #14: RanToCompletion
'      Task #4: Canceled
'      Task #6: Faulted
'         NotSupportedException: Specified method is not supported.
'      Task #7: Canceled
'      Task #15: RanToCompletion
'      Task #9: Canceled
'      Task #11: Faulted
'         NotSupportedException: Specified method is not supported.
'      Task #12: Canceled

Per ulteriori informazioni sulla gestione delle eccezioni nelle operazioni asincrone basate su attività, vedere gestione delle eccezioni.For more information on exception handling in task-based asynchronous operations, see Exception Handling.

Attività e impostazioni culturaTasks and culture

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.

Nota

Le app dello Store seguono le Windows Runtime in impostazione e recupero delle impostazioni cultura predefinite.Store apps follow the Windows Runtime in setting and getting the default culture.

Per gli sviluppatori del debuggerFor debugger developers

Per gli sviluppatori che implementano debugger personalizzati, possono essere utili diversi membri interni e privati dell'attività (possono cambiare da release a Release).For developers implementing custom debuggers, several internal and private members of task may be useful (these may change from release to release). Il m_taskId campo funge da archivio di backup per la Id proprietà, tuttavia l'accesso a questo campo direttamente da un debugger può essere più efficiente rispetto all'accesso allo stesso valore tramite il metodo di richiamo della proprietà (il s_taskIdCounter contatore è utilizzato per recuperare il successivo ID disponibile per un'attività.The m_taskId field serves as the backing store for the Id property, however accessing this field directly from a debugger may be more efficient than accessing the same value through the property's getter method (the s_taskIdCounter counter is used to retrieve the next available ID for a task). Analogamente, m_stateFlags il campo Archivia le informazioni sulla fase del ciclo di vita corrente dell'attività, anche le Status informazioni sono accessibili tramite la proprietà.Similarly, the m_stateFlags field stores information about the current lifecycle stage of the task, information also accessible through the Status property. Il m_action campo Archivia un riferimento al delegato dell'attività e il m_stateObject campo Archivia lo stato asincrono passato all'attività dallo sviluppatore.The m_action field stores a reference to the task's delegate, and the m_stateObject field stores the async state passed to the task by the developer. Infine, per i debugger che analizzano gli stack frame InternalWait , il metodo rappresenta un potenziale marcatore quando un'attività sta immettendo un'operazione di attesa.Finally, for debuggers that parse stack frames, the InternalWait method serves a potential marker for when a task is entering a wait operation.

Costruttori

Task(Action) Task(Action) Task(Action) Task(Action)

Inizializza un nuovo oggetto Task con l'azione specificata.Initializes a new Task with the specified action.

Task(Action, CancellationToken) Task(Action, CancellationToken) Task(Action, CancellationToken) Task(Action, CancellationToken)

Inizializza un nuovo oggetto Task con l'azione specificata e CancellationToken.Initializes a new Task with the specified action and CancellationToken.

Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions)

Inizializza un nuovo oggetto Task con l'azione e le opzioni di creazione specificate.Initializes a new Task with the specified action and creation options.

Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions)

Inizializza un nuovo oggetto Task con l'azione e le opzioni di creazione specificate.Initializes a new Task with the specified action and creation options.

Task(Action<Object>, Object) Task(Action<Object>, Object) Task(Action<Object>, Object) Task(Action<Object>, Object)

Inizializza un nuovo oggetto Task con l'azione e lo stato specificati.Initializes a new Task with the specified action and state.

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

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

Task(Action<Object>, Object, CancellationToken, TaskCreationOptions) Task(Action<Object>, Object, CancellationToken, TaskCreationOptions) Task(Action<Object>, Object, CancellationToken, TaskCreationOptions) Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)

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

Task(Action<Object>, Object, TaskCreationOptions) Task(Action<Object>, Object, TaskCreationOptions) Task(Action<Object>, Object, TaskCreationOptions) Task(Action<Object>, Object, TaskCreationOptions)

Inizializza un nuovo oggetto Task con l'azione, lo stato e le opzioni specificati.Initializes a new Task with the specified action, state, and 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.

CompletedTask CompletedTask CompletedTask CompletedTask

Ottiene un'attività già completata correttamente.Gets a task that has already completed successfully.

CreationOptions CreationOptions CreationOptions CreationOptions

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

CurrentId CurrentId CurrentId CurrentId

Restituisce l'ID dell'oggetto Task attualmente in esecuzione.Returns the ID of the currently executing 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.

Factory Factory Factory Factory

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

Id Id Id Id

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

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.

IsCompleted IsCompleted IsCompleted IsCompleted

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

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

Status Status Status Status

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

Metodi

ConfigureAwait(Boolean) ConfigureAwait(Boolean) ConfigureAwait(Boolean) ConfigureAwait(Boolean)

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Delay(Int32) Delay(Int32) Delay(Int32) Delay(Int32)

Crea un'attività che viene completata dopo un numero di millisecondi specificato.Creates a task that completes after a specified number of milliseconds.

Delay(Int32, CancellationToken) Delay(Int32, CancellationToken) Delay(Int32, CancellationToken) Delay(Int32, CancellationToken)

Crea un'attività annullabile che viene completata dopo un numero di millisecondi specificato.Creates a cancellable task that completes after a specified number of milliseconds.

Delay(TimeSpan) Delay(TimeSpan) Delay(TimeSpan) Delay(TimeSpan)

Crea un'attività che viene completata dopo un intervallo di tempo specificato.Creates a task that completes after a specified time interval.

Delay(TimeSpan, CancellationToken) Delay(TimeSpan, CancellationToken) Delay(TimeSpan, CancellationToken) Delay(TimeSpan, CancellationToken)

Crea un'attività annullabile che viene completata dopo un intervallo di tempo specificato.Creates a cancellable task that completes after a specified time interval.

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.

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.

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)
FromCanceled(CancellationToken) FromCanceled(CancellationToken) FromCanceled(CancellationToken) FromCanceled(CancellationToken)

Crea un oggetto Task che risulta completato a causa dell'annullamento con un token di annullamento specificato.Creates a Task that's completed due to cancellation with a specified cancellation token.

FromCanceled<TResult>(CancellationToken) FromCanceled<TResult>(CancellationToken) FromCanceled<TResult>(CancellationToken) FromCanceled<TResult>(CancellationToken)

Crea un oggetto Task<TResult> che risulta completato a causa dell'annullamento con un token di annullamento specificato.Creates a Task<TResult> that's completed due to cancellation with a specified cancellation token.

FromException(Exception) FromException(Exception) FromException(Exception) FromException(Exception)

Crea un oggetto Task che risulta completato con un'eccezione specificata.Creates a Task that has completed with a specified exception.

FromException<TResult>(Exception) FromException<TResult>(Exception) FromException<TResult>(Exception) FromException<TResult>(Exception)

Crea un oggetto Task<TResult> che risulta completato con un'eccezione specificata.Creates a Task<TResult> that's completed with a specified exception.

FromResult<TResult>(TResult) FromResult<TResult>(TResult) FromResult<TResult>(TResult) FromResult<TResult>(TResult)

Crea un Task<TResult> che viene completato correttamente con il risultato specificato.Creates a Task<TResult> that's completed successfully with the specified result.

GetAwaiter() GetAwaiter() GetAwaiter() GetAwaiter()

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

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)
Run(Action) Run(Action) Run(Action) Run(Action)

Accoda il lavoro specificato da eseguire nel pool di thread e restituisce un oggetto Task che rappresenta tale lavoro.Queues the specified work to run on the thread pool and returns a Task object that represents that work.

Run(Action, CancellationToken) Run(Action, CancellationToken) Run(Action, CancellationToken) Run(Action, CancellationToken)

Accoda il lavoro specificato da eseguire nel pool di thread e restituisce un oggetto Task che rappresenta tale lavoro.Queues the specified work to run on the thread pool and returns a Task object that represents that work. Un token di annullamento consente di annullare il lavoro.A cancellation token allows the work to be cancelled.

Run(Func<Task>) Run(Func<Task>) Run(Func<Task>) Run(Func<Task>)

Accoda il lavoro specificato da eseguire sul pool di thread e restituisce un proxy per l'attività restituita da function.Queues the specified work to run on the thread pool and returns a proxy for the task returned by function.

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

Accoda il lavoro specificato da eseguire sul pool di thread e restituisce un proxy per l'attività restituita da function.Queues the specified work to run on the thread pool and returns a proxy for the task returned by function.

Run<TResult>(Func<Task<TResult>>) Run<TResult>(Func<Task<TResult>>) Run<TResult>(Func<Task<TResult>>) Run<TResult>(Func<Task<TResult>>)

Accoda il lavoro specificato da eseguire nel pool di thread e restituisce un proxy per l'oggetto Task(TResult) restituito da function.Queues the specified work to run on the thread pool and returns a proxy for the Task(TResult) returned by function.

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

Accoda il lavoro specificato da eseguire nel pool di thread e restituisce un proxy per l'oggetto Task(TResult) restituito da function.Queues the specified work to run on the thread pool and returns a proxy for the Task(TResult) returned by function.

Run<TResult>(Func<TResult>) Run<TResult>(Func<TResult>) Run<TResult>(Func<TResult>) Run<TResult>(Func<TResult>)

Accoda il lavoro specificato da eseguire nel pool di thread e restituisce un oggetto Task<TResult> che rappresenta tale lavoro.Queues the specified work to run on the thread pool and returns a Task<TResult> object that represents that work.

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

Accoda il lavoro specificato da eseguire nel pool di thread e restituisce un oggetto Task(TResult) che rappresenta tale lavoro.Queues the specified work to run on the thread pool and returns a Task(TResult) object that represents that work. Un token di annullamento consente di annullare il lavoro.A cancellation token allows the work to be cancelled.

RunSynchronously() RunSynchronously() RunSynchronously() RunSynchronously()

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

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.

Start() Start() Start() Start()

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

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.

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.

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.

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.

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.

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.

WaitAll(Task[]) WaitAll(Task[]) WaitAll(Task[]) WaitAll(Task[])

Attende il completamento dell'esecuzione di tutti gli oggetti Task forniti.Waits for all of the provided Task objects to complete execution.

WaitAll(Task[], CancellationToken) WaitAll(Task[], CancellationToken) WaitAll(Task[], CancellationToken) WaitAll(Task[], CancellationToken)

Attende il completamento dell'esecuzione di tutti gli oggetti Task forniti a meno che l'attesa non venga annullata.Waits for all of the provided Task objects to complete execution unless the wait is cancelled.

WaitAll(Task[], Int32) WaitAll(Task[], Int32) WaitAll(Task[], Int32) WaitAll(Task[], Int32)

Attende il completamento dell'esecuzione di tutti gli oggetti Task forniti entro un numero specificato di millisecondi.Waits for all of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAll(Task[], Int32, CancellationToken) WaitAll(Task[], Int32, CancellationToken) WaitAll(Task[], Int32, CancellationToken) WaitAll(Task[], Int32, CancellationToken)

Attende il completamento dell'esecuzione di tutti gli oggetti Task forniti entro un numero specificato di millisecondi o finché l'attesa non viene annullata.Waits for all of the provided Task objects to complete execution within a specified number of milliseconds or until the wait is cancelled.

WaitAll(Task[], TimeSpan) WaitAll(Task[], TimeSpan) WaitAll(Task[], TimeSpan) WaitAll(Task[], TimeSpan)

Attende il completamento dell'esecuzione di tutti gli oggetti Task forniti annullabili entro un intervallo di tempo specificato.Waits for all of the provided cancellable Task objects to complete execution within a specified time interval.

WaitAny(Task[]) WaitAny(Task[]) WaitAny(Task[]) WaitAny(Task[])

Attende il completamento dell'esecuzione di uno qualsiasi degli oggetti Task forniti.Waits for any of the provided Task objects to complete execution.

WaitAny(Task[], CancellationToken) WaitAny(Task[], CancellationToken) WaitAny(Task[], CancellationToken) WaitAny(Task[], CancellationToken)

Attende il completamento dell'esecuzione di uno qualsiasi degli oggetti Task forniti a meno che l'attesa non venga annullata.Waits for any of the provided Task objects to complete execution unless the wait is cancelled.

WaitAny(Task[], Int32) WaitAny(Task[], Int32) WaitAny(Task[], Int32) WaitAny(Task[], Int32)

Attende il completamento dell'esecuzione di uno qualsiasi degli oggetti Task forniti entro un numero specificato di millisecondi.Waits for any of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAny(Task[], Int32, CancellationToken) WaitAny(Task[], Int32, CancellationToken) WaitAny(Task[], Int32, CancellationToken) WaitAny(Task[], Int32, CancellationToken)

Attende il completamento dell'esecuzione di uno qualsiasi degli oggetti Task forniti entro un numero specificato di millisecondi o finché un token di annullamento non viene annullato.Waits for any of the provided Task objects to complete execution within a specified number of milliseconds or until a cancellation token is cancelled.

WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan)

Attende il completamento dell'esecuzione di uno qualsiasi degli oggetti Task forniti entro un intervallo di tempo specificato.Waits for any of the provided Task objects to complete execution within a specified time interval.

WhenAll(IEnumerable<Task>) WhenAll(IEnumerable<Task>) WhenAll(IEnumerable<Task>) WhenAll(IEnumerable<Task>)

Crea un'attività che verrà completata in seguito al completamento di tutti gli oggetti Task in una raccolta enumerabile.Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[])

Crea un'attività che verrà completata in seguito al completamento di tutti gli oggetti Task in una matrice.Creates a task that will complete when all of the Task objects in an array have completed.

WhenAll<TResult>(IEnumerable<Task<TResult>>) WhenAll<TResult>(IEnumerable<Task<TResult>>) WhenAll<TResult>(IEnumerable<Task<TResult>>) WhenAll<TResult>(IEnumerable<Task<TResult>>)

Crea un'attività che verrà completata in seguito al completamento di tutti gli oggetti Task<TResult> in una raccolta enumerabile.Creates a task that will complete when all of the Task<TResult> objects in an enumerable collection have completed.

WhenAll<TResult>(Task<TResult>[]) WhenAll<TResult>(Task<TResult>[]) WhenAll<TResult>(Task<TResult>[]) WhenAll<TResult>(Task<TResult>[])

Crea un'attività che verrà completata in seguito al completamento di tutti gli oggetti Task<TResult> in una matrice.Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

WhenAny(IEnumerable<Task>) WhenAny(IEnumerable<Task>) WhenAny(IEnumerable<Task>) WhenAny(IEnumerable<Task>)

Crea un'attività che verrà completata quando tutte le attività fornite saranno completate.Creates a task that will complete when any of the supplied tasks have completed.

WhenAny(Task[]) WhenAny(Task[]) WhenAny(Task[]) WhenAny(Task[])

Crea un'attività che verrà completata quando tutte le attività fornite saranno completate.Creates a task that will complete when any of the supplied tasks have completed.

WhenAny<TResult>(IEnumerable<Task<TResult>>) WhenAny<TResult>(IEnumerable<Task<TResult>>) WhenAny<TResult>(IEnumerable<Task<TResult>>) WhenAny<TResult>(IEnumerable<Task<TResult>>)

Crea un'attività che verrà completata quando tutte le attività fornite saranno completate.Creates a task that will complete when any of the supplied tasks have completed.

WhenAny<TResult>(Task<TResult>[]) WhenAny<TResult>(Task<TResult>[]) WhenAny<TResult>(Task<TResult>[]) WhenAny<TResult>(Task<TResult>[])

Crea un'attività che verrà completata quando tutte le attività fornite saranno completate.Creates a task that will complete when any of the supplied tasks have completed.

Yield() Yield() Yield() Yield()

Crea un'attività awaitable che in modo asincrono consente il passaggio al contesto corrente una volta atteso.Creates an awaitable task that asynchronously yields back to the current context when awaited.

Implementazioni dell'interfaccia esplicita

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.

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.

Metodi di estensione

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.

Si applica a

Thread safety

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

Vedi anche