TaskFactory<TResult> Classe

Definição

generic <typename TResult>
public ref class TaskFactory

public class TaskFactory<TResult>

type TaskFactory<'Result> = class

Public Class TaskFactory(Of TResult)

Parâmetros de Tipo Genérico

Herança

Object

TaskFactory<TResult>

Exemplos

O exemplo seguinte usa a propriedade estática Factory para fazer duas chamadas ao TaskFactory<TResult>.StartNew método. A primeira tarefa devolve um array de cadeias que é preenchido com os nomes dos ficheiros no diretório MyDocuments do utilizador, enquanto a segunda devolve um array de strings preenchido com os nomes dos subdiretórios do diretório MyDocuments do utilizador. Depois chama o TaskFactory.ContinueWhenAll(Task[], Action<Task[]>) método, que apresenta informação sobre o número de ficheiros e diretórios nos arrays devolvidos pelas duas tarefas após a sua execução.

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

Observações

O .NET fornece duas fábricas para criar e agendar tarefas:

• A TaskFactory classe, que cria Task objetos Task<TResult> .

• A TaskFactory<TResult> classe, que cria Task<TResult> objetos.

A TaskFactory<TResult> aula permite-lhe fazer o seguinte:

• Crie uma tarefa e inicie-a imediatamente chamando o StartNew método. Pode chamar as sobrecargas deste método para criar e executar uma tarefa que exija argumentos não padrão.

  Warning

  A partir do .NET Framework 4.5, o método Task.Run fornece a forma mais fácil de criar uma tarefa com valores de configuração padrão e iniciá-la imediatamente.

• Crie uma tarefa que comece quando qualquer uma das tarefas de um array for concluída, chamando o ContinueWhenAny método ou ContinueWhenAny .

• Crie uma tarefa que comece quando todas as tarefas de um array forem concluídas, chamando o ContinueWhenAll método ou.ContinueWhenAll

A propriedade estática Task<TResult>.Factory devolve um objeto por defeito TaskFactory<TResult> . Também pode chamar um dos TaskFactory<TResult> construtores de classes para configurar os Task<TResult> objetos que a TaskFactory<TResult> classe cria. O exemplo seguinte configura um novo TaskFactory<TResult> objeto para criar tarefas que tenham um token de cancelamento especificado, opções de criação de tarefas, opções de continuação e um agendador de tarefas 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

Na maioria dos casos, não é necessário instanciar uma nova TaskFactory<TResult> instância. Em vez disso, pode usar a propriedade estática Task<TResult>.Factory , que devolve um objeto de fábrica que usa valores por defeito. Pode então chamar os seus métodos para iniciar novas tarefas ou definir continuações de tarefas. Para ilustração, veja o exemplo.

Segurança de Thread

Todos os membros públicos e protegidos são TaskFactory<TResult> seguros para threads e podem ser usados simultaneamente a partir de múltiplos threads.

Ver também

• Biblioteca paralela de tarefas (TPL)