TaskFactory<TResult> Clase

Definición

generic <typename TResult>
public ref class TaskFactory

public class TaskFactory<TResult>

type TaskFactory<'Result> = class

Public Class TaskFactory(Of TResult)

Parámetros de tipo

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

Propiedades

Métodos

Se aplica a

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