TaskFactory Classe

Definizione

Spazio dei nomi:

System.Threading.Tasks

Assembly:

System.Runtime.dll

Source:

TaskFactory.cs

Fornisce supporto per la creazione e la pianificazione di oggetti Task.

public ref class TaskFactory

public class TaskFactory

type TaskFactory = class

Public Class TaskFactory

Ereditarietà

Object

TaskFactory

Esempio

Nell'esempio seguente viene usata la proprietà statica Factory per eseguire due chiamate al TaskFactory.StartNew metodo. Il primo popola una matrice con i nomi dei file nella directory MyDocuments dell'utente, mentre il secondo popola una matrice 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 due matrici dopo che le prime due attività hanno completato l'esecuzione.

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

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

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

      Task.Factory.ContinueWhenAll(tasks, completedTasks => {
                                             Console.WriteLine("{0} contains: ", docsDirectory);
                                             Console.WriteLine("   {0} subdirectories", dirs.Length);
                                             Console.WriteLine("   {0} files", files.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
      Dim files() As String = Nothing
      Dim dirs() As String = Nothing
      Dim docsDirectory As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
      
      tasks(0) = Task.Factory.StartNew( Sub()
                                           files = Directory.GetFiles(docsDirectory)
                                        End Sub )
      tasks(1) = Task.Factory.StartNew( Sub()
                                           dirs = Directory.GetDirectories(docsDirectory)
                                        End Sub )
      Task.Factory.ContinueWhenAll(tasks, Sub(completedTasks)
                                             Console.WriteLine("{0} contains: ", docsDirectory)
                                             Console.WriteLine("   {0} subdirectories", dirs.Length)
                                             Console.WriteLine("   {0} files", files.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 delle attività:

• Classe TaskFactory , che crea Task e Task<TResult> oggetti. È 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.

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

La TaskFactory classe consente di eseguire le operazioni seguenti:

• Creare un'attività e avviarla immediatamente chiamando il StartNew metodo .

  Avviso

  A partire da .NET Framework 4.5, il Task.Run metodo fornisce 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 .

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

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

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

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

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

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

   static void DoWork() {/*...*/ }
}

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(cts.Token,
                                     TaskCreationOptions.PreferFairness,
                                     TaskContinuationOptions.ExecuteSynchronously,
                                     New CustomScheduler())

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

   Sub DoWork()
      ' ...
   End Sub
End Module

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

Costruttori

TaskFactory()	Inizializza un'istanza di TaskFactory con la configurazione predefinita.
TaskFactory(CancellationToken)	Inizializza un'istanza di TaskFactory con la configurazione specificata.
TaskFactory(CancellationToken, TaskCreationOptions, TaskContinuationOptions, TaskScheduler)	Inizializza un'istanza di TaskFactory con la configurazione specificata.
TaskFactory(TaskCreationOptions, TaskContinuationOptions)	Inizializza un'istanza di TaskFactory con la configurazione specificata.
TaskFactory(TaskScheduler)	Inizializza un'istanza di TaskFactory con la configurazione specificata.

Proprietà

CancellationToken	Ottiene il token di annullamento predefinito per questa factory delle attività.
ContinuationOptions	Ottiene le opzioni di continuazione attività predefinite per questa factory delle attività.
CreationOptions	Ottiene le opzioni di creazione attività predefinite per questa factory delle attività.
Scheduler	Ottiene l'utilità di pianificazione delle attività predefinita per questa factory delle attività.

Metodi

ContinueWhenAll(Task[], Action<Task[]>)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAll(Task[], Action<Task[]>, CancellationToken)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAll(Task[], Action<Task[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAll(Task[], Action<Task[]>, TaskContinuationOptions)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, TaskContinuationOptions)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, TaskContinuationOptions)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, TaskContinuationOptions)	Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.
ContinueWhenAny(Task[], Action<Task>)	Crea un oggetto Task di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
ContinueWhenAny(Task[], Action<Task>, CancellationToken)	Crea un oggetto Task di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
ContinueWhenAny(Task[], Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un oggetto Task di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
ContinueWhenAny(Task[], Action<Task>, TaskContinuationOptions)	Crea un oggetto Task di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>)	Crea un oggetto Task<TResult> di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken)	Crea un oggetto Task<TResult> di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un oggetto Task<TResult> di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, TaskContinuationOptions)	Crea un oggetto Task<TResult> di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>)	Crea un oggetto Task di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken)	Crea un oggetto Task di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un oggetto Task di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, TaskContinuationOptions)	Crea un oggetto Task di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>)	Crea un oggetto Task<TResult> di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken)	Crea un oggetto Task<TResult> di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un oggetto Task<TResult> di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, TaskContinuationOptions)	Crea un oggetto Task<TResult> di continuazione che verrà avviato al completamento di una delle attività nel set fornito.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object)	Crea un oggetto Task che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)	Crea un oggetto Task che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync(IAsyncResult, Action<IAsyncResult>)	Crea un oggetto Task che esegue un'azione del metodo End al completamento di un oggetto IAsyncResult specificato.
FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions)	Crea un oggetto Task che esegue un'azione del metodo End al completamento di un oggetto IAsyncResult specificato.
FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions, TaskScheduler)	Crea un oggetto Task che esegue un'azione del metodo End al completamento di un oggetto IAsyncResult specificato.
FromAsync<TArg1,TArg2,TArg3,TResult>(Func<TArg1,TArg2,TArg3,AsyncCallback, Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object)	Crea un oggetto Task<TResult> che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TArg1,TArg2,TArg3,TResult>(Func<TArg1,TArg2,TArg3,AsyncCallback, Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object, TaskCreationOptions)	Crea un oggetto Task<TResult> che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TArg1,TArg2,TArg3>(Func<TArg1,TArg2,TArg3,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, TArg3, Object)	Crea un oggetto Task che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TArg1,TArg2,TArg3>(Func<TArg1,TArg2,TArg3,AsyncCallback, Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, TArg3, Object, TaskCreationOptions)	Crea un oggetto Task che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TArg1,TArg2,TResult>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object)	Crea un oggetto Task<TResult> che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TArg1,TArg2,TResult>(Func<TArg1,TArg2,AsyncCallback, Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object, TaskCreationOptions)	Crea un oggetto Task<TResult> che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TArg1,TArg2>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, Object)	Crea un oggetto Task che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TArg1,TArg2>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, Object, TaskCreationOptions)	Crea un oggetto Task che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TArg1,TResult>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, Object)	Crea un oggetto Task<TResult> che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TArg1,TResult>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, Object, TaskCreationOptions)	Crea un oggetto Task<TResult> che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TArg1>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, Object)	Crea un oggetto Task che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TArg1>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, Object, TaskCreationOptions)	Crea un oggetto Task che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TResult>(Func<AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, Object)	Crea un oggetto Task<TResult> che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TResult>(Func<AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, Object, TaskCreationOptions)	Crea un oggetto Task<TResult> che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>)	Crea un oggetto Task<TResult> che esegue una funzione del metodo End al completamento di un oggetto IAsyncResult specificato.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions)	Crea un oggetto Task<TResult> che esegue una funzione del metodo End al completamento di un oggetto IAsyncResult specificato.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions, TaskScheduler)	Crea un oggetto Task<TResult> che esegue una funzione del metodo End al completamento di un oggetto IAsyncResult specificato.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
StartNew(Action)	Crea e avvia un'attività per il delegato di azione specificato.
StartNew(Action, CancellationToken)	Crea e avvia un'attività per il delegato di azione e il token di annullamento specificati.
StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)	Crea e avvia un'attività per il delegato di azione specificato, il token di annullamento, le opzioni di creazione e lo stato specificati.
StartNew(Action, TaskCreationOptions)	Crea e avvia un'attività per il delegato e le opzioni di creazione dell'azione specificate.
StartNew(Action<Object>, Object)	Crea e avvia un'attività per il delegato e lo stato dell'azione specificati.
StartNew(Action<Object>, Object, CancellationToken)	Crea e avvia un'attività per il delegato di azione, lo stato e il token di annullamento specificati.
StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Crea e avvia un'attività per il delegato di azione, lo stato, il token di annullamento, le opzioni di creazione e l'utilità di pianificazione delle attività specificati.
StartNew(Action<Object>, Object, TaskCreationOptions)	Crea e avvia un'attività per il delegato di azione, lo stato e le opzioni di creazione specificati.
StartNew<TResult>(Func<Object,TResult>, Object)	Crea e avvia un'attività di tipo TResult per il delegato e lo stato della funzione specificati.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken)	Crea e avvia un'attività di tipo TResult per il delegato di funzione, lo stato e il token di annullamento specificati.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Crea e avvia un'attività di tipo TResult per il delegato di funzione, lo stato, il token di annullamento, le opzioni di creazione e l'utilità di pianificazione delle attività specificati.
StartNew<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	Crea e avvia un'attività di tipo TResult per il delegato di funzione, lo stato e le opzioni di creazione specificati.
StartNew<TResult>(Func<TResult>)	Crea e avvia un'attività di tipo TResult per il delegato della funzione specificato.
StartNew<TResult>(Func<TResult>, CancellationToken)	Crea e avvia un'attività di tipo TResult per il delegato della funzione e il token di annullamento specificati.
StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)	Crea e avvia un'attività di tipo TResult per il delegato di funzione specificato, il token di annullamento, le opzioni di creazione e l'utilità di pianificazione delle attività.
StartNew<TResult>(Func<TResult>, TaskCreationOptions)	Crea e avvia un'attività di tipo TResult per il delegato della funzione e le opzioni di creazione specificati.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Thread safety

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

Vedi anche

• Task Parallel Library (TPL)
• Esempi per la programmazione parallela con .NET Core e .NET Standard