TaskFactory.StartNew Méthode

Référence

Définition

Espace de noms:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Crée et lance une tâche.

Surcharges

StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Crée et démarre une tâche pour le délégué d’action, l’état, le jeton d’annulation, les options de création et le planificateur de tâches spécifiés.
StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)	Crée et démarre une tâche pour le délégué d’action, le jeton d’annulation, les options de création et l’état spécifiés.
StartNew(Action<Object>, Object, TaskCreationOptions)	Crée et démarre une tâche pour le délégué d’action, l’état et les options de création spécifiés.
StartNew(Action<Object>, Object, CancellationToken)	Crée et démarre une tâche pour le délégué d’action, l’état et le jeton d’annulation spécifiés.
StartNew(Action, CancellationToken)	Crée et démarre une tâche pour le délégué d’action et le jeton d’annulation spécifiés.
StartNew(Action, TaskCreationOptions)	Crée et démarre une tâche pour les options de délégué et de création d’action spécifiées.
StartNew(Action)	Crée et démarre une tâche pour le délégué d’action spécifié.
StartNew(Action<Object>, Object)	Crée et démarre une tâche pour le délégué et l’état d’action spécifiés.
StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction, le jeton d’annulation, les options de création et le planificateur de tâches spécifiés.
StartNew<TResult>(Func<TResult>)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction spécifié.
StartNew<TResult>(Func<Object,TResult>, Object)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction et l’état spécifiés.
StartNew<TResult>(Func<TResult>, CancellationToken)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction et le jeton d’annulation spécifiés.
StartNew<TResult>(Func<TResult>, TaskCreationOptions)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction et les options de création spécifiés.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction, l’état et le jeton d’annulation spécifiés.
StartNew<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction, l’état et les options de création spécifiés.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction, l’état, le jeton d’annulation, les options de création et le planificateur de tâches spécifiés.

Remarques

À compter de la .NET Framework 4.5, la Task.Run méthode est la méthode recommandée pour lancer une tâche liée au calcul. Utilisez la StartNew méthode uniquement lorsque vous avez besoin d’un contrôle affiné pour une tâche à long terme liée au calcul. Cela inclut des scénarios dans lesquels vous souhaitez contrôler les éléments suivants :

Options de création de tâches. Les tâches créées par la Task.Run méthode par défaut sont créées avec l’option TaskCreationOptions.DenyChildAttach . Pour remplacer ce comportement ou pour fournir d’autres TaskCreationOptions options, appelez une StartNew surcharge.
Passage de paramètre. Les surcharges de la Task.Run méthode ne vous permettent pas de transmettre un paramètre au délégué de tâche. Surcharges de la StartNew méthode.
Planificateur de tâches. Les surcharges de la Task.Run méthode utilisent le planificateur de tâches par défaut. Pour contrôler le planificateur de tâches, appelez une StartNew surcharge avec un scheduler paramètre. Pour plus d'informations, consultez TaskScheduler.

StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)

Crée et démarre une tâche pour le délégué d’action, l’état, le jeton d’annulation, les options de création et le planificateur de tâches spécifiés.

