Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Task.Run<TResult> méthode (Func<TResult>, CancellationToken)

.NET Framework (current version)
 

Date de publication : novembre 2016

Met en file d'attente le travail spécifié à exécuter dans le pool de threads et retourne un objet Task(TResult) qui représente ce travail. Un jeton d’annulation permet l’annulation du travail.

Espace de noms:   System.Threading.Tasks
Assembly:  mscorlib (dans mscorlib.dll)

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

Paramètres

function
Type: System.Func<TResult>

Travail à exécuter de façon asynchrone

cancellationToken
Type: System.Threading.CancellationToken

Jeton d'annulation qui doit être utilisé pour annuler le travail

Valeur de retour

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

Task(TResult) qui représente le travail mis en file d’attente à exécuter dans le pool de threads.

Paramètres de type

TResult

Type de résultat de la tâche.

Exception Condition
ArgumentNullException

Le paramètre function a la valeur null.

TaskCanceledException

La tâche a été annulée.

ObjectDisposedException

La CancellationTokenSource associée au cancellationToken a été supprimée.

Si l’annulation est demandée avant le début de la tâche d’exécution, la tâche ne s’exécute pas. Au lieu de cela, elle est définie sur la Canceled état et lève un TaskCanceledException exception.

Le Run<TResult> méthode constitue une alternative plus simple à la StartNew (méthode). Il crée une tâche avec les valeurs par défaut suivantes :

Pour plus d'informations sur la gestion des exceptions levées par des opérations de la tâche, consultez la page Gestion des exceptions (bibliothèque parallèle de tâches).

L’exemple suivant crée des tâches de 20 qui fait une boucle jusqu'à ce qu’un compteur est incrémenté à une valeur de 2 millions. Lorsque les 10 premières tâches atteint 2 millions, le jeton d’annulation est annulé et toutes les tâches dont les compteurs n’ont pas atteint 2 millions sont annulées. L’exemple montre les résultats éventuels.

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.

Étant donné que l’annulation est coopérative, chaque tâche peut décider comment répondre à l’annulation. L’exemple suivant est similaire à la première, sauf que, une fois que le jeton est annulé, les tâches de retourner le nombre d’itérations ils terminées, au lieu de lever une exception.

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.

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 4.5
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight pour Windows Phone
Disponible depuis 8.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher: