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

Herança

Object

TaskFactory<TResult>

Exemplos

O exemplo a seguir usa a propriedade estática Factory para fazer duas chamadas ao TaskFactory<TResult>.StartNew método. A primeira tarefa retorna uma matriz de cadeia de caracteres que é preenchida com os nomes dos arquivos no diretório MyDocuments do usuário, enquanto a segunda retorna uma matriz de cadeia de caracteres que é preenchida com os nomes de subdiretórios do diretório MyDocuments do usuário. Em seguida, ele chama o TaskFactory.ContinueWhenAll(Task[], Action<Task[]>) método, que exibe informações sobre o número de arquivos e diretórios nas matrizes retornadas pelas duas tarefas após a conclusão da 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

Comentários

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

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

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

A TaskFactory<TResult> classe permite que você faça o seguinte:

• Crie uma tarefa e inicie-a imediatamente chamando o StartNew método. Você pode chamar as sobrecargas desse método para criar e executar uma tarefa que exige argumentos não padrão.

  Aviso

  Começando com .NET Framework 4.5, o Task.Run método fornece a maneira 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 em uma matriz for concluída chamando o método ou ContinueWhenAny o ContinueWhenAny método.

• Crie uma tarefa que comece quando todas as tarefas em uma matriz tiverem sido concluídas chamando o método ou ContinueWhenAll o ContinueWhenAll método.

A propriedade estática Task<TResult>.Factory retorna um objeto padrão TaskFactory<TResult> . Você também pode chamar um dos construtores de TaskFactory<TResult> classe para configurar os Task<TResult> objetos que a TaskFactory<TResult> classe cria. O exemplo a seguir configura um novo TaskFactory<TResult> objeto para criar tarefas que têm um token de cancelamento especificado, opções de criação de tarefa, 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, você não precisa instanciar uma nova TaskFactory<TResult> instância. Em vez disso, você pode usar a propriedade estática Task<TResult>.Factory , que retorna um objeto de fábrica que usa valores padrão. Em seguida, você pode chamar seus métodos para iniciar novas tarefas ou definir continuações de tarefa. Para obter uma ilustração, consulte o exemplo.

Construtores

Propriedades

Métodos

Aplica-se a

Acesso thread-safe

Todos os membros públicos e protegidos TaskFactory<TResult> são thread-safe e podem ser usados simultaneamente de vários threads.

Confira também

• Biblioteca de tarefas paralelas (TPL)