public:
 System::Threading::Tasks::Task ^ StartNew(Action<System::Object ^> ^ action, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task StartNew (Action<object> action, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler);

public System.Threading.Tasks.Task StartNew (Action<object?> action, object? state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.StartNew : Action<obj> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task

Paramètres

action: Action<Object>

Délégué d'action à exécuter de façon asynchrone.

state: Object

Objet contenant des données que le délégué action doit utiliser.

cancellationToken: CancellationToken

Jeton d’annulation qui sera assigné à la nouvelle tâche.

creationOptions: TaskCreationOptions

L’une des valeurs d’énumération qui contrôlent le comportement de la tâche créée.

scheduler: TaskScheduler

Planificateur de tâche utilisé pour planifier la tâche de continuation créée.

Retours

Task

Tâche démarrée.

Exceptions

ObjectDisposedException

Le CancellationToken fourni a déjà été supprimé.

ArgumentNullException

action a la valeur null.

-ou-

scheduler a la valeur null.

ArgumentOutOfRangeException

L’argument creationOptions spécifie une valeur de TaskCreationOptions non valide. Pour plus d'informations, consultez la section Notes de la rubrique FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions).

Remarques

L’appel de StartNew est fonctionnellement équivalent à la création d’une tâche à l’aide de l’un de ses constructeurs, puis à l’appel Start pour planifier son exécution.

À compter de la .NET Framework 4.5, vous pouvez utiliser la Run méthode avec un Action objet comme moyen rapide d’appeler StartNew avec des paramètres par défaut. Pour plus d’informations et des exemples de code, consultez Task.Run vs Task.Factory.StartNew dans le blog De programmation parallèle avec .NET.

Voir aussi

S’applique à

StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)

Crée et démarre une tâche pour le délégué d’action, le jeton d’annulation, les options de création et l’état spécifiés.

public:
 System::Threading::Tasks::Task ^ StartNew(Action ^ action, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task StartNew (Action action, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.StartNew : Action * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function StartNew (action As Action, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task

Paramètres

action: Action

Délégué d'action à exécuter de façon asynchrone.

cancellationToken: CancellationToken

Jeton d’annulation qui sera assigné à la nouvelle tâche.

creationOptions: TaskCreationOptions

L’une des valeurs d’énumération qui contrôlent le comportement de la tâche créée.

scheduler: TaskScheduler

Planificateur de tâche utilisé pour planifier la tâche de continuation créée.

Retours

Task

Tâche démarrée.

Exceptions

ObjectDisposedException

Le CancellationToken fourni a déjà été supprimé.

ArgumentNullException

action a la valeur null.

-ou- scheduler a la valeur null.

ArgumentOutOfRangeException

creationOptions spécifie une valeur de TaskCreationOptions non valide. Pour plus d'informations, consultez la section Notes de la rubrique FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions).

Remarques

L’appel de StartNew est fonctionnellement équivalent à la création d’une tâche à l’aide de l’un de ses constructeurs, puis à l’appel Start pour planifier son exécution.

Voir aussi

S’applique à

StartNew(Action<Object>, Object, TaskCreationOptions)

Crée et démarre une tâche pour le délégué d’action, l’état et les options de création spécifiés.

public:
 System::Threading::Tasks::Task ^ StartNew(Action<System::Object ^> ^ action, System::Object ^ state, System::Threading::Tasks::TaskCreationOptions creationOptions);

public System.Threading.Tasks.Task StartNew (Action<object> action, object state, System.Threading.Tasks.TaskCreationOptions creationOptions);

public System.Threading.Tasks.Task StartNew (Action<object?> action, object? state, System.Threading.Tasks.TaskCreationOptions creationOptions);

member this.StartNew : Action<obj> * obj * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object, creationOptions As TaskCreationOptions) As Task

Paramètres

action: Action<Object>

Délégué d'action à exécuter de façon asynchrone.

state: Object

Objet contenant des données que le délégué action doit utiliser.

creationOptions: TaskCreationOptions

L’une des valeurs d’énumération qui contrôlent le comportement de la tâche créée.

Retours

Task

Tâche démarrée.

Exceptions

ArgumentNullException

action a la valeur null.

ArgumentOutOfRangeException

creationOptions spécifie une valeur de TaskCreationOptions non valide.

Remarques

L’appel de StartNew est fonctionnellement équivalent à la création d’une tâche à l’aide de l’un de ses constructeurs, puis à l’appel Start pour planifier son exécution.

Voir aussi

S’applique à

StartNew(Action<Object>, Object, CancellationToken)

Crée et démarre une tâche pour le délégué d’action, l’état et le jeton d’annulation spécifiés.

public:
 System::Threading::Tasks::Task ^ StartNew(Action<System::Object ^> ^ action, System::Object ^ state, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task StartNew (Action<object> action, object state, System.Threading.CancellationToken cancellationToken);

public System.Threading.Tasks.Task StartNew (Action<object?> action, object? state, System.Threading.CancellationToken cancellationToken);

member this.StartNew : Action<obj> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object, cancellationToken As CancellationToken) As Task

Paramètres

action: Action<Object>

Délégué d'action à exécuter de façon asynchrone.

state: Object

Objet contenant des données que le délégué action doit utiliser.

cancellationToken: CancellationToken

Jeton d’annulation qui sera assigné à la nouvelle tâche.

Retours

Task

Tâche démarrée.

Exceptions

ObjectDisposedException

Le CancellationToken fourni a déjà été supprimé.

ArgumentNullException

action a la valeur null.

Exemples

L’exemple suivant définit un tableau de mots à 6 lettres. Chaque mot est ensuite passé à un Action<T> délégué, qui brouillé le mot et affiche le mot d’origine et sa version brouillée.

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

public class Example
{
   public static void Main()
   {
      CancellationTokenSource cts = new CancellationTokenSource();
      CancellationToken token = cts.Token;
      var tasks = new List<Task>();
      Random rnd = new Random();
      Object lockObj = new Object();
      String[] words6 = { "reason", "editor", "rioter", "rental",
                          "senior", "regain", "ordain", "rained" };

      foreach (var word6 in words6)
         tasks.Add(Task.Factory.StartNew( (word) => { Char[] chars = word.ToString().ToCharArray();
                                                      double[] order = new double[chars.Length];
                                                      token.ThrowIfCancellationRequested();
                                                      bool wasZero = false;
                                                      lock (lockObj) {
                                                         for (int ctr = 0; ctr < order.Length; ctr++) {
                                                             order[ctr] = rnd.NextDouble();
                                                             if (order[ctr] == 0) {
                                                                if (! wasZero) {
                                                                   wasZero = true;
                                                                }
                                                                else {
                                                                   cts.Cancel();
                                                                }
                                                             }
                                                         }
                                                      }
                                                      token.ThrowIfCancellationRequested();
                                                      Array.Sort(order, chars);
                                                      Console.WriteLine("{0} --> {1}", word,
                                                                        new String(chars));
                                                    }, word6, token));

      try {
         Task.WaitAll(tasks.ToArray());
      }
      catch (AggregateException e) {
         foreach (var ie in e.InnerExceptions) {
            if (ie is OperationCanceledException) {
               Console.WriteLine("The word scrambling operation has been cancelled.");
               break;
            }
            else {
               Console.WriteLine(ie.GetType().Name + ": " + ie.Message);
            }
         }
      }
      finally {
         cts.Dispose();
      }
   }
}
// The example displays output like the following:
//    regain --> irnaeg
//    ordain --> rioadn
//    reason --> soearn
//    rained --> rinade
//    rioter --> itrore
//    senior --> norise
//    rental --> atnerl
//    editor --> oteird

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim cts As New CancellationTokenSource()
      Dim token As CancellationToken = cts.Token
      Dim tasks As New List(Of Task)()
      Dim rnd As New Random()
      Dim lockObj As New Object()
      Dim words6() As String = { "reason", "editor", "rioter", "rental",
                                 "senior", "regain", "ordain", "rained" }

      For Each word6 in words6
         tasks.Add(Task.Factory.StartNew( Sub(word)
                                              Dim chars() As Char = word.ToString().ToCharArray()
                                              Dim order(chars.Length - 1) As Double
                                              Dim wasZero As Boolean = False
                                              SyncLock lockObj
                                                 For ctr As Integer = 0 To order.Length - 1
                                                    order(ctr) = rnd.NextDouble()
                                                    If order(ctr) = 0 Then
                                                       If Not wasZero Then
                                                          wasZero = True
                                                       Else
                                                          cts.Cancel()
                                                       End If
                                                    End If
                                                 Next
                                              End SyncLock
                                              token.ThrowIfCancellationRequested()
                                              Array.Sort(order, chars)
                                              Console.WriteLine("{0} --> {1}", word,
                                                                new String(chars))
                                          End Sub, word6))
      Next
      Try
         Task.WaitAll(tasks.ToArray())
      Catch e As AggregateException
         For Each ie In e.InnerExceptions
            If TypeOf ie Is OperationCanceledException
               Console.WriteLine("The word scrambling operation has been cancelled.")
               Exit For
            Else
               Console.WriteLine(ie.GetType().Name + ": " + ie.Message)
            End If
         Next
      Finally
         cts.Dispose()
      End Try
   End Sub
End Module
' The example displays output like the following:
'       regain --> irnaeg
'       ordain --> rioadn
'       reason --> soearn
'       rained --> rinade
'       rioter --> itrore
'       senior --> norise
'       rental --> atnerl
'       editor --> oteird

Notez que l’exemple initialise un seul générateur de nombres aléatoires, qui est protégé par un verrou. Pour connaître le besoin d’un verrou, consultez « La classe System.Random et la sécurité des threads » dans la Random rubrique de classe. Pour gérer la possibilité d’altération du générateur de nombres aléatoires, un jeton d’annulation est passé à la tâche. Si deux nombres aléatoires sont égaux à zéro, la méthode part du principe que le générateur de nombres aléatoires est endommagé et définit le jeton d’annulation. Avant de trier le chars tableau qui contient les six caractères d’un mot, la méthode appelle la CancellationToken.ThrowIfCancellationRequested méthode pour lever un OperationCanceledException jeton si le jeton a été annulé.

Remarques

L’appel de StartNew équivaut à créer une tâche à l’aide de l’un de ses constructeurs, puis d’appeler Start pour planifier l’exécution.

Voir aussi

S’applique à

StartNew(Action, CancellationToken)

Crée et démarre une tâche pour le délégué d’action et le jeton d’annulation spécifiés.

public:
 System::Threading::Tasks::Task ^ StartNew(Action ^ action, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task StartNew (Action action, System.Threading.CancellationToken cancellationToken);

member this.StartNew : Action * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Function StartNew (action As Action, cancellationToken As CancellationToken) As Task

Paramètres

action: Action

Délégué d'action à exécuter de façon asynchrone.

cancellationToken: CancellationToken

Jeton d’annulation qui sera assigné à la nouvelle tâche.

Retours

Task

Tâche démarrée.

Exceptions

ObjectDisposedException

Le CancellationToken fourni a déjà été supprimé.

ArgumentNullException

action a la valeur null.

Exemples

L’exemple suivant appelle la StartNew(Action, CancellationToken) méthode pour créer une tâche qui itère les fichiers dans le répertoire C:\Windows\System32. L’expression lambda appelle la Parallel.ForEach méthode pour ajouter des informations sur chaque fichier à un List<T> objet. Chaque tâche imbriquée détachée appelée par la Parallel.ForEach boucle vérifie l’état du jeton d’annulation et, si l’annulation est demandée, appelle la CancellationToken.ThrowIfCancellationRequested méthode. La CancellationToken.ThrowIfCancellationRequested méthode lève une OperationCanceledException exception gérée dans un catch bloc lorsque le thread appelant appelle la Task.Wait méthode.

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

public class Example
{
   public static void Main()
   {
      var tokenSource = new CancellationTokenSource();
      var token = tokenSource.Token;
      var files = new List<Tuple<string, string, long, DateTime>>();

      var t = Task.Factory.StartNew( () => { string dir = "C:\\Windows\\System32\\";
                                object obj = new Object();
                                if (Directory.Exists(dir)) {
                                   Parallel.ForEach(Directory.GetFiles(dir),
                                   f => {
                                           if (token.IsCancellationRequested)
                                              token.ThrowIfCancellationRequested();
                                           var fi = new FileInfo(f);
                                           lock(obj) {
                                              files.Add(Tuple.Create(fi.Name, fi.DirectoryName, fi.Length, fi.LastWriteTimeUtc));          
                                           }
                                      });
                                 }
                              }
                        , token);
      tokenSource.Cancel();
      try {
         t.Wait(); 
         Console.WriteLine("Retrieved information for {0} files.", files.Count);
      }
      catch (AggregateException e) {
         Console.WriteLine("Exception messages:");
         foreach (var ie in e.InnerExceptions)
            Console.WriteLine("   {0}: {1}", ie.GetType().Name, ie.Message);

         Console.WriteLine("\nTask status: {0}", t.Status);       
      }
      finally {
         tokenSource.Dispose();
      }
   }
}
// The example displays the following output:
//       Exception messages:
//          TaskCanceledException: A task was canceled.
//       
//       Task status: Canceled

Imports System.Collections.Generic
Imports System.IO
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tokenSource As New CancellationTokenSource()
      Dim token As CancellationToken = tokenSource.Token
      Dim files As New List(Of Tuple(Of String, String, Long, Date))()

      Dim t As Task = Task.Factory.StartNew( Sub()
                                   Dim dir As String = "C:\Windows\System32\"
                                   Dim obj As New Object()
                                   If Directory.Exists(dir)Then
                                      Parallel.ForEach(Directory.GetFiles(dir), 
                                         Sub(f)
                                            If token.IsCancellationRequested Then
                                               token.ThrowIfCancellationRequested()
                                            End If  
                                            Dim fi As New FileInfo(f)
                                            SyncLock(obj)
                                              files.Add(Tuple.Create(fi.Name, fi.DirectoryName, fi.Length, fi.LastWriteTimeUtc))          
                                            End SyncLock
                                         End Sub)
                                   End If
                                End Sub, token)
      tokenSource.Cancel()
      Try
         t.Wait() 
         Console.WriteLine("Retrieved information for {0} files.", files.Count)
      Catch e As AggregateException
         Console.WriteLine("Exception messages:")
         For Each ie As Exception In e.InnerExceptions
            Console.WriteLine("   {0}:{1}", ie.GetType().Name, ie.Message)
         Next
         Console.WriteLine()
         Console.WriteLine("Task status: {0}", t.Status)       
      Finally
         tokenSource.Dispose()
      End Try
   End Sub
End Module
' The example displays the following output:
'       Exception messages:
'          TaskCanceledException: A task was canceled.
'       
'       Task status: Canceled

Remarques

L’appel StartNew est fonctionnellement équivalent à la création d’une tâche à l’aide de l’un de ses constructeurs, puis à l’appel Start pour planifier l’exécution.

À compter de la .NET Framework 4.5, vous pouvez utiliser la Task.Run(Action, CancellationToken) méthode comme moyen rapide d’appeler StartNew(Action, CancellationToken) avec des paramètres par défaut. Notez toutefois qu’il existe une différence de comportement entre les deux méthodes concernant : Task.Run(Action, CancellationToken) par défaut, les tâches enfants ne sont pas autorisées à commencer par l’option TaskCreationOptions.AttachedToParent à attacher à l’instance actuelle Task , tandis que StartNew(Action, CancellationToken) cela. Pour plus d’informations et d’exemples de code, consultez Task.Run vs Task.Factory.StartNew dans la programmation parallèle avec le blog .NET.

Voir aussi

S’applique à

StartNew(Action, TaskCreationOptions)

Crée et démarre une tâche pour les options de délégué et de création d’action spécifiées.

public:
 System::Threading::Tasks::Task ^ StartNew(Action ^ action, System::Threading::Tasks::TaskCreationOptions creationOptions);

public System.Threading.Tasks.Task StartNew (Action action, System.Threading.Tasks.TaskCreationOptions creationOptions);

member this.StartNew : Action * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Function StartNew (action As Action, creationOptions As TaskCreationOptions) As Task

Paramètres

action: Action

Délégué d'action à exécuter de façon asynchrone.

creationOptions: TaskCreationOptions

L’une des valeurs d’énumération qui contrôlent le comportement de la tâche créée.

Retours

Task

Tâche démarrée.

Exceptions

ArgumentNullException

action a la valeur null.

ArgumentOutOfRangeException

creationOptions spécifie une valeur de TaskCreationOptions non valide.

Remarques

L’appel de StartNew équivaut à créer une tâche à l’aide de l’un de ses constructeurs, puis d’appeler Start pour planifier l’exécution.

À compter de la .NET Framework 4.5, vous pouvez utiliser la Run méthode avec un Action objet comme moyen rapide d’appeler StartNew avec des paramètres par défaut. Pour plus d’informations et d’exemples de code, consultez Task.Run vs Task.Factory.StartNew dans la programmation parallèle avec le blog .NET.

Voir aussi

S’applique à

StartNew(Action)

Crée et démarre une tâche pour le délégué d’action spécifié.

public:
 System::Threading::Tasks::Task ^ StartNew(Action ^ action);

public System.Threading.Tasks.Task StartNew (Action action);

member this.StartNew : Action -> System.Threading.Tasks.Task

Public Function StartNew (action As Action) As Task

Paramètres

action: Action

Délégué d'action à exécuter de façon asynchrone.

Retours

Task

Tâche démarrée.

Exceptions

ArgumentNullException

L'argument action a la valeur null.

Exemples

L’exemple suivant utilise la StartNew(Action) méthode pour appeler à plusieurs reprises un Action délégué qui génère un nombre aléatoire, l’interprète comme un point de code Unicode, le convertit en unité de code codée UTF16 et affiche des informations sur le caractère ou les caractères résultants.

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

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      List<Task> tasks  = new List<Task>();
      // Execute the task 10 times.
      for (int ctr = 1; ctr <= 9; ctr++) {
         tasks.Add(Task.Factory.StartNew( () => {
                                            int utf32 = 0;
                                            lock(rnd) {
                                               // Get UTF32 value.
                                               utf32 = rnd.Next(0, 0xE01F0);
                                            }
                                            // Convert it to a UTF16-encoded character.
                                            string utf16 = Char.ConvertFromUtf32(utf32);
                                            // Display information about the character.
                                            Console.WriteLine("0x{0:X8} --> '{1,2}' ({2})", 
                                                              utf32, utf16, ShowHex(utf16));
                                         }));                           
      }
      Task.WaitAll(tasks.ToArray()); 
   }

   private static string ShowHex(string value)
   {
      string hexString = null;
      // Handle only non-control characters.
      if (! Char.IsControl(value, 0)) {
         foreach (var ch in value)
            hexString += $"0x{(ushort)ch:X} ";
      }   
      return hexString.Trim();
   }
}
// The example displays the following output:
//       0x00097103 --> '򗄃' (0x55836 0x56579)
//       0x000A98A1 --> '򩢡' (0x55910 0x56481)
//       0x00050002 --> '񐀂' (0x55552 0x56322)
//       0x0000FEF1 --> 'ﻱ' (0x65265)
//       0x0008BC0A --> '򋰊' (0x55791 0x56330)
//       0x000860EA --> '򆃪' (0x55768 0x56554)
//       0x0009AC5A --> '򚱚' (0x55851 0x56410)
//       0x00053320 --> '񓌠' (0x55564 0x57120)
//       0x000874EF --> '򇓯' (0x55773 0x56559)

Imports System.Collections.Generic
Imports System.Threading.Tasks

Public Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim tasks As New List(Of Task)
      ' Execute the task 10 times.
      For ctr As Integer = 1 To 9
         tasks.Add(Task.Factory.StartNew(Sub()
                                            Dim utf32 As Integer
                                            SyncLock(rnd)
                                               ' Get UTF32 value.
                                               utf32 = rnd.Next(0, &hE01F0)
                                            End SyncLock
                                            ' Convert it to a UTF16-encoded character.
                                            Dim utf16 As String = Char.ConvertFromUtf32(utf32)
                                            ' Display information about the character.
                                            Console.WriteLine("0x{0:X8} --> '{1,2}' ({2})", 
                                                              utf32, utf16, ShowHex(utf16))
                                         End Sub))                           
      Next
      Task.WaitAll(tasks.ToArray()) 
   End Sub
   
   Private Function ShowHex(value As String) As String
      Dim hexString As String = Nothing
      ' Handle only non-control characters.
      If Not Char.IsControl(value, 0) Then
         For Each ch In value
            hexString += String.Format("0x{0} ", Convert.ToUInt16(ch))
         Next
      End If   
      Return hexString.Trim()
   End Function
End Module
' The example displays output similar to the following:
'       0x00097103 --> '򗄃' (0x55836 0x56579)
'       0x000A98A1 --> '򩢡' (0x55910 0x56481)
'       0x00050002 --> '񐀂' (0x55552 0x56322)
'       0x0000FEF1 --> 'ﻱ' (0x65265)
'       0x0008BC0A --> '򋰊' (0x55791 0x56330)
'       0x000860EA --> '򆃪' (0x55768 0x56554)
'       0x0009AC5A --> '򚱚' (0x55851 0x56410)
'       0x00053320 --> '񓌠' (0x55564 0x57120)
'       0x000874EF --> '򇓯' (0x55773 0x56559)

Remarques

L’appel StartNew équivaut à créer une tâche à l’aide de l’un de ses constructeurs, puis d’appeler la méthode pour planifier la Task.Start tâche pour l’exécution.

À compter de la .NET Framework 4.5, vous pouvez utiliser la Task.Run(Action) méthode comme moyen rapide d’appeler StartNew(Action) avec des paramètres par défaut. Notez toutefois qu’il existe une différence de comportement entre les deux méthodes concernant : Task.Run(Action) par défaut, les tâches enfants ne sont pas autorisées à commencer par l’option TaskCreationOptions.AttachedToParent à attacher à l’instance actuelle Task , tandis que StartNew(Action) cela. Pour plus d’informations et d’exemples de code, consultez Task.Run vs Task.Factory.StartNew dans la programmation parallèle avec le blog .NET.

Voir aussi

S’applique à

StartNew(Action<Object>, Object)

Crée et démarre une tâche pour le délégué et l’état d’action spécifiés.

public:
 System::Threading::Tasks::Task ^ StartNew(Action<System::Object ^> ^ action, System::Object ^ state);

public System.Threading.Tasks.Task StartNew (Action<object> action, object state);

public System.Threading.Tasks.Task StartNew (Action<object?> action, object? state);

member this.StartNew : Action<obj> * obj -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object) As Task

Paramètres

action: Action<Object>

Délégué d'action à exécuter de façon asynchrone.

state: Object

Objet contenant des données que le délégué action doit utiliser.

Retours

Task

Tâche démarrée.

Exceptions

ArgumentNullException

L'argument action a la valeur null.

Exemples

L’exemple suivant définit un tableau de mots de 6 lettres. Chaque mot est ensuite passé à un Action<T> délégué, qui se décrègue le mot et affiche le mot d’origine et sa version brouillée.

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

public class Example
{
   public static void Main()
   {
      var tasks = new List<Task>();
      Random rnd = new Random();
      Object lockObj = new Object();
      String[] words6 = { "reason", "editor", "rioter", "rental",
                          "senior", "regain", "ordain", "rained" };

      foreach (var word6 in words6)
         tasks.Add(Task.Factory.StartNew( (word) => { Char[] chars = word.ToString().ToCharArray();
                                                      double[] order = new double[chars.Length];
                                                      lock (lockObj) {
                                                         for (int ctr = 0; ctr < order.Length; ctr++)
                                                             order[ctr] = rnd.NextDouble();
                                                      }
                                                      Array.Sort(order, chars);
                                                      Console.WriteLine("{0} --> {1}", word,
                                                                        new String(chars));
                                                    }, word6));

      Task.WaitAll(tasks.ToArray());
   }
}
// The example displays output like the following:
//    regain --> irnaeg
//    ordain --> rioadn
//    reason --> soearn
//    rained --> rinade
//    rioter --> itrore
//    senior --> norise
//    rental --> atnerl
//    editor --> oteird

Imports System.Collections.Generic
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks As New List(Of Task)()
      Dim rnd As New Random()
      Dim lockObj As New Object()
      Dim words6() As String = { "reason", "editor", "rioter", "rental",
                                 "senior", "regain", "ordain", "rained" }

      For Each word6 in words6
         tasks.Add(Task.Factory.StartNew( Sub(word)
                                              Dim chars() As Char = word.ToString().ToCharArray()
                                              Dim order(chars.Length - 1) As Double
                                              SyncLock lockObj
                                                 For ctr As Integer = 0 To order.Length - 1
                                                    order(ctr) = rnd.NextDouble()
                                                 Next
                                              End SyncLock
                                              Array.Sort(order, chars)
                                              Console.WriteLine("{0} --> {1}", word,
                                                                new String(chars))
                                          End Sub, word6))
      Next
      Task.WaitAll(tasks.ToArray())
   End Sub
End Module
' The example displays output like the following:
'       regain --> irnaeg
'       ordain --> rioadn
'       reason --> soearn
'       rained --> rinade
'       rioter --> itrore
'       senior --> norise
'       rental --> atnerl
'       editor --> oteird

Notez que l’exemple initialise un seul générateur de nombres aléatoires, protégé par un verrou. Pour connaître le besoin d’un verrou, consultez « La classe System.Random et la sécurité des threads » dans la Random rubrique de classe.

Remarques

L’appel StartNew est fonctionnellement équivalent à la création d’un Task de ses constructeurs, puis à l’appel de la méthode pour la planifier pour l’exécution Start .

À compter de la .NET Framework 4.5, vous pouvez utiliser la Run méthode avec un Action objet comme moyen rapide d’appeler StartNew avec des paramètres par défaut. Pour plus d’informations et d’exemples de code, consultez Task.Run vs Task.Factory.StartNew dans la programmation parallèle avec le blog .NET.

Voir aussi

S’applique à

StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)

