Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

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

.NET Framework (current version)
 

Data di pubblicazione: ottobre 2016

Accoda il lavoro specificato da eseguire nel pool di thread e restituisce un oggetto Task(TResult) che rappresenta tale lavoro. Un token di annullamento consente di annullare il lavoro.

Spazio dei nomi:   System.Threading.Tasks
Assembly:  mscorlib (in mscorlib.dll)

public static Task<TResult> Run<TResult>(
	Func<TResult> function,
	CancellationToken cancellationToken
)

Parametri

function
Type: System.Func<TResult>

Lavoro da eseguire in modo asincrono.

cancellationToken
Type: System.Threading.CancellationToken

Token di annullamento da usare per annullare il lavoro.

Valore restituito

Type: System.Threading.Tasks.Task<TResult>

Oggetto Task(TResult) che rappresenta il lavoro in coda da eseguire nel pool di thread.

Parametri tipo

TResult

Tipo di risultato dell'attività.

Exception Condition
ArgumentNullException

Il valore del parametro function è null.

TaskCanceledException

L'attività è stata annullata.

ObjectDisposedException

La classe CancellationTokenSource associata all'oggetto cancellationToken è stata eliminata.

Se viene richiesto l'annullamento prima che l'attività inizia l'esecuzione, l'attività non viene eseguito. Invece di impostare il Canceled lo stato e genera un TaskCanceledException (eccezione).

Il Run<TResult> metodo è un'alternativa più semplice per la StartNew metodo. Viene creata un'attività con i valori predefiniti seguenti:

Per informazioni sulla gestione delle eccezioni generate da operazioni di attività, vedere Gestione delle eccezioni (Task Parallel Library).

Nell'esempio seguente crea 20 attività che avvierà un loop fino a quando non viene incrementato un contatore a un valore di 2 milioni. Quando le prime 10 attività raggiungono milioni di 2, il token di annullamento viene annullato e vengono annullate tutte le attività il cui contatori non abbiano raggiunto 2 milioni. Nell'esempio viene illustrato l'output possibili.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var tasks = new List<Task<int>>();
      var source = new CancellationTokenSource();
      var token = source.Token;
      int completedIterations = 0;

      for (int n = 0; n <= 19; n++)
         tasks.Add(Task.Run( () => { int iterations = 0;
                                     for (int ctr = 1; ctr <= 2000000; ctr++) {
                                         token.ThrowIfCancellationRequested();
                                         iterations++;
                                     }
                                     Interlocked.Increment(ref completedIterations);
                                     if (completedIterations >= 10)
                                        source.Cancel();
                                     return iterations; }, token));

      Console.WriteLine("Waiting for the first 10 tasks to complete...\n");
      try  {
         Task.WaitAll(tasks.ToArray());
      }
      catch (AggregateException) {
         Console.WriteLine("Status of tasks:\n");
         Console.WriteLine("{0,10} {1,20} {2,14:N0}", "Task Id",
                           "Status", "Iterations");
         foreach (var t in tasks)
            Console.WriteLine("{0,10} {1,20} {2,14}",
                              t.Id, t.Status,
                              t.Status != TaskStatus.Canceled ? t.Result.ToString("N0") : "n/a");
      }
   }
}
// The example displays output like the following:
//    Waiting for the first 10 tasks to complete...
//    Status of tasks:
//
//       Task Id               Status     Iterations
//             1      RanToCompletion      2,000,000
//             2      RanToCompletion      2,000,000
//             3      RanToCompletion      2,000,000
//             4      RanToCompletion      2,000,000
//             5      RanToCompletion      2,000,000
//             6      RanToCompletion      2,000,000
//             7      RanToCompletion      2,000,000
//             8      RanToCompletion      2,000,000
//             9      RanToCompletion      2,000,000
//            10             Canceled            n/a
//            11             Canceled            n/a
//            12             Canceled            n/a
//            13             Canceled            n/a
//            14             Canceled            n/a
//            15             Canceled            n/a
//            16      RanToCompletion      2,000,000
//            17             Canceled            n/a
//            18             Canceled            n/a
//            19             Canceled            n/a
//            20             Canceled            n/a

Instead of using the P:System.AggregateException.InnerExceptions property to examine exceptions, the example iterates all tasks to determine which have completed successfully and which have been cancelled. For those that have completed, it displays the value returned by the task.

Poiché l'annullamento è cooperativo, ogni attività possono decidere come rispondere all'annullamento. Nell'esempio seguente è simile alla prima, ad eccezione del fatto che, quando il token viene annullato, attività di restituire il numero di iterazioni vengono completati anziché generare un'eccezione.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var tasks = new List<Task<int>>();
      var source = new CancellationTokenSource();
      var token = source.Token;
      int completedIterations = 0;

      for (int n = 0; n <= 19; n++)
         tasks.Add(Task.Run( () => { int iterations = 0;
                                     for (int ctr = 1; ctr <= 2000000; ctr++) {
                                         if (token.IsCancellationRequested)
                                            return iterations;
                                         iterations++;
                                     }
                                     Interlocked.Increment(ref completedIterations);
                                     if (completedIterations >= 10)
                                        source.Cancel();
                                     return iterations; }, token));

      Console.WriteLine("Waiting for the first 10 tasks to complete...\n");
      try  {
         Task.WaitAll(tasks.ToArray());
      }
      catch (AggregateException) {
         Console.WriteLine("Status of tasks:\n");
         Console.WriteLine("{0,10} {1,20} {2,14:N0}", "Task Id",
                           "Status", "Iterations");
         foreach (var t in tasks)
            Console.WriteLine("{0,10} {1,20} {2,14}",
                              t.Id, t.Status,
                              t.Status != TaskStatus.Canceled ? t.Result.ToString("N0") : "n/a");
      }
   }
}
// The example displays output like the following:
//    Status of tasks:
//
//       Task Id               Status     Iterations
//             1      RanToCompletion      2,000,000
//             2      RanToCompletion      2,000,000
//             3      RanToCompletion      2,000,000
//             4      RanToCompletion      2,000,000
//             5      RanToCompletion      2,000,000
//             6      RanToCompletion      2,000,000
//             7      RanToCompletion      2,000,000
//             8      RanToCompletion      2,000,000
//             9      RanToCompletion      2,000,000
//            10      RanToCompletion      1,658,326
//            11      RanToCompletion      1,988,506
//            12      RanToCompletion      2,000,000
//            13      RanToCompletion      1,942,246
//            14      RanToCompletion        950,108
//            15      RanToCompletion      1,837,832
//            16      RanToCompletion      1,687,182
//            17      RanToCompletion        194,548
//            18             Canceled    Not Started
//            19             Canceled    Not Started
//            20             Canceled    Not Started

The example still must handle the T:System.AggregateException exception, since any tasks that have not started when cancellation is requested still throw an exception.

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 4.5
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Windows Phone Silverlight
Disponibile da 8.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: