TaskFactory<TResult> Clase

Definición

Espacio de nombres:

System.Threading.Tasks

Ensamblado:

System.Runtime.dll

Source:

FutureFactory.cs

Proporciona compatibilidad para crear y programar objetos Task<TResult>.

generic <typename TResult>
public ref class TaskFactory

public class TaskFactory<TResult>

type TaskFactory<'Result> = class

Public Class TaskFactory(Of TResult)

Parámetros de tipo

TResult

Valor devuelto de los objetos Task<TResult> creados por los métodos de esta clase.

Herencia

Object

TaskFactory<TResult>

Ejemplos

En el ejemplo siguiente se usa la propiedad estática Factory para realizar dos llamadas al TaskFactory<TResult>.StartNew método . La primera tarea devuelve una matriz de cadenas que se rellena con los nombres de los archivos en el directorio MyDocuments del usuario, mientras que el segundo devuelve una matriz de cadenas que se rellena 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 de las matrices devueltas por las dos tareas después de que hayan completado la ejecución.

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

Comentarios

.NET proporciona dos generadores para crear y programar tareas:

• Clase TaskFactory , que crea Task objetos y Task<TResult> .

• Clase TaskFactory<TResult> , que crea Task<TResult> objetos .

La TaskFactory<TResult> clase permite hacer lo siguiente:

• Cree una tarea e iníciela inmediatamente llamando al StartNew método . 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.

• Cree una tarea que se inicie cuando se haya completado cualquiera de las tareas de una matriz llamando al ContinueWhenAny método o ContinueWhenAny .

• Cree una tarea que se inicie cuando todas las tareas de una matriz se hayan completado llamando al ContinueWhenAll método o ContinueWhenAll .

La propiedad estática Task<TResult>.Factory devuelve un objeto predeterminado TaskFactory<TResult> . También puede llamar a uno de los TaskFactory<TResult> constructores de clase para configurar los Task<TResult> objetos que crea la TaskFactory<TResult> clase. En el ejemplo siguiente se configura un nuevo TaskFactory<TResult> 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;

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

En la mayoría de los casos, no es necesario crear instancias de una nueva TaskFactory<TResult> instancia. En su lugar, puede usar la propiedad estática Task<TResult>.Factory , 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<TResult>()	Inicializa una instancia de TaskFactory<TResult> con la configuración predeterminada.
TaskFactory<TResult>(CancellationToken)	Inicializa una instancia de TaskFactory<TResult> con la configuración predeterminada.
TaskFactory<TResult>(CancellationToken, TaskCreationOptions, TaskContinuationOptions, TaskScheduler)	Inicializa una instancia de TaskFactory<TResult> con la configuración especificada.
TaskFactory<TResult>(TaskCreationOptions, TaskContinuationOptions)	Inicializa una instancia de TaskFactory<TResult> con la configuración especificada.
TaskFactory<TResult>(TaskScheduler)	Inicializa una instancia de TaskFactory<TResult> con la configuración especificada.

Propiedades

CancellationToken	Obtiene el token de cancelación predeterminado para este generador de tareas.
ContinuationOptions	Obtiene el valor de enumeración TaskContinuationOptions para este generador de tareas.
CreationOptions	Obtiene el valor de enumeración TaskCreationOptions para este generador de tareas.
Scheduler	Obtiene el programador de tareas para este generador de tareas.

Métodos

ContinueWhenAll(Task[], Func<Task[],TResult>)	Crea una tarea de continuación que se iniciará cuando se complete el conjunto de tareas proporcionado.
ContinueWhenAll(Task[], Func<Task[],TResult>, CancellationToken)	Crea una tarea de continuación que se iniciará cuando se complete el conjunto de tareas proporcionado.
ContinueWhenAll(Task[], Func<Task[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una tarea de continuación que se iniciará cuando se complete el conjunto de tareas proporcionado.
ContinueWhenAll(Task[], Func<Task[],TResult>, TaskContinuationOptions)	Crea una tarea de continuación que se iniciará cuando se complete el conjunto de tareas proporcionado.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>)	Crea una tarea de continuación que se iniciará cuando se complete el conjunto de tareas proporcionado.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken)	Crea una tarea de continuación que se iniciará cuando se complete el conjunto de tareas proporcionado.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una tarea de continuación que se iniciará cuando se complete el conjunto de tareas proporcionado.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, TaskContinuationOptions)	Crea una tarea de continuación que se iniciará cuando se complete el conjunto de tareas proporcionado.
ContinueWhenAny(Task[], Func<Task,TResult>)	Crea una tarea de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny(Task[], Func<Task,TResult>, CancellationToken)	Crea una tarea de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny(Task[], Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una tarea de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny(Task[], Func<Task,TResult>, TaskContinuationOptions)	Crea una tarea de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>)	Crea una tarea de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken)	Crea una tarea de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una tarea de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, TaskContinuationOptions)	Crea una tarea 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>, Func<IAsyncResult,TResult>, Object)	Crea una tarea 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>, Func<IAsyncResult,TResult>, Object, TaskCreationOptions)	Crea una tarea que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
FromAsync(IAsyncResult, Func<IAsyncResult,TResult>)	Crea una tarea que ejecuta una función del método End cuando se completa el IAsyncResult especificado.
FromAsync(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions)	Crea una tarea que ejecuta una función del método End cuando se completa el IAsyncResult especificado.
FromAsync(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions, TaskScheduler)	Crea una tarea que ejecuta una función del método End cuando se completa el IAsyncResult especificado.
FromAsync<TArg1,TArg2,TArg3>(Func<TArg1,TArg2,TArg3,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object)	Crea una tarea 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>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object, TaskCreationOptions)	Crea una tarea 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>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object)	Crea una tarea 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>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object, TaskCreationOptions)	Crea una tarea 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>, Func<IAsyncResult,TResult>, TArg1, Object)	Crea una tarea 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>, Func<IAsyncResult,TResult>, TArg1, Object, TaskCreationOptions)	Crea una tarea que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.
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(Func<Object,TResult>, Object)	Crea e inicia una tarea.
StartNew(Func<Object,TResult>, Object, CancellationToken)	Crea e inicia una tarea.
StartNew(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Crea e inicia una tarea.
StartNew(Func<Object,TResult>, Object, TaskCreationOptions)	Crea e inicia una tarea.
StartNew(Func<TResult>)	Crea e inicia una tarea.
StartNew(Func<TResult>, CancellationToken)	Crea e inicia una tarea.
StartNew(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)	Crea e inicia una tarea.
StartNew(Func<TResult>, TaskCreationOptions)	Crea e inicia una tarea.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)

Seguridad para subprocesos

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

Consulte también

• Biblioteca TPL