Crée et démarre une tâche de type TResult pour le délégué de fonction, le jeton d’annulation, les options de création et le planificateur de tâches spécifiés.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<TResult> ^ function, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<TResult> function, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.StartNew : Func<'Result> * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of TResult), cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task(Of TResult)

Paramètres de type

TResult

Type du résultat disponible via la tâche.

Paramètres

function: Func<TResult>

Délégué de fonction qui retourne le résultat à venir qui sera mis à disposition via la tâche.

cancellationToken: CancellationToken

Jeton d’annulation qui sera assigné à la nouvelle tâche.

creationOptions: TaskCreationOptions

L’une des valeurs d’énumération qui contrôlent le comportement de la tâche créée.

scheduler: TaskScheduler

Planificateur de tâche utilisé pour planifier la tâche de continuation créée.

Retours

Task<TResult>

Tâche démarrée.

Exceptions

ObjectDisposedException

Le CancellationToken fourni a déjà été supprimé.

ArgumentNullException

function a la valeur null.

-ou- scheduler a la valeur null.

ArgumentOutOfRangeException

Remarques

L’appel de StartNew est fonctionnellement équivalent à la création d’un Task<TResult> de ses constructeurs, puis à l’appel Start pour planifier son exécution.

À compter de la .NET Framework 4.5, vous pouvez utiliser la Run méthode avec un Action objet comme moyen rapide d’appeler StartNew avec des paramètres par défaut. Pour plus d’informations et des exemples de code, consultez l’entrée Task.Run et Task.Factory.StartNew dans le blog De programmation parallèle avec .NET.

