TaskFactory Clase

Referencia

Definición

Espacio de nombres:: System.Threading.Tasks

Ensamblado:: System.Threading.Tasks.dll

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Proporciona compatibilidad para crear y programar objetos Task.

public ref class TaskFactory

public class TaskFactory

type TaskFactory = class

Public Class TaskFactory

Herencia: Object
TaskFactory

Ejemplos

En el ejemplo siguiente se usa la propiedad estática Factory para realizar dos llamadas al TaskFactory.StartNew método . La primera rellena una matriz con los nombres de los archivos en el directorio MyDocuments del usuario, mientras que el segundo rellena una matriz con los nombres de subdirectorios del directorio MyDocuments del usuario. A continuación, llama al TaskFactory.ContinueWhenAll(Task[], Action<Task[]>) método , que muestra información sobre el número de archivos y directorios en las dos matrices después de que las dos primeras tareas hayan completado la ejecución.

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

Comentarios

.NET proporciona dos generadores para crear y programar tareas:

Clase TaskFactory , que crea Task objetos y Task<TResult> . Puede llamar a las sobrecargas de este método para crear y ejecutar una tarea que requiera argumentos no predeterminados.

Advertencia

A partir de .NET Framework 4.5, el Task.Run método proporciona la manera más fácil de crear una tarea con valores de configuración predeterminados e iniciarla inmediatamente.
Clase TaskFactory<TResult> , que crea Task<TResult> objetos .

La TaskFactory clase permite hacer lo siguiente:

Cree una tarea e iníciela inmediatamente llamando al StartNew método .

Advertencia

A partir de .NET Framework 4.5, el Task.Run método proporciona la manera más fácil de crear una tarea con valores de configuración predeterminados e iniciarla inmediatamente.
Cree una tarea que se inicie cuando se haya completado cualquiera de las tareas de una matriz llamando al ContinueWhenAny método .
Cree una tarea que se inicie cuando todas las tareas de una matriz se hayan completado llamando al ContinueWhenAll método .

La propiedad estática Task<TResult>.Factory devuelve un objeto predeterminado TaskFactory<TResult> . También puede llamar a uno de los TaskFactory constructores de clase para configurar los Task objetos que crea la TaskFactory clase. En el ejemplo siguiente se configura un nuevo TaskFactory objeto para crear tareas que tengan un token de cancelación especificado, opciones de creación de tareas, opciones de continuación y un programador de tareas personalizado.

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

En la mayoría de los casos, no es necesario crear instancias de una nueva TaskFactory instancia. En su lugar, puede usar la Task.Factory propiedad , que devuelve un objeto de fábrica que usa valores predeterminados. A continuación, puede llamar a sus métodos para iniciar nuevas tareas o definir continuaciones de tareas. Para obtener una ilustración, vea el ejemplo.

Constructores

TaskFactory()	Inicializa una instancia de TaskFactory con la configuración predeterminada.
TaskFactory(CancellationToken)	Inicializa una instancia de TaskFactory con la configuración especificada.
TaskFactory(CancellationToken, TaskCreationOptions, TaskContinuationOptions, TaskScheduler)	Inicializa una instancia de TaskFactory con la configuración especificada.
TaskFactory(TaskCreationOptions, TaskContinuationOptions)	Inicializa una instancia de TaskFactory con la configuración especificada.
TaskFactory(TaskScheduler)	Inicializa una instancia de TaskFactory con la configuración especificada.

Propiedades

CancellationToken	Obtiene el token de cancelación predeterminado para este generador de tareas.
ContinuationOptions	Obtiene las opciones predeterminadas de continuación de tareas para este generador de tareas.
CreationOptions	Obtiene las opciones predeterminadas de creación de tareas para este generador de tareas.
Scheduler	Obtiene el programador de tareas predeterminado para este generador de tareas.

Métodos

