Task<TResult> Constructors

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))

Parameters

Uitzonderingen

Voorbeelden

In het volgende voorbeeld wordt het geschatte aantal woorden in tekstbestanden geteld dat gepubliceerde boeken vertegenwoordigt. Elke taak is verantwoordelijk voor het openen van een bestand, het asynchroon lezen van de volledige inhoud en het berekenen van het aantal woorden met behulp van een reguliere expressie. De Task.WaitAll(Task[]) methode wordt aangeroepen om ervoor te zorgen dat alle taken zijn voltooid voordat het aantal woorden van elk boek naar de console wordt weergegeven.

Object instantiëring wordt gescheiden van objectuitvoering in dit voorbeeld, zodat het voorbeeld ervoor kan zorgen dat elk bestand bestaat. Als dat niet zo is, wordt de naam van het ontbrekende bestand weergegeven. Anders wordt de Task.Start methode aangeroepen om elke taak te starten.

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

Het reguliere expressiepatroon \p{P}*\s+ komt overeen met nul, één of meer interpunctietekens, gevolgd door een of meer spatietekens. Hierbij wordt ervan uitgegaan dat het totale aantal overeenkomsten gelijk is aan het geschatte aantal woorden.

Opmerkingen

Deze constructor mag alleen worden gebruikt in geavanceerde scenario's waarbij vereist is dat het maken en starten van de taak wordt gescheiden.

In plaats van deze constructor aan te roepen, is de meest voorkomende manier om een Task<TResult> object te instantiëren en een taak te starten door de statische Task.Run<TResult>(Func<TResult>) en TaskFactory<TResult>.StartNew(Func<TResult>) methoden aan te roepen.

Als een taak zonder actie alleen nodig is voor de consument van een API om iets te wachten, moet een TaskCompletionSource<TResult> taak worden gebruikt.

Zie ook

• Taakparallelbibliotheek (TPL)
• Asynchrone programmering op basis van taken

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)

Parameters

Uitzonderingen

Opmerkingen

In plaats van deze constructor aan te roepen, is de meest voorkomende manier om een Task<TResult> object te instantiëren en een taak te starten door de statische TaskFactory<TResult>.StartNew(Func<Object,TResult>, Object) methode aan te roepen. Het enige voordeel dat door deze constructor wordt geboden, is dat object-instantiëring kan worden gescheiden van aanroepen van taken.

Zie ook

• Taakparallelbibliotheek (TPL)
• Asynchrone programmering op basis van taken

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)

Parameters

Uitzonderingen

Opmerkingen

In plaats van deze constructor aan te roepen, is de meest voorkomende manier om een Task<TResult> object te instantiëren en een taak te starten door de statische Task.Run<TResult>(Func<TResult>, CancellationToken) en TaskFactory<TResult>.StartNew(Func<TResult>, CancellationToken) methoden aan te roepen. Het enige voordeel dat door deze constructor wordt geboden, is dat object-instantiëring kan worden gescheiden van aanroepen van taken.

Zie ook

• Taakparallelbibliotheek (TPL)
• Asynchrone programmering op basis van taken

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)

Parameters

Uitzonderingen

Opmerkingen

In plaats van deze constructor aan te roepen, is de meest voorkomende manier om een Task<TResult> object te instantiëren en een taak te starten door de statische TaskFactory<TResult>.StartNew(Func<TResult>, TaskCreationOptions) methode aan te roepen. Het enige voordeel dat door deze constructor wordt geboden, is dat object-instantiëring kan worden gescheiden van aanroepen van taken.

Zie ook

• Taakparallelbibliotheek (TPL)
• Asynchrone programmering op basis van taken

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)

Parameters

Uitzonderingen

Opmerkingen

In plaats van deze constructor aan te roepen, is de meest voorkomende manier om een Task<TResult> object te instantiëren en een taak te starten door de statische TaskFactory<TResult>.StartNew(Func<Object,TResult>, Object, CancellationToken) methode aan te roepen. Het enige voordeel dat door deze constructor wordt geboden, is dat object-instantiëring kan worden gescheiden van aanroepen van taken.

Zie ook

• Taakparallelbibliotheek (TPL)
• Asynchrone programmering op basis van taken

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)

Parameters

Uitzonderingen

Opmerkingen

In plaats van deze constructor aan te roepen, is de meest voorkomende manier om een Task<TResult> object te instantiëren en een taak te starten door de statische TaskFactory<TResult>.StartNew(Func<Object,TResult>, Object, TaskCreationOptions) methode aan te roepen. Het enige voordeel dat door deze constructor wordt geboden, is dat object-instantiëring kan worden gescheiden van aanroepen van taken.

Zie ook

• Taakparallelbibliotheek (TPL)
• Asynchrone programmering op basis van taken

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)

Parameters

Uitzonderingen

Opmerkingen

In plaats van deze constructor aan te roepen, is de meest voorkomende manier om een Task<TResult> object te instantiëren en een taak te starten door de statische TaskFactory.StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler) methode aan te roepen. Het enige voordeel dat door deze constructor wordt geboden, is dat object-instantiëring kan worden gescheiden van aanroepen van taken.

Zie ook

• Taakparallelbibliotheek (TPL)
• Asynchrone programmering op basis van taken

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)

Parameters

Uitzonderingen

Opmerkingen

In plaats van deze constructor aan te roepen, is de meest voorkomende manier om een Task<TResult> object te instantiëren en een taak te starten door de statische TaskFactory<TResult>.StartNew(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler) methode aan te roepen. Het enige voordeel dat door deze constructor wordt geboden, is dat object-instantiëring kan worden gescheiden van aanroepen van taken.

Zie ook

• Taakparallelbibliotheek (TPL)
• Asynchrone programmering op basis van taken