Voir aussi

S’applique à

StartNew<TResult>(Func<TResult>)

Crée et démarre une tâche de type TResult pour le délégué de fonction spécifié.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<TResult> ^ function);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<TResult> function);

member this.StartNew : Func<'Result> -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of TResult)) As Task(Of TResult)

Paramètres de type

TResult

Type du résultat disponible via la tâche.

Paramètres

function: Func<TResult>

Délégué de fonction qui retourne le résultat à venir qui sera mis à disposition via la tâche.

Retours

Task<TResult>

Tâche démarrée.

Exceptions

ArgumentNullException

L'argument function a la valeur null.

Exemples

L’exemple suivant est une application d’ajout simple qui génère deux nombres aléatoires et invite l’utilisateur à entrer sa somme. Il indique ensuite si la réponse est correcte ou, si la réponse de l’utilisateur n’est pas un nombre valide, invite l’utilisateur à entrer à nouveau un nombre valide. Permet StartNew de créer les Task<TResult> objets qui retournent les nombres aléatoires à ajouter.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      Task<int>[] tasks = new Task<int>[2];
      Object obj = new Object();
      
      while (true) {
         for (int ctr = 0; ctr <= 1; ctr++)
            tasks[ctr] = Task.Factory.StartNew(() => { int i = 0;
                                                       lock(obj) {
                                                          i = rnd.Next(101);
                                                       }
                                                       return i; });

         Task.WaitAll(tasks);
         int n1 = tasks[0].Result;
         int n2 = tasks[1].Result;
         int result = n1 + n2;
         bool validInput = false;
         while (! validInput) {
            ShowMessage(n1, n2);
            string userInput = Console.ReadLine();
            // Process user input.
            if (userInput.Trim().ToUpper() == "X") return;
            int answer;
            validInput = Int32.TryParse(userInput, out answer);
            if (! validInput)
               Console.WriteLine("Invalid input. Try again, but enter only numbers. ");
            else if (answer == result)
               Console.WriteLine("Correct!");
            else
               Console.WriteLine("Incorrect. The correct answer is {0}.", result);
         }
      }
   }

   private static void ShowMessage(int n1, int n2)
   {
      Console.WriteLine("\nEnter 'x' to exit...");
      Console.Write("{0} + {1} = ", n1, n2);
   }
}
// The example displays the following output:
//       Enter 'x' to exit...
//       15 + 11 = 26
//       Correct!
//
//       Enter 'x' to exit...
//       75 + 33 = adc
//       Invalid input. Try again, but enter only numbers.
//
//       Enter 'x' to exit...
//       75 + 33 = 108
//       Correct!
//
//       Enter 'x' to exit...
//       67 + 55 = 133
//       Incorrect. The correct answer is 122.
//
//       Enter 'x' to exit...
//       92 + 51 = 133
//       Incorrect. The correct answer is 143.
//
//       Enter 'x' to exit...
//       81 + 65 = x

   
Imports System.Threading.Tasks

