TaskFactory Class

Definition

Fornisce supporto per la creazione e la pianificazione di oggetti Task.Provides support for creating and scheduling Task objects.

public ref class TaskFactory
public class TaskFactory
type TaskFactory = class
Public Class TaskFactory
Inheritance
TaskFactory

Examples

Nell'esempio seguente viene utilizzata la proprietà Factory statica per effettuare due chiamate al metodo TaskFactory.StartNew.The following example uses the static Factory property to make two calls to the TaskFactory.StartNew method. Il primo compila una matrice con i nomi dei file nella directory documenti dell'utente, mentre la seconda compila una matrice con i nomi delle sottodirectory della directory documenti dell'utente.The first populates an array with the names of files in the user's MyDocuments directory, while the second populates an array with the names of subdirectories of the user's MyDocuments directory. Viene quindi chiamato il metodo TaskFactory.ContinueWhenAll(Task[], Action<Task[]>), che visualizza informazioni sul numero di file e directory nelle due matrici dopo che le prime due attività hanno completato l'esecuzione.It then calls the TaskFactory.ContinueWhenAll(Task[], Action<Task[]>) method, which displays information about the number of files and directories in the two arrays after the first two tasks have completed execution.

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

Remarks

Il .NET Framework fornisce due Factory per la creazione e la pianificazione delle attività:The .NET Framework provides two factories for creating and scheduling tasks:

  • Classe TaskFactory, che crea Task e Task<TResult> oggetti.The TaskFactory class, which creates Task and Task<TResult> objects. È possibile chiamare gli overload di questo metodo per creare ed eseguire un'attività che richiede argomenti non predefiniti.You can call the overloads of this method to create and execute a task that requires non-default arguments.

    Warning

    A partire dalla .NET Framework 4.5.NET Framework 4.5, il metodo Task.Run fornisce il modo più semplice per creare un'attività con i valori di configurazione predefiniti e avviarla immediatamente.Starting with the .NET Framework 4.5.NET Framework 4.5, the Task.Run method provides the easiest way to create a task with default configuration values and start it immediately.

  • Classe TaskFactory<TResult>, che crea Task<TResult> oggetti.The TaskFactory<TResult> class, which creates Task<TResult> objects.

La classe TaskFactory consente di eseguire le operazioni seguenti:The TaskFactory class allows you to do the following:

  • Creare un'attività e avviarla immediatamente chiamando il metodo StartNew.Create a task and start it immediately by calling the StartNew method.

    Warning

    A partire dalla .NET Framework 4.5.NET Framework 4.5, il metodo Task.Run fornisce il modo più semplice per creare un'attività con i valori di configurazione predefiniti e avviarla immediatamente.Starting with the .NET Framework 4.5.NET Framework 4.5, the Task.Run method provides the easiest way to create a task with default configuration values and start it immediately.

  • Creare un'attività che viene avviata quando una delle attività in una matrice è stata completata chiamando il metodo ContinueWhenAny.Create a task that starts when any one of the tasks in an array has completed by calling the ContinueWhenAny method.

  • Creare un'attività che viene avviata quando tutte le attività in una matrice sono state completate chiamando il metodo ContinueWhenAll.Create a task that starts when all the tasks in an array have completed by calling the ContinueWhenAll method.

La proprietà Task<TResult>.Factory statica restituisce un oggetto TaskFactory<TResult> predefinito.The static Task<TResult>.Factory property returns a default TaskFactory<TResult> object. È anche possibile chiamare uno dei costruttori della classe TaskFactory per configurare gli oggetti Task creati dalla classe TaskFactory.You can also call one of the TaskFactory class constructors to configure the Task objects that the TaskFactory class creates. Nell'esempio seguente viene configurato un nuovo oggetto TaskFactory per creare attività con un token di annullamento specificato, opzioni di creazione di attività, opzioni di continuazione e un'utilità di pianificazione personalizzata.The following example configures a new TaskFactory object to create tasks that have a specified cancellation token, task creation options, continuation options, and a customized task scheduler.

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 istanza di TaskFactory.In most cases, you do not have to instantiate a new TaskFactory instance. È invece possibile usare la proprietà Task.Factory, che restituisce un oggetto factory che usa i valori predefiniti.Instead, you can use the Task.Factory property, which returns a factory object that uses default values. È quindi possibile chiamare i relativi metodi per avviare nuove attività o definire le continuazioni delle attività.You can then call its methods to start new tasks or define task continuations. Per un'illustrazione, vedere l'esempio.For an illustration, see the example.

