TaskFactory Classe

Definizione

Spazio dei nomi:: System.Threading.Tasks

Assembly:: mscorlib.dll, System.Threading.Tasks.dll

Assembly:: netstandard.dll, System.Runtime.dll

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origine:: TaskFactory.cs

Origine:: TaskFactory.cs

Origine:: TaskFactory.cs

Origine:: TaskFactory.cs

Origine:: TaskFactory.cs

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

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

public ref class TaskFactory

public class TaskFactory

type TaskFactory = class

Public Class TaskFactory

Ereditarietà: Object
TaskFactory

Esempio

Nell'esempio seguente viene utilizzata la proprietà statica Factory per effettuare due chiamate al TaskFactory.StartNew metodo . La prima popola una matrice con i nomi dei file nella directory MyDocuments dell'utente, mentre la seconda 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 il completamento dell'esecuzione delle prime due attività.

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 di attività:

Classe TaskFactory , che crea Task oggetti e Task<TResult> . È 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 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 .
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 TaskFactory costruttori di classi 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 un'utilità di pianificazione 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 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.

Costruttori

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

Proprietà

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

Metodi

Nome	Descrizione
ContinueWhenAll(Task[], Action<Task[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAll(Task[], Action<Task[]>, CancellationToken)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAll(Task[], Action<Task[]>, TaskContinuationOptions)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAll(Task[], Action<Task[]>)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, TaskContinuationOptions)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, TaskContinuationOptions)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, TaskContinuationOptions)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>)	Crea un'attività di continuazione che viene avviata al completamento di un set di attività specificate.
ContinueWhenAny(Task[], Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione Task che verrà avviata al completamento di qualsiasi attività nel set specificato.
ContinueWhenAny(Task[], Action<Task>, CancellationToken)	Crea una continuazione Task che verrà avviata al completamento di qualsiasi attività nel set specificato.
ContinueWhenAny(Task[], Action<Task>, TaskContinuationOptions)	Crea una continuazione Task che verrà avviata al completamento di qualsiasi attività nel set specificato.
ContinueWhenAny(Task[], Action<Task>)	Crea una continuazione Task che verrà avviata al completamento di qualsiasi attività nel set specificato.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione Task<TResult> che verrà avviata al completamento di qualsiasi attività nel set specificato.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken)	Crea una continuazione Task<TResult> che verrà avviata al completamento di qualsiasi attività nel set specificato.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, TaskContinuationOptions)	Crea una continuazione Task<TResult> che verrà avviata al completamento di qualsiasi attività nel set specificato.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>)	Crea una continuazione Task<TResult> che verrà avviata al completamento di qualsiasi attività nel set specificato.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione Task che verrà avviata al completamento di qualsiasi attività nel set specificato.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken)	Crea una continuazione Task che verrà avviata al completamento di qualsiasi attività nel set specificato.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, TaskContinuationOptions)	Crea una continuazione Task che verrà avviata al completamento di qualsiasi attività nel set specificato.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>)	Crea una continuazione Task che verrà avviata al completamento di qualsiasi attività nel set specificato.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione Task<TResult> che verrà avviata al completamento di qualsiasi attività nel set specificato.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken)	Crea una continuazione Task<TResult> che verrà avviata al completamento di qualsiasi attività nel set specificato.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, TaskContinuationOptions)	Crea una continuazione Task<TResult> che verrà avviata al completamento di qualsiasi attività nel set specificato.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>)	Crea una continuazione Task<TResult> che verrà avviata al completamento di qualsiasi attività nel set specificato.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)	Crea un oggetto Task che rappresenta una coppia di metodi begin e end conformi al modello modello di programmazione asincrona.
FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object)	Crea un oggetto Task che rappresenta una coppia di metodi begin e end conformi al modello modello di programmazione asincrona.
FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions, TaskScheduler)	Crea un oggetto Task che esegue un'azione del metodo finale al completamento di un oggetto specificato IAsyncResult .
FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions)	Crea un oggetto Task che esegue un'azione del metodo finale al completamento di un oggetto specificato IAsyncResult .
FromAsync(IAsyncResult, Action<IAsyncResult>)	Crea un oggetto Task che esegue un'azione del metodo finale al completamento di un oggetto specificato IAsyncResult .
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 e end conformi al modello modello di programmazione asincrona.
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 e end conformi al modello 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 e end conformi al modello 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 e end conformi al modello 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 e end conformi al modello 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 e end conformi al modello 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 e end conformi al modello 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 e end conformi al modello 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 e end conformi al modello 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 e end conformi al modello 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 e end conformi al modello 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 e end conformi al modello 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 e end conformi al modello 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 e end conformi al modello modello di programmazione asincrona.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions, TaskScheduler)	Crea un oggetto Task<TResult> che esegue una funzione del metodo end al termine di un oggetto specificato IAsyncResult .
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions)	Crea un oggetto Task<TResult> che esegue una funzione del metodo end al termine di un oggetto specificato IAsyncResult .
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>)	Crea un oggetto Task<TResult> che esegue una funzione del metodo end al termine di un oggetto specificato IAsyncResult .
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene il Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)	Crea e avvia un'attività per il delegato di azione, il token di annullamento, le opzioni di creazione e lo stato specificati.
StartNew(Action, CancellationToken)	Crea e avvia un'attività per il delegato di azione e il token di annullamento specificati.
StartNew(Action, TaskCreationOptions)	Crea e avvia un'attività per le opzioni di creazione e delega dell'azione specificate.
StartNew(Action)	Crea e avvia un'attività per il delegato di azione specificato.
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 dell'attività 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, TaskCreationOptions)	Crea e avvia un'attività per le opzioni di delega, stato e creazione dell'azione specificate.
StartNew(Action<Object>, Object)	Crea e avvia un'attività per il delegato e lo stato dell'azione 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 dell'attività 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, 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<Object,TResult>, Object)	Crea e avvia un'attività di tipo `TResult` per il delegato e lo stato della funzione specificati.
StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)	Crea e avvia un'attività di tipo `TResult` per il delegato di funzione, il token di annullamento, le opzioni di creazione e l'utilità di pianificazione specificati.
StartNew<TResult>(Func<TResult>, CancellationToken)	Crea e avvia un'attività di tipo `TResult` per il delegato di funzione e il token di annullamento specificati.
StartNew<TResult>(Func<TResult>, TaskCreationOptions)	Crea e avvia un'attività di tipo `TResult` per le opzioni di creazione e delegato di funzione specificate.
StartNew<TResult>(Func<TResult>)	Crea e avvia un'attività di tipo `TResult` per il delegato di funzione specificato.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Si applica a

Thread safety

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

Vedi anche

Commenti e suggerimenti

Questa pagina è stata utile?