Module AdditionTester
   Public Sub Main()
      Dim rnd As New Random()
      Dim tasks(1) As Task(Of Integer)
      Dim obj As New Object()
      
      Do While True
         For ctr As Integer = 0 To 1
            tasks(ctr) = Task.Factory.StartNew(Function()
                                                  Dim i As Integer
                                                  SyncLock(obj)
                                                     i = rnd.Next(101)
                                                  End SyncLock
                                                  Return i
                                               End Function)
         Next
         Task.WaitAll(tasks)
         Dim n1 As Integer = tasks(0).Result
         Dim n2 As Integer = tasks(1).Result
         Dim result As Integer = n1 + n2
         Dim validInput As Boolean = False
         Do While Not validInput
            ShowMessage(n1, n2)
            Dim userInput As String = Console.ReadLine()
            ' Process user input.
            If userInput.Trim().ToUpper = "X" Then Exit Sub
            Dim answer As Integer
            validInput = Int32.TryParse(userInput, answer)
            If Not validInput Then
               Console.WriteLine("Invalid input. Try again, but enter only numbers. ")
            Else If answer = result Then
               Console.WriteLine("Correct!")
            Else
               Console.WriteLine("Incorrect. The correct answer is {0}.", result)
            End If
         Loop
      Loop
   End Sub
   
   Private Sub ShowMessage(n1 As Integer, n2 As Integer)
      Console.WriteLine()
      Console.WriteLine("Enter 'x' to exit...")
      Console.Write("{0} + {1} = ", n1, n2)
   End Sub