Constructors

TaskFactory()

Inizializza un'istanza di TaskFactory con la configurazione predefinita.Initializes a TaskFactory instance with the default configuration.

TaskFactory(CancellationToken)

Inizializza un'istanza di TaskFactory con la configurazione specificata.Initializes a TaskFactory instance with the specified configuration.

TaskFactory(CancellationToken, TaskCreationOptions, TaskContinuationOptions, TaskScheduler)

Inizializza un'istanza di TaskFactory con la configurazione specificata.Initializes a TaskFactory instance with the specified configuration.

TaskFactory(TaskCreationOptions, TaskContinuationOptions)

Inizializza un'istanza di TaskFactory con la configurazione specificata.Initializes a TaskFactory instance with the specified configuration.

TaskFactory(TaskScheduler)

Inizializza un'istanza di TaskFactory con la configurazione specificata.Initializes a TaskFactory instance with the specified configuration.

Properties

CancellationToken

Ottiene il token di annullamento predefinito per questa factory delle attività.Gets the default cancellation token for this task factory.

ContinuationOptions

Ottiene le opzioni di continuazione attività predefinite per questa factory delle attività.Gets the default task continuation options for this task factory.

CreationOptions

Ottiene le opzioni di creazione attività predefinite per questa factory delle attività.Gets the default task creation options for this task factory.

Scheduler

Ottiene l'utilità di pianificazione delle attività predefinita per questa factory delle attività.Gets the default task scheduler for this task factory.

Methods

ContinueWhenAll(Task[], Action<Task[]>)

Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll(Task[], Action<Task[]>, CancellationToken)

Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll(Task[], Action<Task[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll(Task[], Action<Task[]>, TaskContinuationOptions)

Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.Creates a continuation task that starts when a set of specified tasks has completed.

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.Creates a continuation task that starts when a set of specified tasks has completed.

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.Creates a continuation task that starts when a set of specified tasks has completed.

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.Creates a continuation task that starts when a set of specified tasks has completed.

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.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>)

Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken)

Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.Creates a continuation task that starts when a set of specified tasks has completed.

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.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, TaskContinuationOptions)

Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>)

Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken)

Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.Creates a continuation task that starts when a set of specified tasks has completed.

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.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, TaskContinuationOptions)

Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAny(Task[], Action<Task>)

Crea un oggetto Task di continuazione che verrà avviato al completamento di una delle attività nel set fornito.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

ContinueWhenAny(Task[], Action<Task>, CancellationToken)

Crea un oggetto Task di continuazione che verrà avviato al completamento di una delle attività nel set fornito.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

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.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

ContinueWhenAny(Task[], Action<Task>, TaskContinuationOptions)

Crea un oggetto Task di continuazione che verrà avviato al completamento di una delle attività nel set fornito.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

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.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

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.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

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.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

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.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

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.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

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.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

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.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

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.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

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.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

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.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

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.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

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.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from 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.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

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.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync(IAsyncResult, Action<IAsyncResult>)

Crea un oggetto Task che esegue un'azione del metodo End al completamento di un oggetto IAsyncResult specificato.Creates a Task that executes an end method action when a specified IAsyncResult completes.

FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions)

Crea un oggetto Task che esegue un'azione del metodo End al completamento di un oggetto IAsyncResult specificato.Creates a Task that executes an end method action when a specified IAsyncResult completes.

FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions, TaskScheduler)

