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

Il Task classe rappresenta una singola operazione che non restituisce un valore e che in genere esegue in modo asincrono.The Task class represents a single operation that does not return a value and that usually executes asynchronously. Task gli oggetti sono uno dei componenti centrali del modello asincrono basato su attività introdotte inizialmente in .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 in genere viene eseguito l'oggetto in modo asincrono in un pool di thread anziché in modo sincrono sul thread principale dell'applicazione, è possibile usare il Status proprietà, nonché il IsCanceled, IsCompleted, e IsFaulted alle proprietà per determinare lo stato di un'attività.Because the work performed by a Task object typically executes asynchronously on a thread pool thread rather than synchronously on the main application thread, you can use the Status property, as well as the IsCanceled, IsCompleted, and IsFaulted properties, to determine the state of a task. In genere, un'espressione lambda viene utilizzata per specificare il lavoro che l'attività deve eseguire.Most commonly, a lambda expression is used to specify the work that the task is to perform.

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

Contenuto della sezione:In this section:

Esempi di creazione di un'istanza di attività Task instantiation examples
Creazione ed esecuzione di un'attività Creating and executing a task
La separazione tra l'esecuzione e la creazione di attività Separating task creation and execution
In attesa di uno o più attività da completare Waiting for one or more tasks to complete
Le attività e le impostazioni cultura Tasks and culture
Per gli sviluppatori di debuggerFor debugger developers

Creazione di istanze di attivitàTask instantiation

Nell'esempio seguente crea ed esegue quattro attività.The following example creates and executes four tasks. Le tre attività vengono eseguite 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. Un'espressione lambda viene eseguita un'attività quarta (un Action delegare) vale a dire definito inline nella chiamata al metodo di creazione di attività.A fourth task executes a lambda expression (an Action delegate) that is defined inline in the call to the task creation method. Ogni attività vengano creata un'istanza ed eseguire in modo diverso:Each task is instantiated and run in a different way:

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

  • Task t2 viene creata e avviata in una singola chiamata al metodo chiamando il TaskFactory.StartNew(Action<Object>, Object) (metodo).Task t2 is instantiated and started in a single method call by calling the TaskFactory.StartNew(Action<Object>, Object) method.

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

  • Task t4 viene eseguita in modo sincrono sul thread principale, chiamare il RunSynchronously() (metodo).Task t4 is executed synchronously on the main thread by calling the RunSynchronously() method.

In quanto attività t4 esegue in modo sincrono, viene eseguito sul thread principale dell'applicazione.Because task t4 executes synchronously, it executes on the main application thread. Le rimanenti attività eseguire in modo asincrono in genere in uno o più 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

Task è possibile creare istanze in diversi modi.Task instances may be created in a variety of ways. L'approccio più comune, che sarà disponibile a partire con il .NET Framework 4.5.NET Framework 4.5, è possibile chiamare il metodo statico Run (metodo).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 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. L'esempio seguente usa il Run(Action) 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

In alternativa e il metodo più comune per avviare un'attività in .NET Framework 4.NET Framework 4, è il metodo statico TaskFactory.StartNew (metodo).An alternative, and the most common method to start a task in .NET Framework 4.NET Framework 4, is the static TaskFactory.StartNew method. Il Task.Factory proprietà restituisce un TaskFactory oggetto.The Task.Factory property returns a TaskFactory object. Esegue l'overload del TaskFactory.StartNew metodo consentono di specificare i parametri da passare a un'utilità di pianificazione e le opzioni di creazione di attività.Overloads of the TaskFactory.StartNew method let you specify parameters to pass to the task creation options and a task scheduler. L'esempio seguente usa il TaskFactory.StartNew metodo per avviare un'attività.The following example uses the TaskFactory.StartNew method to start a task. È funzionalmente equivalente al codice nell'esempio precedente.It is functionally equivalent to the code in the previous example.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      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.

La separazione tra l'esecuzione e la creazione di attivitàSeparating task creation and execution

Il Task classe fornisce anche i costruttori che inizializzano l'attività, ma che non si pianifica l'esecuzione.The Task class also provides constructors that initialize the task but that do not schedule it for execution. Per motivi di prestazioni, la Task.Run o TaskFactory.StartNew metodo è il meccanismo preferito per creare e pianificare le attività di calcolo, ma per gli scenari in cui la creazione e la pianificazione devono essere separati, è possibile usare i costruttori e quindi chiamare il Task.Start metodo per pianificare l'attività per l'esecuzione 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 di uno o più attività da completareWaiting for one or more tasks to complete

