TaskFactory<TResult> Classe

Definizione

generic <typename TResult>
public ref class TaskFactory

public class TaskFactory<TResult>

type TaskFactory<'Result> = class

Public Class TaskFactory(Of TResult)

Parametri di tipo

Ereditarietà

Object

TaskFactory<TResult>

Esempio

Nell'esempio seguente viene utilizzata la proprietà statica Factory per effettuare due chiamate al TaskFactory<TResult>.StartNew metodo . La prima attività restituisce una matrice di stringhe popolata con i nomi dei file nella directory MyDocuments dell'utente, mentre la seconda restituisce una matrice di stringhe popolata con i nomi delle sottodirectory della directory MyDocuments dell'utente. Chiama quindi il TaskFactory.ContinueWhenAll(Task[], Action<Task[]>) metodo , che visualizza informazioni sul numero di file e directory nelle matrici restituite dalle due attività dopo aver completato l'esecuzione.

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

Commenti

.NET offre due factory per la creazione e la pianificazione di attività:

• Classe TaskFactory , che crea Task oggetti e Task<TResult> .

• Classe TaskFactory<TResult> , che crea Task<TResult> oggetti .

La TaskFactory<TResult> classe consente di eseguire le operazioni seguenti:

• Creare un'attività e avviarla immediatamente chiamando il StartNew metodo . È possibile chiamare gli overload di questo metodo per creare ed eseguire un'attività che richiede argomenti non predefiniti.

  Avviso

  A partire da .NET Framework 4.5, il Task.Run metodo offre il modo più semplice per creare un'attività con valori di configurazione predefiniti e avviarla immediatamente.

• Creare un'attività che viene avviata quando una delle attività in una matrice è stata completata chiamando il ContinueWhenAny metodo o ContinueWhenAny .

• Creare un'attività che viene avviata quando tutte le attività in una matrice sono state completate chiamando il ContinueWhenAll metodo o ContinueWhenAll .

La proprietà statica Task<TResult>.Factory restituisce un oggetto predefinito TaskFactory<TResult> . È anche possibile chiamare uno dei TaskFactory<TResult> costruttori di classi per configurare gli Task<TResult> oggetti creati dalla TaskFactory<TResult> classe. Nell'esempio seguente viene configurato un nuovo TaskFactory<TResult> oggetto per creare attività con un token di annullamento, opzioni di creazione delle attività, opzioni di continuazione e un'utilità di pianificazione personalizzata.

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

Nella maggior parte dei casi, non è necessario creare un'istanza di una nuova TaskFactory<TResult> istanza. È invece possibile utilizzare la proprietà statica Task<TResult>.Factory , che restituisce un oggetto factory che utilizza valori predefiniti. È quindi possibile chiamare i relativi metodi per avviare nuove attività o definire le continuazioni delle attività. Per un'illustrazione, vedere l'esempio.

Thread safety

Tutti i membri pubblici e protetti di TaskFactory<TResult> sono thread-safe e possono essere usati simultaneamente da più thread.

Vedi anche

• Task Parallel Library (TPL)