End Module
' The example displays output like the following:
'       Enter 'x' to exit...
'       15 + 11 = 26
'       Correct!
'
'       Enter 'x' to exit...
'       75 + 33 = adc
'       Invalid input. Try again, but enter only numbers.
'
'       Enter 'x' to exit...
'       75 + 33 = 108
'       Correct!
'
'       Enter 'x' to exit...
'       67 + 55 = 133
'       Incorrect. The correct answer is 122.
'
'       Enter 'x' to exit...
'       92 + 51 = 133
'       Incorrect. The correct answer is 143.
'
'       Enter 'x' to exit...
'       81 + 65 = x

Remarques

L’appel StartNew est fonctionnellement équivalent à la création d’un Task<TResult> de ses constructeurs, puis à l’appel Start pour planifier son exécution.

À compter de la .NET Framework 4.5, vous pouvez appeler la Task.Run<TResult>(Func<TResult>) méthode comme moyen rapide d’appeler StartNew avec les paramètres par défaut. Notez toutefois qu’il existe une différence de comportement entre les deux méthodes en ce qui concerne : Task.Run<TResult>(Func<TResult>) par défaut, les tâches enfants n’autorisent pas les tâches enfants démarrées avec l’option TaskCreationOptions.AttachedToParent à attacher à l’instance actuelle Task<TResult> , tandis que StartNew<TResult>(Func<TResult>) cela. Pour plus d’informations et des exemples de code, consultez l’entrée Task.Run et Task.Factory.StartNew dans le blog De programmation parallèle avec .NET.

Voir aussi

S’applique à

StartNew<TResult>(Func<Object,TResult>, Object)

Crée et démarre une tâche de type TResult pour le délégué de fonction et l’état spécifiés.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<System::Object ^, TResult> ^ function, System::Object ^ state);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object,TResult> function, object state);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object?,TResult> function, object? state);

member this.StartNew : Func<obj, 'Result> * obj -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object) As Task(Of TResult)

Paramètres de type

TResult

Type du résultat disponible via la tâche.

Paramètres

function: Func<Object,TResult>

Délégué de fonction qui retourne le résultat à venir qui sera mis à disposition via la tâche.

state: Object

Objet contenant des données que le délégué function doit utiliser.

Retours

Task<TResult>

Tâche démarrée.

Exceptions

ArgumentNullException

function a la valeur null.

Remarques

L’appel de StartNew est fonctionnellement équivalent à la création d’un Task<TResult> de ses constructeurs, puis à l’appel Start pour planifier son exécution.