Crea un oggetto Task che esegue un'azione del metodo End al completamento di un oggetto IAsyncResult specificato.Creates a Task that executes an end method action when a specified IAsyncResult completes.

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.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

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.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

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.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

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.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

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.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

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.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

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.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

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.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

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.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

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.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

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.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

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.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

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.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

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.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

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.Creates a Task<TResult> that executes an end method function when a specified IAsyncResult completes.

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.Creates a Task<TResult> that executes an end method function when a specified IAsyncResult completes.

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.Creates a Task<TResult> that executes an end method function when a specified IAsyncResult completes.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
StartNew(Action)

Crea e avvia un'attività per il delegato dell'azione specificato.Creates and starts a task for the specified action delegate.

StartNew(Action, CancellationToken)

Crea e avvia un'attività per il delegato dell'azione e il token di annullamento specificati.Creates and starts a task for the specified action delegate and cancellation token.

StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)

Crea e avvia un'attività per il delegato dell'azione, il token di annullamento, le opzioni di creazione e lo stato specificati.Creates and starts a task for the specified action delegate, cancellation token, creation options and state.

StartNew(Action, TaskCreationOptions)

Crea e avvia un'attività per il delegato dell'azione e le opzioni di creazione specificati.Creates and starts a task for the specified action delegate and creation options.

StartNew(Action<Object>, Object)

Crea e avvia un'attività per il delegato dell'azione e lo stato specificati.Creates and starts a task for the specified action delegate and state.

StartNew(Action<Object>, Object, CancellationToken)

Crea e avvia un'attività per il delegato dell'azione, lo stato e il token di annullamento specificati.Creates and starts a task for the specified action delegate, state and cancellation token.

StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)

Crea e avvia un'attività per il delegato dell'azione, lo stato, il token di annullamento, le opzioni di creazione e l'utilità di pianificazione specificati.Creates and starts a task for the specified action delegate, state, cancellation token, creation options and task scheduler.

StartNew(Action<Object>, Object, TaskCreationOptions)

Crea e avvia un'attività per il delegato dell'azione, lo stato e le opzioni di creazione specificati.Creates and starts a task for the specified action delegate, state and creation options.

StartNew<TResult>(Func<Object,TResult>, Object)

Crea e avvia un'attività di tipo TResult per il delegato della funzione e lo stato specificati.Creates and starts a task of type TResult for the specified function delegate and state.

StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken)

Crea e avvia un'attività di tipo TResult per il delegato della funzione, lo stato e il token di annullamento specificati.Creates and starts a task of type TResult for the specified function delegate, state and cancellation token.

StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)

Crea e avvia un'attività di tipo TResult per il delegato della funzione, lo stato, il token di annullamento, le opzioni di creazione e l'utilità di pianificazione specificati.Creates and starts a task of type TResult for the specified function delegate, state, cancellation token, creation options and task scheduler.

StartNew<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)

Crea e avvia un'attività di tipo TResult per il delegato della funzione, lo stato e le opzioni di creazione specificati.Creates and starts a task of type TResult for the specified function delegate, state and creation options.

StartNew<TResult>(Func<TResult>)

Crea e avvia un'attività di tipo TResult per il delegato della funzione specificato.Creates and starts a task of type TResult for the specified function delegate.

StartNew<TResult>(Func<TResult>, CancellationToken)

Crea e avvia un'attività di tipo TResult per il delegato della funzione e il token di annullamento specificati.Creates and starts a task of type TResult for the specified function delegate and cancellation token.

StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)

Crea e avvia un'attività di tipo TResult per il delegato della funzione, il token di annullamento, le opzioni di creazione e l'utilità di pianificazione specificati.Creates and starts a task of type TResult for the specified function delegate, cancellation token, creation options and task scheduler.

StartNew<TResult>(Func<TResult>, TaskCreationOptions)

Crea e avvia un'attività di tipo TResult per il delegato della funzione e le opzioni di creazione specificati.Creates and starts a task of type TResult for the specified function delegate and creation options.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Inherited from Object)

Applies to

Thread Safety

Tutti i membri pubblici e protetti di TaskFactory sono thread-safe e possono essere usati contemporaneamente da più thread.All public and protected members of TaskFactory are thread-safe and may be used concurrently from multiple threads.

See also