Task<TResult> Constructeurs

public:
 Task(Func<TResult> ^ function);

public Task(Func<TResult> function);

new System.Threading.Tasks.Task<'Result> : Func<'Result> -> System.Threading.Tasks.Task<'Result>

Public Sub New (function As Func(Of TResult))

Paramètres

Exceptions

Exemples

L’exemple suivant compte le nombre approximatif de mots dans les fichiers texte qui représentent des livres publiés. Chaque tâche est chargée d’ouvrir un fichier, de lire son contenu entier de façon asynchrone et de calculer le nombre de mots à l’aide d’une expression régulière. La Task.WaitAll(Task[]) méthode est appelée pour s’assurer que toutes les tâches ont été effectuées avant d’afficher le nombre de mots de chaque livre dans la console.

L’instanciation d’objet est séparée de l’exécution d’objets dans cet exemple afin que l’exemple puisse s’assurer que chaque fichier existe. Si ce n’est pas le cas, il affiche le nom du fichier manquant. Sinon, il appelle la Task.Start méthode pour lancer chaque tâche.

using System;
using System.IO;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

public class Example
{
   public static async Task Main()
   {
      string pattern = @"\p{P}*\s+";
      string[] titles = { "Sister Carrie", "The Financier" };
      Task<int>[] tasks = new Task<int>[titles.Length];

      for (int ctr = 0; ctr < titles.Length; ctr++) {
         string s = titles[ctr];
         tasks[ctr] = new Task<int>( () => {
                                   // Number of words.
                                   int nWords = 0;
                                   // Create filename from title.
                                   string fn = s + ".txt";

                                   StreamReader sr = new StreamReader(fn);
                                   string input = sr.ReadToEndAsync().Result;
                                   sr.Close();
                                   nWords = Regex.Matches(input, pattern).Count;
                                   return nWords;
                                } );
      }
      // Ensure files exist before launching tasks.
      bool allExist = true;
      foreach (var title in titles) {
         string fn = title + ".txt";
         if (!File.Exists(fn)) {
            allExist = false;
            Console.WriteLine("Cannot find '{0}'", fn);
            break;
         }   
      }
      // Launch tasks 
      if (allExist) {
         foreach (var t in tasks)
            t.Start();
      
        await Task.WhenAll(tasks);
  
        Console.WriteLine("Word Counts:\n");
        for (int ctr = 0; ctr < titles.Length; ctr++)
           Console.WriteLine("{0}: {1,10:N0} words", titles[ctr], tasks[ctr].Result);
      }   
   }
}
// The example displays the following output:
//       Sister Carrie:    159,374 words
//       The Financier:    196,362 words

Imports System.IO
Imports System.Text.RegularExpressions
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim pattern As String = "\p{P}*\s+"
      Dim titles() As String = { "Sister Carrie",
                                 "The Financier" }
      Dim tasks(titles.Length - 1) As Task(Of Integer)

      For ctr As Integer = 0 To titles.Length - 1
         Dim s As String = titles(ctr)
         tasks(ctr) = New Task(Of Integer)( Function()
                                   ' Number of words.
                                   Dim nWords As Integer = 0
                                   ' Create filename from title.
                                   Dim fn As String = s + ".txt"

                                   Dim sr As New StreamReader(fn)
                                   Dim input As String = sr.ReadToEndAsync().Result
                                   sr.Close()
                                   nWords = Regex.Matches(input, pattern).Count
                                   Return nWords
                                End Function)
      Next

      ' Ensure files exist before launching tasks.
      Dim allExist As Boolean = True
      For Each title In titles
         Dim fn As String = title + ".txt"
         If Not File.Exists(fn) Then
            allExist = false
            Console.WriteLine("Cannot find '{0}'", fn)
            Exit For
         End If   
      Next
      ' Launch tasks 
      If allExist Then
         For Each t in tasks
            t.Start()
         Next
         Task.WaitAll(tasks)

         Console.WriteLine("Word Counts:")
         Console.WriteLine()
         For ctr As Integer = 0 To titles.Length - 1
         Console.WriteLine("{0}: {1,10:N0} words", titles(ctr), tasks(ctr).Result)
         Next
      End If   
   End Sub
End Module
' The example displays the following output:
'       Sister Carrie:    159,374 words
'       The Financier:    196,362 words

Le modèle \p{P}*\s+ d’expression régulière correspond à zéro, un ou plusieurs caractères de ponctuation suivis d’un ou plusieurs caractères d’espace blanc. Il suppose que le nombre total de correspondances est égal au nombre approximatif de mots.

Remarques

Ce constructeur ne doit être utilisé que dans les scénarios avancés où il est nécessaire que la création et le démarrage de la tâche soient séparés.

Au lieu d’appeler ce constructeur, le moyen le plus courant d’instancier un Task<TResult> objet et de lancer une tâche consiste à appeler les méthodes et TaskFactory<TResult>.StartNew(Func<TResult>) statiquesTask.Run<TResult>(Func<TResult>).

Si une tâche sans action n’est nécessaire que pour que le consommateur d’une API ait quelque chose à attendre, il TaskCompletionSource<TResult> doit être utilisé.

Voir aussi

