TaskFactory<TResult> Klass

Definition

generic <typename TResult>
public ref class TaskFactory

public class TaskFactory<TResult>

type TaskFactory<'Result> = class

Public Class TaskFactory(Of TResult)

Typparametrar

Arv

Object

TaskFactory<TResult>

Exempel

I följande exempel används den statiska Factory egenskapen för att göra två anrop till TaskFactory<TResult>.StartNew metoden. Den första aktiviteten returnerar en strängmatris som fylls med namnen på filerna i användarens Katalog MyDocuments, medan den andra returnerar en strängmatris som är ifylld med namnen på underkatalogerna i användarens Katalog MyDocuments. Den anropar TaskFactory.ContinueWhenAll(Task[], Action<Task[]>) sedan metoden, som visar information om antalet filer och kataloger i matriserna som returneras av de två aktiviteterna när de har slutfört körningen.

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

Kommentarer

.NET innehåller två fabriker för att skapa och schemalägga uppgifter:

• Klassen TaskFactory , som skapar Task och Task<TResult> objekt.

• Klassen TaskFactory<TResult> , som skapar Task<TResult> objekt.

Med TaskFactory<TResult> klassen kan du göra följande:

• Skapa en uppgift och starta den direkt genom att anropa StartNew metoden. Du kan anropa överlagringarna för den här metoden för att skapa och köra en uppgift som kräver argument som inte är standard.

  Varning

  Från och med .NET Framework 4.5 är metoden Task.Run det enklaste sättet att skapa en uppgift med standardkonfigurationsvärden och starta den omedelbart.

• Skapa en aktivitet som startar när någon av aktiviteterna i en matris har slutförts genom att anropa ContinueWhenAny metoden eller ContinueWhenAny .

• Skapa en aktivitet som startar när alla aktiviteter i en matris har slutförts genom att anropa ContinueWhenAll metoden eller ContinueWhenAll .

Den statiska Task<TResult>.Factory egenskapen returnerar ett standardobjekt TaskFactory<TResult> . Du kan också anropa en av TaskFactory<TResult> klasskonstruktorerna för att konfigurera de Task<TResult> objekt som TaskFactory<TResult> klassen skapar. I följande exempel konfigureras ett nytt TaskFactory<TResult> objekt för att skapa aktiviteter som har en angiven annulleringstoken, alternativ för att skapa aktiviteter, fortsättningsalternativ och en anpassad schemaläggare.

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

I de flesta fall behöver du inte instansiera en ny TaskFactory<TResult> instans. I stället kan du använda den statiska Task<TResult>.Factory egenskapen, som returnerar ett fabriksobjekt som använder standardvärden. Du kan sedan anropa dess metoder för att starta nya aktiviteter eller definiera aktivitetsfortsättningar. En bild finns i exemplet.

Trådsäkerhet

Alla offentliga och skyddade medlemmar TaskFactory<TResult> i är trådsäkra och kan användas samtidigt från flera trådar.

Se även

• Aktivitetsparallellt bibliotek (TPL)