À compter de la .NET Framework 4.5, vous pouvez utiliser la Run méthode avec un Action objet comme moyen rapide d’appeler StartNew avec des paramètres par défaut. Pour plus d’informations et des exemples de code, consultez l’entrée Task.Run et Task.Factory.StartNew dans le blog De programmation parallèle avec .NET.

Voir aussi

S’applique à

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

Crée et démarre une tâche de type TResult pour le délégué de fonction et le jeton d’annulation spécifiés.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<TResult> ^ function, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<TResult> function, System.Threading.CancellationToken cancellationToken);

member this.StartNew : Func<'Result> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of TResult), cancellationToken As CancellationToken) As Task(Of TResult)

Paramètres de type

TResult

Type du résultat disponible via la tâche.

Paramètres

function: Func<TResult>

Délégué de fonction qui retourne le résultat à venir qui sera mis à disposition via la tâche.

cancellationToken: CancellationToken

Jeton d’annulation qui sera assigné à la nouvelle tâche.

Retours

Task<TResult>

Tâche démarrée.

Exceptions

ObjectDisposedException

Le CancellationToken fourni a déjà été supprimé.

ArgumentNullException

function a la valeur null.

Exemples

L’exemple suivant utilise deux tâches pour calculer la séquence Fibonacci se terminant par F100 = F100-1 + F100-2 avec les valeurs initiales F1= 1, F2 = 1 et F1 = 0, F2 = 1. Environ la moitié du temps, un jeton d’annulation est défini à mesure que les opérations s’exécutent. La sortie de l’exemple montre le résultat si les deux tâches se terminent correctement et si le jeton est annulé.

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

public class Example
{
   public static void Main()
   {
      var rnd = new Random();
      var tasks = new List<Task<BigInteger[]>>();
      var source = new CancellationTokenSource();
      var token = source.Token;
      for (int ctr = 0; ctr <= 1; ctr++) {
         int start = ctr;
         tasks.Add(Task.Run( () => { BigInteger[] sequence = new BigInteger[100];
                                     sequence[0] = start;
                                     sequence[1] = 1;
                                     for (int index = 2; index <= sequence.GetUpperBound(0); index++) {
                                        token.ThrowIfCancellationRequested();
                                        sequence[index] = sequence[index - 1] + sequence[index - 2];
                                     }
                                     return sequence;
                                   }, token));
      }
      if (rnd.Next(0, 2) == 1)
         source.Cancel();
      try {
         Task.WaitAll(tasks.ToArray());
         foreach (var t in tasks)
            Console.WriteLine("{0}, {1}...{2:N0}", t.Result[0], t.Result[1],
                              t.Result[99]);
      }
      catch (AggregateException e) {
         foreach (var ex in e.InnerExceptions)
            Console.WriteLine("{0}: {1}", ex.GetType().Name, ex.Message);
      }
   }
}
// The example displays either the following output:
//    0, 1...218,922,995,834,555,169,026
//    1, 1...354,224,848,179,261,915,075
// or the following output:
//    TaskCanceledException: A task was canceled.
//    TaskCanceledException: A task was canceled.

Imports System.Collections.Generic
Imports System.Numerics
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim tasks As New List(Of Task(Of BigInteger()))
      Dim source As New CancellationTokenSource
      Dim token As CancellationToken = source.Token
      For ctr As Integer = 0 To 1
         Dim start As Integer = ctr
         tasks.Add(Task.Run(Function()
                               Dim sequence(99) As BigInteger
                               sequence(0) = start
                               sequence(1) = 1
                               For index As Integer = 2 To sequence.GetUpperBound(0)
                                  token.ThrowIfCancellationRequested()
                                  sequence(index) = sequence(index - 1) + sequence(index - 2)
                               Next
                               Return sequence
                            End Function, token))
      Next
      If rnd.Next(0, 2) = 1 Then source.Cancel
      Try
         Task.WaitAll(tasks.ToArray())
         For Each t In tasks
            Console.WriteLine("{0}, {1}...{2:N0}", t.Result(0), t.Result(1),
                              t.Result(99))
         Next
      Catch e As AggregateException
         For Each ex In e.InnerExceptions
            Console.WriteLine("{0}: {1}", ex.GetType().Name, ex.Message)
         Next
      End Try
   End Sub
End Module
' The example displays either the following output:
'    0, 1...218,922,995,834,555,169,026
'    1, 1...354,224,848,179,261,915,075
' or the following output:
'    TaskCanceledException: A task was canceled.
'    TaskCanceledException: A task was canceled.

Remarques

L’appel StartNew est fonctionnellement équivalent à la création d’un Task<TResult> de ses constructeurs, puis à l’appel Start pour planifier son exécution.

À compter de la .NET Framework 4.5, vous pouvez utiliser la Task.Run<TResult>(Func<TResult>, CancellationToken) méthode comme moyen rapide d’appeler StartNew<TResult>(Func<TResult>, CancellationToken) avec des paramètres par défaut. Notez toutefois qu’il existe une différence de comportement entre les deux méthodes en ce qui concerne : Task.Run<TResult>(Func<TResult>, CancellationToken) par défaut, les tâches enfants n’autorisent pas les tâches enfants démarrées avec l’option TaskCreationOptions.AttachedToParent à attacher à l’instance actuelle Task<TResult> , tandis que StartNew<TResult>(Func<TResult>, CancellationToken) cela. Pour plus d’informations et des exemples de code, consultez l’entrée Task.Run et Task.Factory.StartNew dans le blog De programmation parallèle avec .NET.

Voir aussi

S’applique à

StartNew<TResult>(Func<TResult>, TaskCreationOptions)

Crée et démarre une tâche de type TResult pour le délégué de fonction et les options de création spécifiés.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<TResult> ^ function, System::Threading::Tasks::TaskCreationOptions creationOptions);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<TResult> function, System.Threading.Tasks.TaskCreationOptions creationOptions);

member this.StartNew : Func<'Result> * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of TResult), creationOptions As TaskCreationOptions) As Task(Of TResult)

Paramètres de type

TResult

Type du résultat disponible via la tâche.

Paramètres

function: Func<TResult>

Délégué de fonction qui retourne le résultat à venir qui sera mis à disposition via la tâche.

creationOptions: TaskCreationOptions

L’une des valeurs d’énumération qui contrôlent le comportement de la tâche créée.

Retours

Task<TResult>

Tâche démarrée.

Exceptions

ArgumentNullException

function a la valeur null.

ArgumentOutOfRangeException

Remarques