• Bibliothèque parallèle de tâches (TPL)
• Programmation asynchrone basée sur des tâches

public:
 Task(Func<System::Object ^, TResult> ^ function, System::Object ^ state);

public Task(Func<object,TResult> function, object state);

new System.Threading.Tasks.Task<'Result> : Func<obj, 'Result> * obj -> System.Threading.Tasks.Task<'Result>

Public Sub New (function As Func(Of Object, TResult), state As Object)

Paramètres

Exceptions

Remarques

Au lieu d’appeler ce constructeur, la méthode la plus courante pour instancier un Task<TResult> objet et lancer une tâche consiste à appeler la méthode statique TaskFactory<TResult>.StartNew(Func<Object,TResult>, Object) . Le seul avantage offert par ce constructeur est qu’il permet à l’instanciation d’objet d’être séparée de l’appel de tâche.

Voir aussi

• Bibliothèque parallèle de tâches (TPL)
• Programmation asynchrone basée sur des tâches

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

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

new System.Threading.Tasks.Task<'Result> : Func<'Result> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Sub New (function As Func(Of TResult), cancellationToken As CancellationToken)

Paramètres

Exceptions

Remarques

Au lieu d’appeler ce constructeur, le moyen le plus courant d’instancier un Task<TResult> objet et de lancer une tâche consiste à appeler les méthodes et TaskFactory<TResult>.StartNew(Func<TResult>, CancellationToken) statiquesTask.Run<TResult>(Func<TResult>, CancellationToken). Le seul avantage offert par ce constructeur est qu’il permet à l’instanciation d’objet d’être séparée de l’appel de tâche.

Voir aussi

• Bibliothèque parallèle de tâches (TPL)
• Programmation asynchrone basée sur des tâches

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

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

new System.Threading.Tasks.Task<'Result> : Func<'Result> * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task<'Result>

Public Sub New (function As Func(Of TResult), creationOptions As TaskCreationOptions)

Paramètres

Exceptions

Remarques

Au lieu d’appeler ce constructeur, la méthode la plus courante pour instancier un Task<TResult> objet et lancer une tâche consiste à appeler la méthode statique TaskFactory<TResult>.StartNew(Func<TResult>, TaskCreationOptions) . Le seul avantage offert par ce constructeur est qu’il permet à l’instanciation d’objet d’être séparée de l’appel de tâche.

Voir aussi

• Bibliothèque parallèle de tâches (TPL)
• Programmation asynchrone basée sur des tâches

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

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

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

Public Sub New (function As Func(Of Object, TResult), state As Object, cancellationToken As CancellationToken)

Paramètres

Exceptions

Remarques

Au lieu d’appeler ce constructeur, la méthode la plus courante pour instancier un Task<TResult> objet et lancer une tâche consiste à appeler la méthode statique TaskFactory<TResult>.StartNew(Func<Object,TResult>, Object, CancellationToken) . Le seul avantage offert par ce constructeur est qu’il permet à l’instanciation d’objet d’être séparée de l’appel de tâche.

Voir aussi

• Bibliothèque parallèle de tâches (TPL)
• Programmation asynchrone basée sur des tâches

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

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

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

Public Sub New (function As Func(Of Object, TResult), state As Object, creationOptions As TaskCreationOptions)

Paramètres

Exceptions

Remarques

Au lieu d’appeler ce constructeur, la méthode la plus courante pour instancier un Task<TResult> objet et lancer une tâche consiste à appeler la méthode statique TaskFactory<TResult>.StartNew(Func<Object,TResult>, Object, TaskCreationOptions) . Le seul avantage offert par ce constructeur est qu’il permet à l’instanciation d’objet d’être séparée de l’appel de tâche.

Voir aussi

• Bibliothèque parallèle de tâches (TPL)
• Programmation asynchrone basée sur des tâches

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

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

new System.Threading.Tasks.Task<'Result> : Func<'Result> * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task<'Result>

Public Sub New (function As Func(Of TResult), cancellationToken As CancellationToken, creationOptions As TaskCreationOptions)

Paramètres

Exceptions

Remarques

Au lieu d’appeler ce constructeur, la méthode la plus courante pour instancier un Task<TResult> objet et lancer une tâche consiste à appeler la méthode statique TaskFactory.StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler) . Le seul avantage offert par ce constructeur est qu’il permet à l’instanciation d’objet d’être séparée de l’appel de tâche.

Voir aussi

• Bibliothèque parallèle de tâches (TPL)
• Programmation asynchrone basée sur des tâches

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

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

new System.Threading.Tasks.Task<'Result> : Func<obj, 'Result> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task<'Result>

Public Sub New (function As Func(Of Object, TResult), state As Object, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions)

Paramètres

Exceptions

Remarques

Au lieu d’appeler ce constructeur, la méthode la plus courante pour instancier un Task<TResult> objet et lancer une tâche consiste à appeler la méthode statique TaskFactory<TResult>.StartNew(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler) . Le seul avantage offert par ce constructeur est qu’il permet à l’instanciation d’objet d’être séparée de l’appel de tâche.

Voir aussi

• Bibliothèque parallèle de tâches (TPL)
• Programmation asynchrone basée sur des tâches