TaskFactory<TResult> Osztály

Definíció

generic <typename TResult>
public ref class TaskFactory

public class TaskFactory<TResult>

type TaskFactory<'Result> = class

Public Class TaskFactory(Of TResult)

Típusparaméterek

Öröklődés

Object

TaskFactory<TResult>

Példák

Az alábbi példa a statikus Factory tulajdonság használatával két hívást indít a TaskFactory<TResult>.StartNew metódusra. Az első feladat egy sztringtömböt ad vissza, amely a felhasználó MyDocuments könyvtárában lévő fájlok nevével van feltöltve, a második pedig egy sztringtömböt ad vissza, amely a felhasználó MyDocuments könyvtárának alkönyvtárainak nevével van feltöltve. Ezután meghívja a TaskFactory.ContinueWhenAll(Task[], Action<Task[]>) metódust, amely információkat jelenít meg a két feladat által visszaadott fájlok és könyvtárak számáról a végrehajtás befejezése után.

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

Megjegyzések

.NET két gyárat biztosít a feladatok létrehozásához és ütemezéséhez:

• Az TaskFactory osztály, amely létrehoz Task és Task<TResult> objektumokat.

• Az TaskFactory<TResult> objektumokat létrehozó Task<TResult> osztály.

Az TaskFactory<TResult> osztály a következőket teszi lehetővé:

• Hozzon létre egy feladatot, és azonnal indítsa el a StartNew metódus meghívásával. A metódus túlterheléseit meghívva létrehozhat és végrehajthat egy olyan feladatot, amely nem alapértelmezett argumentumokat igényel.

  Warning

  A .NET Framework 4.5-től kezdve a Task.Run metódus a legegyszerűbb módot kínálja az alapértelmezett konfigurációs értékekkel rendelkező feladatok létrehozására és azonnali elindítására.

• Hozzon létre egy feladatot, amely akkor indul el, amikor egy tömb bármelyik tevékenysége befejeződött a ContinueWhenAny metódus meghívásával ContinueWhenAny .

• Hozzon létre egy tevékenységet, amely akkor indul el, amikor egy tömb összes tevékenysége befejeződött a ContinueWhenAll metódus meghívásával ContinueWhenAll .

A statikus Task<TResult>.Factory tulajdonság egy alapértelmezett TaskFactory<TResult> objektumot ad vissza. Az osztálykonstruktorok TaskFactory<TResult> egyikét Task<TResult> is meghívhatja az TaskFactory<TResult> osztály által létrehozott objektumok konfigurálásához. Az alábbi példa egy új TaskFactory<TResult> objektumot konfigurál a megadott lemondási jogkivonattal, tevékenységlétrehozási lehetőségekkel, folytatási lehetőségekkel és testreszabott feladatütemezővel rendelkező tevékenységek létrehozásához.

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

A legtöbb esetben nem kell új TaskFactory<TResult> példányt létrehoznia. Ehelyett használhatja a statikus Task<TResult>.Factory tulajdonságot, amely egy alapértelmezett értékeket használó gyári objektumot ad vissza. Ezután meghívhatja a metódusokat új tevékenységek indításához vagy a tevékenységek folytatásának definiálásához. Ábrát a példában talál.

Szálbiztonság

Az összes nyilvános és védett tagja TaskFactory<TResult> szálbiztos, és egyidejűleg több szálból is használható.

Lásd még

• Feladatpárhuzamosítási könyvtár (TPL)