L’appel de StartNew est fonctionnellement équivalent à la création d’un Task<TResult> de ses constructeurs, puis à l’appel Start pour planifier son exécution.

À compter de la .NET Framework 4.5, vous pouvez utiliser la Run méthode avec un Action objet comme moyen rapide d’appeler StartNew avec des paramètres par défaut. Pour plus d’informations et des exemples de code, consultez l’entrée Task.Run et Task.Factory.StartNew dans le blog De programmation parallèle avec .NET.

Voir aussi

S’applique à

StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken)

Crée et démarre une tâche de type TResult pour le délégué de fonction, l’état et le jeton d’annulation spécifiés.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<System::Object ^, TResult> ^ function, System::Object ^ state, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object,TResult> function, object state, System.Threading.CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object?,TResult> function, object? state, System.Threading.CancellationToken cancellationToken);

member this.StartNew : Func<obj, 'Result> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object, cancellationToken As CancellationToken) As Task(Of TResult)

Paramètres de type

TResult

Type du résultat disponible via la tâche.

Paramètres

function: Func<Object,TResult>

Délégué de fonction qui retourne le résultat à venir qui sera mis à disposition via la tâche.

state: Object

Objet contenant des données que le délégué function doit utiliser.

cancellationToken: CancellationToken

Jeton d’annulation qui sera assigné à la nouvelle tâche.

Retours

Task<TResult>

Tâche démarrée.

Exceptions

ObjectDisposedException

Le CancellationToken fourni a déjà été supprimé.

ArgumentNullException

function a la valeur null.

Remarques

L’appel de StartNew est fonctionnellement équivalent à la création d’un Task<TResult> de ses constructeurs, puis à l’appel Start pour planifier son exécution.

À compter de la .NET Framework 4.5, vous pouvez utiliser la Run méthode avec un Action objet comme moyen rapide d’appeler StartNew avec des paramètres par défaut. Pour plus d’informations et des exemples de code, consultez l’entrée Task.Run et Task.Factory.StartNew dans le blog De programmation parallèle avec .NET.

Voir aussi

S’applique à

StartNew<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)

Crée et démarre une tâche de type TResult pour le délégué de fonction, l’état et les options de création spécifiés.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<System::Object ^, TResult> ^ function, System::Object ^ state, System::Threading::Tasks::TaskCreationOptions creationOptions);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object,TResult> function, object state, System.Threading.Tasks.TaskCreationOptions creationOptions);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object?,TResult> function, object? state, System.Threading.Tasks.TaskCreationOptions creationOptions);

member this.StartNew : Func<obj, 'Result> * obj * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object, creationOptions As TaskCreationOptions) As Task(Of TResult)

Paramètres de type

TResult

Type du résultat disponible via la tâche.

Paramètres

function: Func<Object,TResult>

Délégué de fonction qui retourne le résultat à venir qui sera mis à disposition via la tâche.

state: Object

Objet contenant des données que le délégué function doit utiliser.

creationOptions: TaskCreationOptions

L’une des valeurs d’énumération qui contrôlent le comportement de la tâche créée.

Retours

Task<TResult>

Tâche démarrée.

Exceptions

ArgumentNullException

function a la valeur null.

ArgumentOutOfRangeException

Remarques

L’appel de StartNew est fonctionnellement équivalent à la création d’un Task<TResult> de ses constructeurs, puis à l’appel Start pour planifier son exécution.

À compter de la .NET Framework 4.5, vous pouvez utiliser la Run méthode avec un Action objet comme moyen rapide d’appeler StartNew avec des paramètres par défaut. Pour plus d’informations et des exemples de code, consultez l’entrée Task.Run et Task.Factory.StartNew dans le blog De programmation parallèle avec .NET.

Voir aussi

S’applique à

StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)

Crée et démarre une tâche de type TResult pour le délégué de fonction, l’état, le jeton d’annulation, les options de création et le planificateur de tâches spécifiés.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<System::Object ^, TResult> ^ function, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object,TResult> function, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object?,TResult> function, object? state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.StartNew : Func<obj, 'Result> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task(Of TResult)

Paramètres de type

TResult

Type du résultat disponible via la tâche.

Paramètres

function: Func<Object,TResult>

Délégué de fonction qui retourne le résultat à venir qui sera mis à disposition via la tâche.

state: Object

Objet contenant des données que le délégué function doit utiliser.

cancellationToken: CancellationToken

Jeton d’annulation qui sera assigné à la nouvelle tâche.

creationOptions: TaskCreationOptions

L’une des valeurs d’énumération qui contrôlent le comportement de la tâche créée.

scheduler: TaskScheduler

Planificateur de tâche utilisé pour planifier la tâche de continuation créée.

Retours

Task<TResult>

Tâche démarrée.

Exceptions

ObjectDisposedException

Le CancellationToken fourni a déjà été supprimé.

ArgumentNullException

function a la valeur null.

-ou- scheduler a la valeur null.

ArgumentOutOfRangeException

Remarques

L’appel de StartNew est fonctionnellement équivalent à la création d’un Task<TResult> de ses constructeurs, puis à l’appel Start pour planifier son exécution.

À compter de la .NET Framework 4.5, vous pouvez utiliser la Run méthode avec un Action objet comme moyen rapide d’appeler StartNew avec des paramètres par défaut. Pour plus d’informations et des exemples de code, consultez l’entrée Task.Run et Task.Factory.StartNew dans le blog De programmation parallèle avec .NET.

Voir aussi

S’applique à

Partager via

TaskFactory.StartNew Méthode

Définition

Surcharges

Remarques

StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)

Paramètres

Retours

Exceptions

Remarques

Voir aussi

S’applique à

StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)

Paramètres

Retours

Exceptions

Remarques

Voir aussi

S’applique à

StartNew(Action<Object>, Object, TaskCreationOptions)

Paramètres

Retours

Exceptions

Remarques

Voir aussi

S’applique à

StartNew(Action<Object>, Object, CancellationToken)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

StartNew(Action, CancellationToken)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

StartNew(Action, TaskCreationOptions)

Paramètres

Retours

Exceptions

Remarques

Voir aussi

S’applique à

StartNew(Action)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

StartNew(Action<Object>, Object)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)

Paramètres de type

Paramètres

Retours

Exceptions

Remarques

Voir aussi

S’applique à

StartNew<TResult>(Func<TResult>)

Paramètres de type

Paramètres

Retours

Exceptions

Exemples

Remarques