Poiché le attività in genere vengono eseguiti in modo asincrono in un pool di thread, il thread che crea e avvia l'attività continua l'esecuzione, non appena l'attività è stata creata l'istanza.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'app può terminare prima di qualsiasi attività effettivamente inizia 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 altri casi, la logica dell'applicazione può richiedere che il thread chiamante continua l'esecuzione solo quando una o più attività è stata completata 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 asincrona le attività consente di avviare chiamando un Wait metodo per attendere uno o più attività da completare.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 un'attività singola, è possibile chiamare relativo Task.Wait (metodo).To wait for a single task to complete, you can call its Task.Wait method. Una chiamata al Wait metodo si blocca il thread chiamante finché l'istanza della classe singola è stata completata l'esecuzione.A call to the Wait method blocks the calling thread until the single class instance has completed execution.

L'esempio seguente viene chiamata senza parametri Wait() metodo 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 lavoro chiamando il Thread.Sleep metodo allo stato di 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

È inoltre in modo condizionale può attendere un'attività da completare.You can also conditionally wait for a task to complete. Il Wait(Int32) e Wait(TimeSpan) metodi bloccano il thread chiamante finché non viene completata l'attività o un intervallo di timeout scade, a seconda del valore 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 rimane inattivo per due secondi, ma definisce un valore di timeout di un secondo, il thread chiamante si blocca fino a quando non scade il timeout e prima dell'attività è stata completata l'esecuzione.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 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 il token IsCancellationRequested proprietà è true o diventa true mentre il Wait metodo è in esecuzione, 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, si vuole attendere per il primo di una serie di esecuzione dell'attività completata, ma è care 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 tale 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. L'esempio seguente crea tre attività, ognuna delle quali rimane inattivo per un intervallo di determinare dal 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 dell'attività prima.The WaitAny(Task[]) method waits for the first task to complete. Nell'esempio vengono quindi visualizzate informazioni sullo stato di tutte le tre 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 tutti di una serie di attività da completare tramite la chiamata di 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 che tutti e dieci completamento e quindi Visualizza il relativo 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 in attesa di uno o più attività da completare, tutte le eccezioni generate nelle attività in esecuzione vengono propagate nel thread che chiama il Wait 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. Avvia le attività di 12, tre dei quali completata normalmente e tre dei 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 sono annullata prima che inizino e tre sono annullata mentre sono in esecuzione.Of the remaining six tasks, three are cancelled before they start, and three are cancelled while they are executing. Vengono generate eccezioni nel WaitAll chiamata al metodo e sono gestite da un try / 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 altre informazioni sulla gestione delle eccezioni in operazioni asincrone basate su attività, vedere gestione delle eccezioni.For more information on exception handling in task-based asynchronous operations, see Exception Handling.

Le attività e le impostazioni culturaTasks and culture

Inizia con le app desktop che hanno come destinazione il .NET Framework 4.6.NET Framework 4.6, le impostazioni cultura del thread che crea e richiama un'attività entra a far parte del contesto del thread.Starting with desktop apps that target the .NET Framework 4.6.NET Framework 4.6, the culture of the thread that creates and invokes a task becomes part of the thread's context. Indipendentemente dalle impostazioni cultura correnti del thread in cui l'attività viene eseguita, le impostazioni cultura correnti dell'attività sono la cultura del thread chiamante.That is, regardless of the current culture of the thread on which the task executes, the current culture of the task is the culture of the calling thread. Per le app destinate a versioni di .NET Framework precedenti al .NET Framework 4.6.NET Framework 4.6, le impostazioni cultura dell'attività sono le impostazioni cultura del thread in cui viene eseguita l'attività.For apps that target versions of the .NET Framework prior to the .NET Framework 4.6.NET Framework 4.6, the culture of the task is the culture of the thread on which the task executes. Per altre informazioni, vedere la sezione "Impostazioni cultura e operazioni asincrone basate su attività" nel CultureInfo argomento.For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic.

Nota

Le app di Store seguono il Runtime di Windows nell'impostazione e recupero delle impostazioni cultura predefinite.Store apps follow the Windows Runtime in setting and getting the default culture.

Per gli sviluppatori di debuggerFor debugger developers

Per gli sviluppatori implementano debugger personalizzati, membri interni e privati diverse dell'attività possono essere utili (tali può cambiare nelle diverse versioni).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 il 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 Consente di 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 m_stateFlags campo Archivia le informazioni relative alla fase del ciclo di vita corrente dell'attività, informazioni accessibili anche tramite il Status 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 debugger che analizzano gli stack frame, la InternalWait metodo viene utilizzato un marcatore potenziali per quando un'attività sta entrando in 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.

Extension Methods

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

Vedi anche