TaskFactory<TResult> Klas

Definitie

generic <typename TResult>
public ref class TaskFactory

public class TaskFactory<TResult>

type TaskFactory<'Result> = class

Public Class TaskFactory(Of TResult)

Type parameters

Overname

Object

TaskFactory<TResult>

Voorbeelden

In het volgende voorbeeld wordt de statische Factory eigenschap gebruikt om twee aanroepen naar de TaskFactory<TResult>.StartNew methode uit te voeren. De eerste taak retourneert een tekenreeksmatrix die is gevuld met de namen van bestanden in de map MyDocuments van de gebruiker, terwijl de tweede een tekenreeksmatrix retourneert die is gevuld met de namen van submappen van de map MyDocuments van de gebruiker. Vervolgens wordt de TaskFactory.ContinueWhenAll(Task[], Action<Task[]>) methode aangeroepen, die informatie weergeeft over het aantal bestanden en mappen in de matrices die worden geretourneerd door de twee taken nadat ze de uitvoering hebben voltooid.

using System;
using System.IO;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task<string[]>[] tasks = new Task<string[]>[2];
      String docsDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

      tasks[0] = Task<string[]>.Factory.StartNew( () => Directory.GetFiles(docsDirectory));
      tasks[1] = Task<string[]>.Factory.StartNew( () => Directory.GetDirectories(docsDirectory));

      Task.Factory.ContinueWhenAll(tasks, completedTasks => {
                                             Console.WriteLine("{0} contains: ", docsDirectory);
                                             Console.WriteLine("   {0} subdirectories", tasks[1].Result.Length);
                                             Console.WriteLine("   {0} files", tasks[0].Result.Length);
                                          } );
   }
}
// The example displays output like the following:
//       C:\Users\<username>\Documents contains:
//          24 subdirectories
//          16 files

Imports System.IO
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks(1) As Task(Of String())
      Dim docsDirectory As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
      
      tasks(0) = Task(Of String()).Factory.StartNew( Function()Directory.GetFiles(docsDirectory) )
''                                        End Sub )
      tasks(1) = Task(Of String()).Factory.StartNew( Function() Directory.GetDirectories(docsDirectory) )
''                                        End Sub )
      Task.Factory.ContinueWhenAll(tasks, Sub(completedTasks)
                                             Console.WriteLine("{0} contains: ", docsDirectory)
                                             Console.WriteLine("   {0} subdirectories", tasks(1).Result.Length)
                                             Console.WriteLine("   {0} files", tasks(0).Result.Length)
                                          End Sub)
   End Sub
End Module
' The example displays output like the following:
'       C:\Users\<username>\Documents contains:
'          24 subdirectories
'          16 files

Opmerkingen

.NET biedt twee factory's voor het maken en plannen van taken:

• De TaskFactory klasse, die objecten maakt en Task<TResult> objecten maaktTask.

• De TaskFactory<TResult> klasse, waarmee objecten worden gemaakt Task<TResult> .

Met de TaskFactory<TResult> klasse kunt u het volgende doen:

• Maak een taak en start deze onmiddellijk door de StartNew methode aan te roepen. U kunt de overbelastingen van deze methode aanroepen om een taak te maken en uit te voeren waarvoor niet-standaardargumenten zijn vereist.

  Warning

  Vanaf .NET Framework 4.5 biedt de methode Task.Run de eenvoudigste manier om een taak te maken met standaardconfiguratiewaarden en deze onmiddellijk te starten.

• Maak een taak die begint wanneer een van de taken in een matrix is voltooid door de of ContinueWhenAny methode aan te ContinueWhenAny roepen.

• Maak een taak die begint wanneer alle taken in een matrix zijn voltooid door de of ContinueWhenAll methode aan te ContinueWhenAll roepen.

De statische Task<TResult>.Factory eigenschap retourneert een standaardobject TaskFactory<TResult> . U kunt ook een van de TaskFactory<TResult> klasseconstructors aanroepen om de Task<TResult> objecten te configureren die door de TaskFactory<TResult> klasse worden gemaakt. In het volgende voorbeeld wordt een nieuw TaskFactory<TResult> object geconfigureerd voor het maken van taken met een opgegeven annuleringstoken, opties voor het maken van taken, vervolgopties en een aangepaste taakplanner.

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

public class Example
{
   static CancellationTokenSource cts = new CancellationTokenSource();

   static TaskFactory<int> factory = new TaskFactory<int>(
      cts.Token,
      TaskCreationOptions.PreferFairness,
      TaskContinuationOptions.ExecuteSynchronously,
      new CustomScheduler());

   static void Main()
   {
      var t2 = factory.StartNew(() => DoWork());
      cts.Dispose();
   }

   static int DoWork()
   {
       /*...*/
       return DateTime.Now.Hour <= 12 ?  1 : 2;
    }
}

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

Module Example
   Public Sub Main()
      Dim cts As New CancellationTokenSource()
      Dim factory As New TaskFactory(Of Integer)(
                         cts.Token,
                         TaskCreationOptions.PreferFairness,
                         TaskContinuationOptions.ExecuteSynchronously,
                         New CustomScheduler())

      Dim t2 = factory.StartNew(Function() DoWork())
      cts.Dispose()
   End Sub

   Function DoWork() As Integer
      Return If(Date.Now.Hour <= 12, 1, 2)
   End Function
End Module

In de meeste gevallen hoeft u geen instantie van een nieuw TaskFactory<TResult> exemplaar te maken. In plaats daarvan kunt u de statische Task<TResult>.Factory eigenschap gebruiken, die een fabrieksobject retourneert dat gebruikmaakt van standaardwaarden. Vervolgens kunt u de methoden aanroepen om nieuwe taken te starten of taakvervolgingen te definiëren. Zie het voorbeeld voor een afbeelding.

Veiligheid thread

Alle openbare en beveiligde leden van TaskFactory<TResult> zijn thread-veilig en kunnen gelijktijdig worden gebruikt vanuit meerdere threads.

Zie ook

• Taakparallelbibliotheek (TPL)