ContinueWhenAll(Task[], Action<Task[]>)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll(Task[], Action<Task[]>, CancellationToken)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll(Task[], Action<Task[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll(Task[], Action<Task[]>, TaskContinuationOptions)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, TaskContinuationOptions)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, TaskContinuationOptions)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, TaskContinuationOptions)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAny(Task[], Action<Task>)	Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny(Task[], Action<Task>, CancellationToken)	Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny(Task[], Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny(Task[], Action<Task>, TaskContinuationOptions)	Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>)	Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken)	Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, TaskContinuationOptions)	Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>)	Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken)	Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, TaskContinuationOptions)	Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>)	Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken)	Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, TaskContinuationOptions)	Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object)	Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)	Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync(IAsyncResult, Action<IAsyncResult>)	Crea un objeto Task que ejecuta una acción del método End cuando se completa la interfaz IAsyncResult especificada.
FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions)	Crea un objeto Task que ejecuta una acción del método End cuando se completa la interfaz IAsyncResult especificada.
FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions, TaskScheduler)	Crea un objeto Task que ejecuta una acción del método End cuando se completa la interfaz IAsyncResult especificada.
FromAsync<TArg1,TArg2,TArg3,TResult>(Func<TArg1,TArg2,TArg3,AsyncCallback, Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object)	Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync<TArg1,TArg2,TArg3,TResult>(Func<TArg1,TArg2,TArg3,AsyncCallback, Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object, TaskCreationOptions)	Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync<TArg1,TArg2,TArg3>(Func<TArg1,TArg2,TArg3,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, TArg3, Object)	Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync<TArg1,TArg2,TArg3>(Func<TArg1,TArg2,TArg3,AsyncCallback, Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, TArg3, Object, TaskCreationOptions)	Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync<TArg1,TArg2,TResult>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object)	Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync<TArg1,TArg2,TResult>(Func<TArg1,TArg2,AsyncCallback, Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object, TaskCreationOptions)	Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync<TArg1,TArg2>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, Object)	Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync<TArg1,TArg2>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, Object, TaskCreationOptions)	Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync<TArg1,TResult>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, Object)	Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync<TArg1,TResult>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, Object, TaskCreationOptions)	Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync<TArg1>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, Object)	Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync<TArg1>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, Object, TaskCreationOptions)	Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync<TResult>(Func<AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, Object)	Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync<TResult>(Func<AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, Object, TaskCreationOptions)	Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>)	Crea un objeto Task<TResult> que ejecuta una función del método End cuando se completa la interfaz IAsyncResult especificada.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions)	Crea un objeto Task<TResult> que ejecuta una función del método End cuando se completa la interfaz IAsyncResult especificada.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions, TaskScheduler)	Crea un objeto Task<TResult> que ejecuta una función del método End cuando se completa la interfaz IAsyncResult especificada.
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
StartNew(Action)	Crea e inicia una tarea para el delegado de acción especificado.
StartNew(Action, CancellationToken)	Crea e inicia una tarea para el delegado de acción y el token de cancelación especificados.
StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)	Crea e inicia una tarea para el delegado de acción, el token de cancelación, las opciones de creación y el estado especificados.
StartNew(Action, TaskCreationOptions)	Crea e inicia una tarea para las opciones de creación y delegado de acción especificadas.
StartNew(Action<Object>, Object)	Crea e inicia una tarea para el delegado y el estado de acción especificados.
StartNew(Action<Object>, Object, CancellationToken)	Crea e inicia una tarea para el delegado de acción, el estado y el token de cancelación especificados.
StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Crea e inicia una tarea para el delegado de acción, el estado, el token de cancelación, las opciones de creación y el programador de tareas especificados.
StartNew(Action<Object>, Object, TaskCreationOptions)	Crea e inicia una tarea para el delegado de acción, el estado y las opciones de creación especificados.
StartNew<TResult>(Func<Object,TResult>, Object)	Crea e inicia una tarea de tipo `TResult` para el delegado y el estado de función especificados.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken)	Crea e inicia una tarea de tipo `TResult` para el delegado de función, el estado y el token de cancelación especificados.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Crea e inicia una tarea de tipo `TResult` para el delegado de función, el estado, el token de cancelación, las opciones de creación y el programador de tareas especificados.
StartNew<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	Crea e inicia una tarea de tipo `TResult` para las opciones de delegado de función, estado y creación especificadas.
StartNew<TResult>(Func<TResult>)	Crea e inicia una tarea de tipo `TResult` para el delegado de función especificado.
StartNew<TResult>(Func<TResult>, CancellationToken)	Crea e inicia una tarea de tipo `TResult` para el delegado de función y el token de cancelación especificados.
StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)	Crea e inicia una tarea de tipo `TResult` para el delegado de función, el token de cancelación, las opciones de creación y el programador de tareas especificados.
StartNew<TResult>(Func<TResult>, TaskCreationOptions)	Crea e inicia una tarea de tipo `TResult` para las opciones de creación y delegado de función especificadas.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)

Se aplica a

Seguridad para subprocesos

Todos los miembros públicos y protegidos de TaskFactory son seguros para subprocesos y se pueden usar simultáneamente desde varios subprocesos.

Compartir a través de