Task Classe

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à
Task
Derivato
Implementazioni

Commenti

La classe Task 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. Task 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 oggetto Task in genere viene eseguito in modo asincrono in un thread del pool di thread anziché in modo sincrono sul thread principale dell'applicazione, è possibile usare la proprietà Status, nonché le proprietà IsCanceled, IsCompletede IsFaulted 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 la classe Task<TResult>.For operations that return values, you use the Task<TResult> class.

In questa 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 delegato Action<T> 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 delegato Action) 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 creata un'istanza dell'attività t1 chiamando un costruttore della classe di attività, ma viene avviata chiamando il relativo metodo Start() solo dopo l'avvio dell't2 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 creata un'istanza dell'attività t2 e viene avviata in una singola chiamata al metodo chiamando il metodo TaskFactory.StartNew(Action<Object>, Object).Task t2 is instantiated and started in a single method call by calling the TaskFactory.StartNew(Action<Object>, Object) method.

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

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

Poiché l'attività t4 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

è possibile creare istanze di Task in diversi modi.Task instances may be created in a variety of ways. L'approccio più comune, disponibile a partire dalla .NET Framework 4.5.NET Framework 4.5, consiste nel chiamare il metodo Run statico.The 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 metodo Run 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 il metodo Run(Action) 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 4, è il metodo TaskFactory.StartNew statico.An alternative, and the most common method to start a task in .NET Framework 4.NET Framework 4, is the static TaskFactory.StartNew method. La proprietà Task.Factory restituisce un oggetto TaskFactory.The Task.Factory property returns a TaskFactory object. Gli overload del metodo TaskFactory.StartNew 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 il metodo TaskFactory.StartNew 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 classe Task fornisce anche 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, il metodo Task.Run o TaskFactory.StartNew è 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 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 metodo di Wait 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 relativo metodo Task.Wait.To wait for a single task to complete, you can call its Task.Wait method. Una chiamata al metodo Wait 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 metodo Wait() 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 metodi Wait(Int32) e Wait(TimeSpan) 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 specificare un token di annullamento chiamando il Wait(CancellationToken) e Wait(Int32, CancellationToken) metodi.You can also supply a cancellation token by calling the Wait(CancellationToken) and Wait(Int32, CancellationToken) methods. Se la proprietà IsCancellationRequested del token è true o diventa true mentre è in esecuzione il metodo Wait, il metodo genera un'OperationCanceledException.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 metodo Task.WaitAny.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 metodo WaitAny(Task[]) 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 metodo WaitAll.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 che chiama il metodo Wait, 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 nella chiamata al metodo WaitAll e sono gestite da un blocco catch /try.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 alla .NET Framework 4.6.NET Framework 4.6, 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 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 ulteriori informazioni, vedere la sezione "impostazioni cultura e operazioni asincrone basate su attività" nell'argomento CultureInfo.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 campo m_taskId funge da archivio di backup per la proprietà Id, tuttavia l'accesso a questo campo direttamente da un debugger può risultare più efficiente rispetto all'accesso allo stesso valore tramite il metodo di richiamo della proprietà (il contatore s_taskIdCounter viene 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, il campo m_stateFlags archivia informazioni sulla fase del ciclo di vita corrente dell'attività, anche le informazioni sono accessibili tramite la proprietà Status.Similarly, the m_stateFlags field stores information about the current lifecycle stage of the task, information also accessible through the Status property. Il campo m_action archivia un riferimento al delegato dell'attività e il campo m_stateObject 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, il InternalWait 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)

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

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)

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)

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)

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)

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)

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)

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

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

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

CreationOptions

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

CurrentId

Restituisce l'ID dell'oggetto Task attualmente in esecuzione.Returns the ID of the currently executing Task.

Exception

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

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

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

IsCanceled

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

IsCompleted

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

IsCompletedSuccessfully

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

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

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

Metodi

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)

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)

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)

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)

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)

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>)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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>)

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)

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)

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)

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)

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)

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)

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)

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)

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

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)

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

Equals(Object)

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

(Ereditato da Object)
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)

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)

Crea un oggetto Task che risulta completato con un'eccezione specificata.Creates a Task that has completed with a specified 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)

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

GetAwaiter()

Ottiene un elemento awaiter usato per attendere questo oggetto Task.Gets an awaiter used to await this Task.

GetHashCode()

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

(Ereditato da Object)
GetType()

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

(Ereditato da Object)
MemberwiseClone()

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

(Ereditato da Object)
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)

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>)

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)

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>>)

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)

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>)

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)

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

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

RunSynchronously(TaskScheduler)

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

Start()

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

Start(TaskScheduler)

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

ToString()

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

(Ereditato da Object)
Wait()

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

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)

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)

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)

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[])

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)

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)

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)

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)

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[])

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)

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)

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)

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)

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>)

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

WhenAll(Task[])

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

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

Crea un'attività che verrà completata in seguito al completamento di tutti gli oggetti Task<TResult> di 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>[])

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

WhenAny(IEnumerable<Task>)

Crea un'attività che verrà completata quando una delle attività fornite sarà completata.Creates a task that will complete when any of the supplied tasks have completed.

WhenAny(Task[])

Crea un'attività che verrà completata quando una delle attività fornite sarà completata.Creates a task that will complete when any of the supplied tasks have completed.

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

Crea un'attività che verrà completata quando una delle attività fornite sarà completata.Creates a task that will complete when any of the supplied tasks have completed.

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

Crea un'attività che verrà completata quando una delle attività fornite sarà completata.Creates a task that will complete when any of the supplied tasks have completed.

Yield()

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

Implementazioni dell'interfaccia esplicita

IAsyncResult.AsyncWaitHandle

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

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)

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

DispatcherOperationWait(Task, TimeSpan)

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

IsDispatcherOperationTask(Task)

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

AsAsyncAction(Task)

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

Si applica a

Thread safety

Tutti i membri di Task, ad eccezione di Dispose(), 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