TaskFactory<TResult> Classe

Riferimento

Definizione

Spazio dei nomi:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

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 oggetti Task<TResult>.

generic <typename TResult>
public ref class TaskFactory

public class TaskFactory<TResult>

type TaskFactory<'Result> = class

Public Class TaskFactory(Of TResult)

Parametri di tipo

TResult

Valore restituito degli oggetti Task<TResult> creati dai metodi di questa classe.

Ereditarietà: Object
TaskFactory<TResult>

Esempio

Nell'esempio seguente viene usata la proprietà statica Factory per eseguire 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 delle attività:

Classe TaskFactory , che crea Task e Task<TResult> oggetti.
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 fornisce il modo più semplice per creare un'attività con valori di configurazione predefiniti e avviarla immediatamente.
Creare un'attività che inizia quando una delle attività in una matrice è stata completata chiamando il ContinueWhenAny metodo o ContinueWhenAny .
Creare un'attività che inizia 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 costruttori di TaskFactory<TResult> classe 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 specificato, opzioni di creazione attività, opzioni di continuazione e utilità di pianificazione attività 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 usare la proprietà statica Task<TResult>.Factory , che restituisce un oggetto factory che usa valori predefiniti. È quindi possibile chiamare i metodi per avviare nuove attività o definire le continuazioni delle attività. Per un'illustrazione, vedere l'esempio.

Costruttori

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

Proprietà

CancellationToken	Ottiene il token di annullamento predefinito per questa factory delle attività.
ContinuationOptions	Ottiene il valore di enumerazione TaskContinuationOptions per questa factory delle attività.
CreationOptions	Ottiene il valore di enumerazione TaskCreationOptions per questa factory delle attività.
Scheduler	Ottiene l'utilità di pianificazione per questa factory delle attività.

Metodi

ContinueWhenAll(Task[], Func<Task[],TResult>)	Crea un'attività di continuazione che verrà avviata al completamento di un set di attività fornite.
ContinueWhenAll(Task[], Func<Task[],TResult>, CancellationToken)	Crea un'attività di continuazione che verrà avviata al completamento di un set di attività fornite.
ContinueWhenAll(Task[], Func<Task[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un'attività di continuazione che verrà avviata al completamento di un set di attività fornite.
ContinueWhenAll(Task[], Func<Task[],TResult>, TaskContinuationOptions)	Crea un'attività di continuazione che verrà avviata al completamento di un set di attività fornite.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>)	Crea un'attività di continuazione che verrà avviata al completamento di un set di attività fornite.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken)	Crea un'attività di continuazione che verrà avviata al completamento di un set di attività fornite.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un'attività di continuazione che verrà avviata al completamento di un set di attività fornite.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, TaskContinuationOptions)	Crea un'attività di continuazione che verrà avviata al completamento di un set di attività fornite.
ContinueWhenAny(Task[], Func<Task,TResult>)	Crea un'attività di continuazione che verrà avviata al completamento di una delle attività nel set fornito.
ContinueWhenAny(Task[], Func<Task,TResult>, CancellationToken)	Crea un'attività di continuazione che verrà avviata al completamento di una delle attività nel set fornito.
ContinueWhenAny(Task[], Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un'attività di continuazione che verrà avviata al completamento di una delle attività nel set fornito.
ContinueWhenAny(Task[], Func<Task,TResult>, TaskContinuationOptions)	Crea un'attività di continuazione che verrà avviata al completamento di una delle attività nel set fornito.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>)	Crea un'attività di continuazione che verrà avviata al completamento di una delle attività nel set fornito.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken)	Crea un'attività di continuazione che verrà avviata al completamento di una delle attività nel set fornito.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un'attività di continuazione che verrà avviata al completamento di una delle attività nel set fornito.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, TaskContinuationOptions)	Crea un'attività di continuazione che verrà avviata 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>, Func<IAsyncResult,TResult>, Object)	Crea un'attività che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, Object, TaskCreationOptions)	Crea un'attività che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync(IAsyncResult, Func<IAsyncResult,TResult>)	Crea un'attività che esegue una funzione del metodo End al completamento di un oggetto IAsyncResult specificato.
FromAsync(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions)	Crea un'attività che esegue una funzione del metodo End al completamento di un oggetto IAsyncResult specificato.
FromAsync(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions, TaskScheduler)	Crea un'attività che esegue una funzione del metodo End al completamento di un oggetto IAsyncResult specificato.
FromAsync<TArg1,TArg2,TArg3>(Func<TArg1,TArg2,TArg3,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object)	Crea un'attività 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>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object, TaskCreationOptions)	Crea un'attività che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TArg1,TArg2>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object)	Crea un'attività che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TArg1,TArg2>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object, TaskCreationOptions)	Crea un'attività che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TArg1>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, Object)	Crea un'attività che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
FromAsync<TArg1>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, Object, TaskCreationOptions)	Crea un'attività che rappresenta una coppia di metodi Begin ed End conformi al modello di programmazione asincrona.
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(Func<Object,TResult>, Object)	Crea e avvia un'attività.
StartNew(Func<Object,TResult>, Object, CancellationToken)	Crea e avvia un'attività.
StartNew(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Crea e avvia un'attività.
StartNew(Func<Object,TResult>, Object, TaskCreationOptions)	Crea e avvia un'attività.
StartNew(Func<TResult>)	Crea e avvia un'attività.
StartNew(Func<TResult>, CancellationToken)	Crea e avvia un'attività.
StartNew(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)	Crea e avvia un'attività.
StartNew(Func<TResult>, TaskCreationOptions)	Crea e avvia un'attività.
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<TResult> sono thread-safe e possono essere usati simultaneamente da più thread.

Vedi anche

Task Parallel Library (TPL)

Condividi tramite