TaskFactory<TResult> Klasse

Definition

generic <typename TResult>
public ref class TaskFactory

public class TaskFactory<TResult>

type TaskFactory<'Result> = class

Public Class TaskFactory(Of TResult)

Typparameter

Vererbung

Object

TaskFactory<TResult>

Beispiele

Im folgenden Beispiel wird die statische Factory Eigenschaft verwendet, um zwei Aufrufe an die TaskFactory<TResult>.StartNew Methode vorzunehmen. Der erste Vorgang gibt ein Zeichenfolgenarray zurück, das mit den Namen von Dateien im Verzeichnis "MyDocuments" des Benutzers gefüllt wird, während der zweite ein Zeichenfolgenarray zurückgibt, das mit den Namen von Unterverzeichnissen des Ordners "MyDocuments" des Benutzers gefüllt wird. Anschließend wird die TaskFactory.ContinueWhenAll(Task[], Action<Task[]>) Methode aufgerufen, die Informationen über die Anzahl der Dateien und Verzeichnisse in den von den beiden Vorgängen zurückgegebenen Arrays anzeigt, nachdem sie die Ausführung abgeschlossen haben.

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

Hinweise

.NET bietet zwei Fabriken zum Erstellen und Planen von Aufgaben:

• Die TaskFactory Klasse, die erstellt und Objekte erstellt und Task<TResult> objekte erstelltTask.

• Die TaskFactory<TResult> Klasse, die Objekte erstellt Task<TResult> .

Mit der TaskFactory<TResult> Klasse können Sie folgendes ausführen:

• Erstellen Sie eine Aufgabe, und starten Sie sie sofort, indem Sie die StartNew Methode aufrufen. Sie können die Überladungen dieser Methode aufrufen, um eine Aufgabe zu erstellen und auszuführen, die nicht standardmäßige Argumente erfordert.

  Warnung

  Ab .NET Framework 4.5 bietet die Task.Run Methode die einfachste Möglichkeit, eine Aufgabe mit Standardkonfigurationswerten zu erstellen und sofort zu starten.

• Erstellen Sie eine Aufgabe, die beginnt, wenn eine der Aufgaben in einem Array abgeschlossen ist, indem Sie die ContinueWhenAny ContinueWhenAny Methode aufrufen.

• Erstellen Sie eine Aufgabe, die beginnt, wenn alle Vorgänge in einem Array abgeschlossen sind, indem Sie die ContinueWhenAll ContinueWhenAll Methode aufrufen.

Die statische Task<TResult>.Factory Eigenschaft gibt ein Standardobjekt TaskFactory<TResult> zurück. Sie können auch einen der TaskFactory<TResult> Klassenkonstruktoren aufrufen, um die Objekte zu konfigurieren, die die Task<TResult> TaskFactory<TResult> Klasse erstellt. Im folgenden Beispiel wird ein neues TaskFactory<TResult> Objekt zum Erstellen von Aufgaben konfiguriert, die über ein angegebenes Abbruchtoken, Aufgabenerstellungsoptionen, Fortsetzungsoptionen und einen angepassten Aufgabenplaner verfügen.

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 den meisten Fällen müssen Sie keine neue TaskFactory<TResult> Instanz instanziieren. Stattdessen können Sie die statische Task<TResult>.Factory Eigenschaft verwenden, die ein Factoryobjekt zurückgibt, das Standardwerte verwendet. Anschließend können Sie die Methoden aufrufen, um neue Aufgaben zu starten oder Vorgangskontinuitäten zu definieren. Eine Abbildung finden Sie im Beispiel.

Konstruktoren

Eigenschaften

Methoden

Gilt für

Threadsicherheit

Alle öffentlichen und geschützten Elemente TaskFactory<TResult> sind threadsicher und können gleichzeitig von mehreren Threads verwendet werden.

Siehe auch

• Task Parallel Library (TPL)