Task.Run Método

Referência

Definição

Namespace:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Enfileira o trabalho especificado para ser executado no ThreadPool e retorna uma tarefa ou Task<TResult> identificador para esse trabalho.

Sobrecargas

Run(Func<Task>, CancellationToken)	Enfileira o trabalho especificado para ser executado no pool de threads e retorna um proxy para a tarefa retornada por `function`. Um token de cancelamento permite que o trabalho seja cancelado se ele ainda não tiver sido iniciado.
Run(Action, CancellationToken)	Enfileira o trabalho especificado para ser executado no pool de threads e retorna um objeto Task que representa esse trabalho. Um token de cancelamento permite que o trabalho seja cancelado se ele ainda não tiver sido iniciado.
Run(Func<Task>)	Enfileira o trabalho especificado para ser executado no pool de threads e retorna um proxy para a tarefa retornada por `function`.
Run(Action)	Enfileira o trabalho especificado para ser executado no pool de threads e retorna um objeto Task que representa esse trabalho.
Run<TResult>(Func<Task<TResult>>)	Enfileira o trabalho especificado para execução no pool de threads e retorna um proxy para o `Task(TResult)` retornado por `function`. Um token de cancelamento permite que o trabalho seja cancelado se ele ainda não tiver sido iniciado.
Run<TResult>(Func<TResult>)	Enfileira o trabalho especificado para ser executado no pool de threads e retorna um objeto Task<TResult> que representa esse trabalho. Um token de cancelamento permite que o trabalho seja cancelado se ele ainda não tiver sido iniciado.
Run<TResult>(Func<Task<TResult>>, CancellationToken)	Enfileira o trabalho especificado para execução no pool de threads e retorna um proxy para o `Task(TResult)` retornado por `function`.
Run<TResult>(Func<TResult>, CancellationToken)	Enfileira o trabalho especificado para ser executado no pool de threads e retorna um objeto `Task(TResult)` que representa esse trabalho.

Comentários

O método Run fornece um conjunto de sobrecargas que facilitam o início de uma tarefa usando valores padrão. É uma alternativa leve às sobrecargas de StartNew.

Run(Func<Task>, CancellationToken)

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Enfileira o trabalho especificado para ser executado no pool de threads e retorna um proxy para a tarefa retornada por function. Um token de cancelamento permite que o trabalho seja cancelado se ele ainda não tiver sido iniciado.

public:
 static System::Threading::Tasks::Task ^ Run(Func<System::Threading::Tasks::Task ^> ^ function, System::Threading::CancellationToken cancellationToken);

public static System.Threading.Tasks.Task Run (Func<System.Threading.Tasks.Task> function, System.Threading.CancellationToken cancellationToken);

public static System.Threading.Tasks.Task Run (Func<System.Threading.Tasks.Task?> function, System.Threading.CancellationToken cancellationToken);

static member Run : Func<System.Threading.Tasks.Task> * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Shared Function Run (function As Func(Of Task), cancellationToken As CancellationToken) As Task

Parâmetros

function: Func<Task>

O trabalho a ser executado de forma assíncrona.

cancellationToken: CancellationToken

Um token de cancelamento que pode ser usado para cancelar o trabalho se ele ainda não tiver sido iniciado. Run(Func<Task>, CancellationToken) não passa cancellationToken para action.

Retornos

Task

Uma tarefa que representa um proxy para a tarefa retornada por function.

Exceções

ArgumentNullException

O parâmetro function foi null.

OperationCanceledException

A tarefa foi cancelada. Essa exceção é armazenada na tarefa retornada.

ObjectDisposedException

O CancellationTokenSource associado ao cancellationToken foi descartado.

TaskCanceledException

A tarefa foi cancelada.

Comentários

Para obter informações sobre como lidar com exceções geradas por operações de tarefa, consulte de Tratamento de Exceções.

Confira também

de cancelamento de tarefa
tratamento de exceção (biblioteca paralela da tarefa)

Aplica-se a

Run(Action, CancellationToken)

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Enfileira o trabalho especificado para ser executado no pool de threads e retorna um objeto Task que representa esse trabalho. Um token de cancelamento permite que o trabalho seja cancelado se ele ainda não tiver sido iniciado.

public:
 static System::Threading::Tasks::Task ^ Run(Action ^ action, System::Threading::CancellationToken cancellationToken);

public static System.Threading.Tasks.Task Run (Action action, System.Threading.CancellationToken cancellationToken);

static member Run : Action * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Shared Function Run (action As Action, cancellationToken As CancellationToken) As Task

Parâmetros

action: Action

O trabalho a ser executado de forma assíncrona.

cancellationToken: CancellationToken

Um token de cancelamento que pode ser usado para cancelar o trabalho se ele ainda não tiver sido iniciado. Run(Action, CancellationToken) não passa cancellationToken para action.

Retornos

Task

Uma tarefa que representa o trabalho enfileirado para execução no pool de threads.

Exceções

ArgumentNullException

O parâmetro action foi null.

OperationCanceledException

A tarefa foi cancelada. Essa exceção é armazenada na tarefa retornada.

ObjectDisposedException

O CancellationTokenSource associado ao cancellationToken foi descartado.

TaskCanceledException

A tarefa foi cancelada.

Exemplos

O exemplo a seguir chama o método Run(Action, CancellationToken) para criar uma tarefa que itera os arquivos no diretório C:\Windows\System32. A expressão lambda chama o método Parallel.ForEach para adicionar informações sobre cada arquivo a um objeto List<T>. Cada tarefa aninhada desanexada invocada pelo loop Parallel.ForEach verifica o estado do token de cancelamento e, se o cancelamento for solicitado, chamará o método CancellationToken.ThrowIfCancellationRequested. O método CancellationToken.ThrowIfCancellationRequested gera uma exceção OperationCanceledException que é tratada em um bloco de catch quando o thread de chamada chama o método Task.Wait.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static async Task Main()
   {
      var tokenSource = new CancellationTokenSource();
      var token = tokenSource.Token;
      var files = new List<Tuple<string, string, long, DateTime>>();

      var t = Task.Run( () => { string dir = "C:\\Windows\\System32\\";
                                object obj = new Object();
                                if (Directory.Exists(dir)) {
                                   Parallel.ForEach(Directory.GetFiles(dir),
                                   f => {
                                           if (token.IsCancellationRequested)
                                              token.ThrowIfCancellationRequested();
                                           var fi = new FileInfo(f);
                                           lock(obj) {
                                              files.Add(Tuple.Create(fi.Name, fi.DirectoryName, fi.Length, fi.LastWriteTimeUtc));          
                                           }
                                      });
                                 }
                              }
                        , token);
      await Task.Yield();
      tokenSource.Cancel();
      try {
         await t;
         Console.WriteLine("Retrieved information for {0} files.", files.Count);
      }
      catch (AggregateException e) {
         Console.WriteLine("Exception messages:");
         foreach (var ie in e.InnerExceptions)
            Console.WriteLine("   {0}: {1}", ie.GetType().Name, ie.Message);

         Console.WriteLine("\nTask status: {0}", t.Status);       
      }
      finally {
         tokenSource.Dispose();
      }
   }
}
// The example displays the following output:
//       Exception messages:
//          TaskCanceledException: A task was canceled.
//          TaskCanceledException: A task was canceled.
//          ...
//       
//       Task status: Canceled

open System
open System.IO
open System.Threading
open System.Threading.Tasks

let main =
    task {
        use tokenSource = new CancellationTokenSource()
        let token = tokenSource.Token
        let files = ResizeArray()

        let t =
            Task.Run(
                (fun () ->
                    let dir = "C:\\Windows\\System32\\"
                    let obj = obj ()

                    if Directory.Exists dir then
                        Parallel.ForEach(
                            Directory.GetFiles dir,
                            (fun f ->
                                if token.IsCancellationRequested then
                                    token.ThrowIfCancellationRequested()

                                let fi = FileInfo f
                                lock obj (fun () -> files.Add(fi.Name, fi.DirectoryName, fi.Length, fi.LastWriteTimeUtc)))
                        )
                        |> ignore),
                token
            )

        do! Task.Yield()
        tokenSource.Cancel()

        try
            do! t
            printfn $"Retrieved information for {files.Count} files."

        with :? AggregateException as e ->
            printfn "Exception messages:"

            for ie in e.InnerExceptions do
                printfn $"   {ie.GetType().Name}: {ie.Message}"

            printfn $"Task status: {t.Status}"
    }

main.Wait()


// The example displays the following output:
//       Exception messages:
//          TaskCanceledException: A task was canceled.
//          TaskCanceledException: A task was canceled.
//          ...
//
//       Task status: Canceled

Imports System.Collections.Generic
Imports System.IO
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tokenSource As New CancellationTokenSource()
      Dim token As CancellationToken = tokenSource.Token
      Dim files As New List(Of Tuple(Of String, String, Long, Date))()

      Dim t As Task = Task.Run( Sub()
                                   Dim dir As String = "C:\Windows\System32\"
                                   Dim obj As New Object()
                                   If Directory.Exists(dir)Then
                                      Parallel.ForEach(Directory.GetFiles(dir), 
                                         Sub(f)
                                            If token.IsCancellationRequested Then
                                               token.ThrowIfCancellationRequested()
                                            End If  
                                            Dim fi As New FileInfo(f)
                                            SyncLock(obj)
                                              files.Add(Tuple.Create(fi.Name, fi.DirectoryName, fi.Length, fi.LastWriteTimeUtc))          
                                            End SyncLock
                                         End Sub)
                                   End If
                                End Sub, token)
      tokenSource.Cancel()
      Try
         t.Wait() 
         Console.WriteLine("Retrieved information for {0} files.", files.Count)
      Catch e As AggregateException
         Console.WriteLine("Exception messages:")
         For Each ie As Exception In e.InnerExceptions
            Console.WriteLine("   {0}:{1}", ie.GetType().Name, ie.Message)
         Next
         Console.WriteLine()
         Console.WriteLine("Task status: {0}", t.Status)       
      Finally
         tokenSource.Dispose()
      End Try
   End Sub
End Module
' The example displays the following output:
'       Exception messages:
'          TaskCanceledException: A task was canceled.
'       
'       Task status: Canceled

Comentários

Se o cancelamento for solicitado antes do início da execução da tarefa, a tarefa não será executada. Em vez disso, ele é definido como o estado Canceled e gera uma exceção TaskCanceledException.

O método Run(Action, CancellationToken) é uma alternativa mais simples ao método TaskFactory.StartNew(Action, CancellationToken). Ele cria uma tarefa com os seguintes valores padrão:

Seu valor de propriedade CreationOptions é TaskCreationOptions.DenyChildAttach.
Ele usa o agendador de tarefas padrão.

Para obter informações sobre como lidar com exceções geradas por operações de tarefa, consulte de Tratamento de Exceções.

Confira também

tratamento de exceção (biblioteca paralela da tarefa)

Aplica-se a

Run(Func<Task>)

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Enfileira o trabalho especificado para ser executado no pool de threads e retorna um proxy para a tarefa retornada por function.

public:
 static System::Threading::Tasks::Task ^ Run(Func<System::Threading::Tasks::Task ^> ^ function);

public static System.Threading.Tasks.Task Run (Func<System.Threading.Tasks.Task> function);

public static System.Threading.Tasks.Task Run (Func<System.Threading.Tasks.Task?> function);

static member Run : Func<System.Threading.Tasks.Task> -> System.Threading.Tasks.Task

Public Shared Function Run (function As Func(Of Task)) As Task

Parâmetros

function: Func<Task>

O trabalho a ser executado de forma assíncrona.

Retornos

Task

Uma tarefa que representa um proxy para a tarefa retornada por function.

Exceções

ArgumentNullException

O parâmetro function foi null.

Comentários

Para obter informações sobre como lidar com exceções geradas por operações de tarefa, consulte de Tratamento de Exceções.

Confira também

tratamento de exceção (biblioteca paralela da tarefa)

Aplica-se a

Run(Action)

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Enfileira o trabalho especificado para ser executado no pool de threads e retorna um objeto Task que representa esse trabalho.

public:
 static System::Threading::Tasks::Task ^ Run(Action ^ action);

public static System.Threading.Tasks.Task Run (Action action);

static member Run : Action -> System.Threading.Tasks.Task

Public Shared Function Run (action As Action) As Task

Parâmetros

action: Action

O trabalho a ser executado de forma assíncrona.

Retornos

Task

Uma tarefa que representa o trabalho enfileirado a ser executado no ThreadPool.

Exceções

ArgumentNullException

O parâmetro action foi null.

Exemplos

O exemplo a seguir define um método ShowThreadInfo que exibe o Thread.ManagedThreadId do thread atual. Ele é chamado diretamente do thread do aplicativo e é chamado do delegado Action passado para o método Run(Action).

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      ShowThreadInfo("Application");

      var t = Task.Run(() => ShowThreadInfo("Task") );
      t.Wait();
   }

   static void ShowThreadInfo(String s)
   {
      Console.WriteLine("{0} thread ID: {1}",
                        s, Thread.CurrentThread.ManagedThreadId);
   }
}
// The example displays the following output:
//       Application thread ID: 1
//       Task thread ID: 3

open System.Threading
open System.Threading.Tasks

let showThreadInfo s =
    printfn $"%s{s} thread ID: {Thread.CurrentThread.ManagedThreadId}"

showThreadInfo "Application"

let t = Task.Run(fun () -> showThreadInfo "Task")
t.Wait()

// The example displays the following output:
//       Application thread ID: 1
//       Task thread ID: 3

Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ShowThreadInfo("Application")

      Dim t As Task = Task.Run(Sub() ShowThreadInfo("Task") )
      t.Wait()
   End Sub
   
   Private Sub ShowThreadInfo(s As String)
      Console.WriteLine("{0} Thread ID: {1}",
                        s, Thread.CurrentThread.ManagedThreadId)
   End Sub
End Module
' The example displays output like the following:
'    Application thread ID: 1
'    Task thread ID: 3

O exemplo a seguir é semelhante ao anterior, exceto que ele usa uma expressão lambda para definir o código que a tarefa deve executar.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("Application thread ID: {0}",
                        Thread.CurrentThread.ManagedThreadId);
      var t = Task.Run(() => {  Console.WriteLine("Task thread ID: {0}",
                                   Thread.CurrentThread.ManagedThreadId);
                             } );
      t.Wait();
   }
}
// The example displays the following output:
//       Application thread ID: 1
//       Task thread ID: 3

open System.Threading
open System.Threading.Tasks

printfn $"Application thread ID: {Thread.CurrentThread.ManagedThreadId}"
let t = Task.Run(fun () -> printfn $"Task thread ID: {Thread.CurrentThread.ManagedThreadId}")
t.Wait()

// The example displays the following output:
//       Application thread ID: 1
//       Task thread ID: 3

Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Console.WriteLine("Application thread ID: {0}",
                        Thread.CurrentThread.ManagedThreadId)
      Dim t As Task = Task.Run(Sub()
                                  Console.WriteLine("Task thread ID: {0}",
                                                    Thread.CurrentThread.ManagedThreadId)
                               End Sub)
      t.Wait()
   End Sub
End Module
' The example displays output like the following:
'    Application thread ID: 1
'    Task thread ID: 3

Os exemplos mostram que a tarefa assíncrona é executada em um thread diferente do thread principal do aplicativo.

A chamada para o método Wait garante que a tarefa seja concluída e exibe sua saída antes do fim do aplicativo. Caso contrário, é possível que o método Main seja concluído antes da conclusão da tarefa.

O exemplo a seguir ilustra o método Run(Action). Ele define uma matriz de nomes de diretório e inicia uma tarefa separada para recuperar os nomes de arquivo em cada diretório. Todas as tarefas gravam os nomes de arquivo em um único objeto ConcurrentBag<T>. Em seguida, o exemplo chama o método WaitAll(Task[]) para garantir que todas as tarefas tenham sido concluídas e, em seguida, exibe uma contagem do número total de nomes de arquivo gravados no objeto ConcurrentBag<T>.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var list = new ConcurrentBag<string>();
      string[] dirNames = { ".", ".." };
      List<Task> tasks = new List<Task>();
      foreach (var dirName in dirNames) {
         Task t = Task.Run( () => { foreach(var path in Directory.GetFiles(dirName)) 
                                       list.Add(path); }  );
         tasks.Add(t);
      }
      Task.WaitAll(tasks.ToArray());
      foreach (Task t in tasks)
         Console.WriteLine("Task {0} Status: {1}", t.Id, t.Status);
         
      Console.WriteLine("Number of files read: {0}", list.Count);
   }
}
// The example displays output like the following:
//       Task 1 Status: RanToCompletion
//       Task 2 Status: RanToCompletion
//       Number of files read: 23

open System.Collections.Concurrent
open System.IO
open System.Threading.Tasks

let list = ConcurrentBag<string>()
let dirNames = [ "."; ".." ]
let tasks = ResizeArray()

for dirName in dirNames do
    let t =
        Task.Run(fun () ->
            for path in Directory.GetFiles dirName do
                list.Add path)

    tasks.Add t

tasks.ToArray() |> Task.WaitAll

for t in tasks do
    printfn $"Task {t.Id} Status: {t.Status}"

printfn $"Number of files read: {list.Count}"

// The example displays output like the following:
//       Task 1 Status: RanToCompletion
//       Task 2 Status: RanToCompletion
//       Number of files read: 23

Imports System.Collections.Concurrent
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim list As New ConcurrentBag(Of String)()
      Dim dirNames() As String = { ".", ".." }
      Dim tasks As New List(Of Task)()
      For Each dirName In dirNames 
         Dim t As Task = Task.Run( Sub()
                                      For Each path In Directory.GetFiles(dirName) 
                                         list.Add(path)
                                      Next
                                   End Sub  )
         tasks.Add(t)
      Next
      Task.WaitAll(tasks.ToArray())
      For Each t In tasks
         Console.WriteLine("Task {0} Status: {1}", t.Id, t.Status)
      Next   
      Console.WriteLine("Number of files read: {0}", list.Count)
   End Sub
End Module
' The example displays output like the following:
'       Task 1 Status: RanToCompletion
'       Task 2 Status: RanToCompletion
'       Number of files read: 23

Comentários

O método Run permite que você crie e execute uma tarefa em uma única chamada de método e é uma alternativa mais simples ao método StartNew. Ele cria uma tarefa com os seguintes valores padrão:

Seu token de cancelamento é CancellationToken.None.
Seu valor de propriedade CreationOptions é TaskCreationOptions.DenyChildAttach.
Ele usa o agendador de tarefas padrão.

Para obter informações sobre como lidar com exceções geradas por operações de tarefa, consulte de Tratamento de Exceções.

Confira também

tratamento de exceção (biblioteca paralela da tarefa)

Aplica-se a

Run<TResult>(Func<Task<TResult>>)

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Enfileira o trabalho especificado para execução no pool de threads e retorna um proxy para o Task(TResult) retornado por function. Um token de cancelamento permite que o trabalho seja cancelado se ele ainda não tiver sido iniciado.

public:
generic <typename TResult>
 static System::Threading::Tasks::Task<TResult> ^ Run(Func<System::Threading::Tasks::Task<TResult> ^> ^ function);

public static System.Threading.Tasks.Task<TResult> Run<TResult> (Func<System.Threading.Tasks.Task<TResult>> function);

public static System.Threading.Tasks.Task<TResult> Run<TResult> (Func<System.Threading.Tasks.Task<TResult>?> function);

static member Run : Func<System.Threading.Tasks.Task<'Result>> -> System.Threading.Tasks.Task<'Result>

Public Shared Function Run(Of TResult) (function As Func(Of Task(Of TResult))) As Task(Of TResult)

Parâmetros de tipo

TResult

O tipo do resultado retornado pela tarefa proxy.

Parâmetros

function: Func<Task<TResult>>

O trabalho a ser executado de forma assíncrona.

Retornos

Task<TResult>

Um Task(TResult) que representa um proxy para o Task(TResult) retornado por function.

Exceções

ArgumentNullException

O parâmetro function foi null.

Comentários

Para obter informações sobre como lidar com exceções geradas por operações de tarefa, consulte de Tratamento de Exceções.

Confira também

tratamento de exceção (biblioteca paralela da tarefa)

Aplica-se a

Run<TResult>(Func<TResult>)

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Enfileira o trabalho especificado para ser executado no pool de threads e retorna um objeto Task<TResult> que representa esse trabalho. Um token de cancelamento permite que o trabalho seja cancelado se ele ainda não tiver sido iniciado.

public:
generic <typename TResult>
 static System::Threading::Tasks::Task<TResult> ^ Run(Func<TResult> ^ function);

public static System.Threading.Tasks.Task<TResult> Run<TResult> (Func<TResult> function);

static member Run : Func<'Result> -> System.Threading.Tasks.Task<'Result>

Public Shared Function Run(Of TResult) (function As Func(Of TResult)) As Task(Of TResult)

Parâmetros de tipo

TResult

O tipo de retorno da tarefa.

Parâmetros

function: Func<TResult>

O trabalho a ser executado de forma assíncrona.

Retornos

Task<TResult>

Um objeto de tarefa que representa o trabalho enfileirado para execução no pool de threads.

Exceções

ArgumentNullException

O parâmetro function é null.

Exemplos

O exemplo a seguir conta o número aproximado de palavras em arquivos de texto que representam livros publicados. Cada tarefa é responsável por abrir um arquivo, ler todo o conteúdo de forma assíncrona e calcular a contagem de palavras usando uma expressão regular. O método WaitAll(Task[]) é chamado para garantir que todas as tarefas tenham sido concluídas antes de exibir a contagem de palavras de cada livro no console.

using System;
using System.IO;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      string pattern = @"\p{P}*\s+";
      string[] titles = { "Sister Carrie", "The Financier" };
      Task<int>[] tasks = new Task<int>[titles.Length];

      for (int ctr = 0; ctr < titles.Length; ctr++) {
         string s = titles[ctr];
         tasks[ctr] = Task.Run( () => {
                                   // Number of words.
                                   int nWords = 0;
                                   // Create filename from title.
                                   string fn = s + ".txt";
                                   if (File.Exists(fn)) {
                                      StreamReader sr = new StreamReader(fn);
                                      string input = sr.ReadToEndAsync().Result;
                                      nWords = Regex.Matches(input, pattern).Count;
                                   }
                                   return nWords;
                                } );
      }
      Task.WaitAll(tasks);

      Console.WriteLine("Word Counts:\n");
      for (int ctr = 0; ctr < titles.Length; ctr++)
         Console.WriteLine("{0}: {1,10:N0} words", titles[ctr], tasks[ctr].Result);
   }
}
// The example displays the following output:
//       Sister Carrie:    159,374 words
//       The Financier:    196,362 words

open System
open System.IO
open System.Text.RegularExpressions
open System.Threading.Tasks

let pattern = @"\p{P}*\s+"
let titles = [| "Sister Carrie"; "The Financier" |]

let tasks =
    Array.map (fun title ->
        Task.Run(fun () ->
            // Create filename from title.
            let fn = title + ".txt"

            if File.Exists fn then
                use sr = new StreamReader(fn)
                let input = sr.ReadToEndAsync().Result
                Regex.Matches(input, pattern).Count
            else
                0)) titles

tasks |> Seq.cast |> Array.ofSeq |> Task.WaitAll

printfn "Word Counts:\n"

for i = 0 to tasks.Length - 1 do
    printfn $"%s{titles.[i]}: %10d{tasks.[i].Result} words"

// The example displays the following output:
//       Sister Carrie:    159,374 words
//       The Financier:    196,362 words

Imports System.IO
Imports System.Text.RegularExpressions
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim pattern As String = "\p{P}*\s+"
      Dim titles() As String = { "Sister Carrie",
                                 "The Financier" }
      Dim tasks(titles.Length - 1) As Task(Of Integer)

      For ctr As Integer = 0 To titles.Length - 1
         Dim s As String = titles(ctr)
         tasks(ctr) = Task.Run( Function()
                                   ' Number of words.
                                   Dim nWords As Integer = 0
                                   ' Create filename from title.
                                   Dim fn As String = s + ".txt"
                                   If File.Exists(fn) Then
                                      Dim sr As New StreamReader(fn)
                                      Dim input As String = sr.ReadToEndAsync().Result
                                      nWords = Regex.Matches(input, pattern).Count
                                   End If
                                   Return nWords
                                End Function)
      Next
      Task.WaitAll(tasks)

      Console.WriteLine("Word Counts:")
      Console.WriteLine()
      For ctr As Integer = 0 To titles.Length - 1
         Console.WriteLine("{0}: {1,10:N0} words", titles(ctr), tasks(ctr).Result)
      Next
   End Sub
End Module
' The example displays the following output:
'       Sister Carrie:    159,374 words
'       The Financier:    196,362 words

A expressão regular \p{P}*\s+ corresponde a zero, um ou mais caracteres de pontuação seguidos por um ou mais caracteres de espaço em branco. Ele pressupõe que o número total de correspondências é igual à contagem aproximada de palavras.

Comentários

O método Run é uma alternativa mais simples ao método TaskFactory.StartNew(Action). Ele cria uma tarefa com os seguintes valores padrão:

Seu token de cancelamento é CancellationToken.None.
Seu valor de propriedade CreationOptions é TaskCreationOptions.DenyChildAttach.
Ele usa o agendador de tarefas padrão.

Para obter informações sobre como lidar com exceções geradas por operações de tarefa, consulte de Tratamento de Exceções.

Confira também

tratamento de exceção (biblioteca paralela da tarefa)

Aplica-se a

Run<TResult>(Func<Task<TResult>>, CancellationToken)

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Enfileira o trabalho especificado para execução no pool de threads e retorna um proxy para o Task(TResult) retornado por function.

public:
generic <typename TResult>
 static System::Threading::Tasks::Task<TResult> ^ Run(Func<System::Threading::Tasks::Task<TResult> ^> ^ function, System::Threading::CancellationToken cancellationToken);

public static System.Threading.Tasks.Task<TResult> Run<TResult> (Func<System.Threading.Tasks.Task<TResult>> function, System.Threading.CancellationToken cancellationToken);

public static System.Threading.Tasks.Task<TResult> Run<TResult> (Func<System.Threading.Tasks.Task<TResult>?> function, System.Threading.CancellationToken cancellationToken);

static member Run : Func<System.Threading.Tasks.Task<'Result>> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Shared Function Run(Of TResult) (function As Func(Of Task(Of TResult)), cancellationToken As CancellationToken) As Task(Of TResult)

Parâmetros de tipo

TResult

O tipo do resultado retornado pela tarefa proxy.

Parâmetros

function: Func<Task<TResult>>

O trabalho a ser executado de forma assíncrona.

cancellationToken: CancellationToken

Um token de cancelamento que pode ser usado para cancelar o trabalho se ele ainda não tiver sido iniciado. Run<TResult>(Func<Task<TResult>>, CancellationToken) não passa cancellationToken para action.

Retornos

Task<TResult>

Um Task(TResult) que representa um proxy para o Task(TResult) retornado por function.

Exceções

ArgumentNullException

O parâmetro function foi null.

OperationCanceledException

A tarefa foi cancelada. Essa exceção é armazenada na tarefa retornada.

ObjectDisposedException

O CancellationTokenSource associado ao cancellationToken foi descartado.

TaskCanceledException

A tarefa foi cancelada.

Comentários

Para obter informações sobre como lidar com exceções geradas por operações de tarefa, consulte de Tratamento de Exceções.

Confira também

de cancelamento de tarefa
tratamento de exceção (biblioteca paralela da tarefa)

Aplica-se a

Run<TResult>(Func<TResult>, CancellationToken)

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Enfileira o trabalho especificado para ser executado no pool de threads e retorna um objeto Task(TResult) que representa esse trabalho.

public:
generic <typename TResult>
 static System::Threading::Tasks::Task<TResult> ^ Run(Func<TResult> ^ function, System::Threading::CancellationToken cancellationToken);

public static System.Threading.Tasks.Task<TResult> Run<TResult> (Func<TResult> function, System.Threading.CancellationToken cancellationToken);

static member Run : Func<'Result> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Shared Function Run(Of TResult) (function As Func(Of TResult), cancellationToken As CancellationToken) As Task(Of TResult)

Parâmetros de tipo

TResult

O tipo de resultado da tarefa.

Parâmetros

function: Func<TResult>

O trabalho a ser executado de forma assíncrona.

cancellationToken: CancellationToken

Um token de cancelamento que pode ser usado para cancelar o trabalho se ele ainda não tiver sido iniciado. Run<TResult>(Func<TResult>, CancellationToken) não passa cancellationToken para action.

Retornos

Task<TResult>

Um Task(TResult) que representa o trabalho enfileirado para execução no pool de threads.

Exceções

ArgumentNullException

O parâmetro function é null.

OperationCanceledException

A tarefa foi cancelada. Essa exceção é armazenada na tarefa retornada.

ObjectDisposedException

O CancellationTokenSource associado ao cancellationToken foi descartado.

TaskCanceledException

A tarefa foi cancelada.

Exemplos

O exemplo a seguir cria 20 tarefas que serão executadas em loop até que um contador seja incrementado para um valor de 2 milhões. Quando as primeiras 10 tarefas chegam a 2 milhões, o token de cancelamento é cancelado e todas as tarefas cujos contadores não atingiram 2 milhões são canceladas. O exemplo mostra uma possível saída.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var tasks = new List<Task<int>>();
      var source = new CancellationTokenSource();
      var token = source.Token;
      int completedIterations = 0;

      for (int n = 0; n <= 19; n++)
         tasks.Add(Task.Run( () => { int iterations = 0;
                                     for (int ctr = 1; ctr <= 2000000; ctr++) {
                                         token.ThrowIfCancellationRequested();
                                         iterations++;
                                     }
                                     Interlocked.Increment(ref completedIterations);
                                     if (completedIterations >= 10)
                                        source.Cancel();
                                     return iterations; }, token));

      Console.WriteLine("Waiting for the first 10 tasks to complete...\n");
      try  {
         Task.WaitAll(tasks.ToArray());
      }
      catch (AggregateException) {
         Console.WriteLine("Status of tasks:\n");
         Console.WriteLine("{0,10} {1,20} {2,14:N0}", "Task Id",
                           "Status", "Iterations");
         foreach (var t in tasks)
            Console.WriteLine("{0,10} {1,20} {2,14}",
                              t.Id, t.Status,
                              t.Status != TaskStatus.Canceled ? t.Result.ToString("N0") : "n/a");
      }
   }
}
// The example displays output like the following:
//    Waiting for the first 10 tasks to complete...
//    Status of tasks:
//
//       Task Id               Status     Iterations
//             1      RanToCompletion      2,000,000
//             2      RanToCompletion      2,000,000
//             3      RanToCompletion      2,000,000
//             4      RanToCompletion      2,000,000
//             5      RanToCompletion      2,000,000
//             6      RanToCompletion      2,000,000
//             7      RanToCompletion      2,000,000
//             8      RanToCompletion      2,000,000
//             9      RanToCompletion      2,000,000
//            10             Canceled            n/a
//            11             Canceled            n/a
//            12             Canceled            n/a
//            13             Canceled            n/a
//            14             Canceled            n/a
//            15             Canceled            n/a
//            16      RanToCompletion      2,000,000
//            17             Canceled            n/a
//            18             Canceled            n/a
//            19             Canceled            n/a
//            20             Canceled            n/a

open System
open System.Collections.Generic
open System.Threading
open System.Threading.Tasks

let source = new CancellationTokenSource()
let token = source.Token
let mutable completedIterations = 0

let tasks =
    [| for _ = 0 to 19 do
           Task.Run(
               (fun () ->
                   let mutable iterations = 0

                   for _ = 1 to 2000000 do
                       token.ThrowIfCancellationRequested()
                       iterations <- iterations + 1

                   Interlocked.Increment &completedIterations |> ignore

                   if completedIterations >= 10 then
                       source.Cancel()

                   iterations),
               token
           )

       |]

printfn "Waiting for the first 10 tasks to complete...\n"

try
    tasks |> Seq.cast |> Array.ofSeq |> Task.WaitAll
with :? AggregateException ->
    printfn "Status of tasks:\n"
    printfn "%10s %20s %14s" "Task Id" "Status" "Iterations"

    for t in tasks do
        if t.Status <> TaskStatus.Canceled then
            t.Result.ToString "N0"
        else
            "n/a"
        |> printfn "%10i %20O %14s" t.Id t.Status


// The example displays output like the following:
//    Waiting for the first 10 tasks to complete...
//    Status of tasks:
//
//       Task Id               Status     Iterations
//             1      RanToCompletion      2,000,000
//             2      RanToCompletion      2,000,000
//             3      RanToCompletion      2,000,000
//             4      RanToCompletion      2,000,000
//             5      RanToCompletion      2,000,000
//             6      RanToCompletion      2,000,000
//             7      RanToCompletion      2,000,000
//             8      RanToCompletion      2,000,000
//             9      RanToCompletion      2,000,000
//            10             Canceled            n/a
//            11             Canceled            n/a
//            12             Canceled            n/a
//            13             Canceled            n/a
//            14             Canceled            n/a
//            15             Canceled            n/a
//            16      RanToCompletion      2,000,000
//            17             Canceled            n/a
//            18             Canceled            n/a
//            19             Canceled            n/a
//            20             Canceled            n/a

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

Module Example

   Public Sub Main()
      Dim tasks As New List(Of Task(Of Integer))()
      Dim source As New CancellationTokenSource
      Dim token As CancellationToken = source.Token
      Dim completedIterations As Integer = 0
      
      For n As Integer = 0 To 19
         tasks.Add(Task.Run( Function()
                                Dim iterations As Integer= 0
                                For ctr As Long = 1 To 2000000
                                   token.ThrowIfCancellationRequested()
                                   iterations += 1
                                Next
                                Interlocked.Increment(completedIterations)
                                If completedIterations >= 10 Then source.Cancel()
                                Return iterations
                             End Function, token))
      Next

      Console.WriteLine("Waiting for the first 10 tasks to complete... ")
      Try
         Task.WaitAll(tasks.ToArray())
      Catch e As AggregateException
         Console.WriteLine("Status of tasks:")
         Console.WriteLine()
         Console.WriteLine("{0,10} {1,20} {2,14}", "Task Id",
                           "Status", "Iterations")
         For Each t In tasks
            Console.WriteLine("{0,10} {1,20} {2,14}",
                              t.Id, t.Status,
                              If(t.Status <> TaskStatus.Canceled,
                                 t.Result.ToString("N0"), "n/a"))
         Next
      End Try
   End Sub
End Module
' The example displays output like the following:
'    Waiting for the first 10 tasks to complete...
'    Status of tasks:
'
'       Task Id               Status     Iterations
'             1      RanToCompletion      2,000,000
'             2      RanToCompletion      2,000,000
'             3      RanToCompletion      2,000,000
'             4      RanToCompletion      2,000,000
'             5      RanToCompletion      2,000,000
'             6      RanToCompletion      2,000,000
'             7      RanToCompletion      2,000,000
'             8      RanToCompletion      2,000,000
'             9      RanToCompletion      2,000,000
'            10             Canceled            n/a
'            11             Canceled            n/a
'            12             Canceled            n/a
'            13             Canceled            n/a
'            14             Canceled            n/a
'            15             Canceled            n/a
'            16      RanToCompletion      2,000,000
'            17             Canceled            n/a
'            18             Canceled            n/a
'            19             Canceled            n/a
'            20             Canceled            n/a

Em vez de usar a propriedade InnerExceptions para examinar exceções, o exemplo itera todas as tarefas para determinar quais foram concluídas com êxito e quais foram canceladas. Para aqueles que foram concluídos, ele exibe o valor retornado pela tarefa.

Como o cancelamento é cooperativo, cada tarefa pode decidir como responder ao cancelamento. O exemplo a seguir é como o primeiro, exceto que, depois que o token é cancelado, as tarefas retornam o número de iterações concluídas em vez de gerar uma exceção.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var tasks = new List<Task<int>>();
      var source = new CancellationTokenSource();
      var token = source.Token;
      int completedIterations = 0;

      for (int n = 0; n <= 19; n++)
         tasks.Add(Task.Run( () => { int iterations = 0;
                                     for (int ctr = 1; ctr <= 2000000; ctr++) {
                                         if (token.IsCancellationRequested)
                                            return iterations;
                                         iterations++;
                                     }
                                     Interlocked.Increment(ref completedIterations);
                                     if (completedIterations >= 10)
                                        source.Cancel();
                                     return iterations; }, token));

      Console.WriteLine("Waiting for the first 10 tasks to complete...\n");
      try  {
         Task.WaitAll(tasks.ToArray());
      }
      catch (AggregateException) {
         Console.WriteLine("Status of tasks:\n");
         Console.WriteLine("{0,10} {1,20} {2,14:N0}", "Task Id",
                           "Status", "Iterations");
         foreach (var t in tasks)
            Console.WriteLine("{0,10} {1,20} {2,14}",
                              t.Id, t.Status,
                              t.Status != TaskStatus.Canceled ? t.Result.ToString("N0") : "n/a");
      }
   }
}
// The example displays output like the following:
//    Status of tasks:
//
//       Task Id               Status     Iterations
//             1      RanToCompletion      2,000,000
//             2      RanToCompletion      2,000,000
//             3      RanToCompletion      2,000,000
//             4      RanToCompletion      2,000,000
//             5      RanToCompletion      2,000,000
//             6      RanToCompletion      2,000,000
//             7      RanToCompletion      2,000,000
//             8      RanToCompletion      2,000,000
//             9      RanToCompletion      2,000,000
//            10      RanToCompletion      1,658,326
//            11      RanToCompletion      1,988,506
//            12      RanToCompletion      2,000,000
//            13      RanToCompletion      1,942,246
//            14      RanToCompletion        950,108
//            15      RanToCompletion      1,837,832
//            16      RanToCompletion      1,687,182
//            17      RanToCompletion        194,548
//            18             Canceled    Not Started
//            19             Canceled    Not Started
//            20             Canceled    Not Started

open System
open System.Collections.Generic
open System.Threading
open System.Threading.Tasks

let source = new CancellationTokenSource()
let token = source.Token
let mutable completedIterations = 0

let tasks =
    [| for _ = 0 to 19 do
           Task.Run(
               (fun () ->
                   let mutable iterations = 0

                   for _ = 1 to 2000000 do
                       token.ThrowIfCancellationRequested()
                       iterations <- iterations + 1

                   Interlocked.Increment &completedIterations |> ignore

                   if completedIterations >= 10 then
                       source.Cancel()

                   iterations),
               token
           ) |]

printfn "Waiting for the first 10 tasks to complete...\n"

try
    tasks |> Seq.cast |> Array.ofSeq |> Task.WaitAll

with :? AggregateException ->
    printfn "Status of tasks:\n"
    printfn "%10s %20s %14s" "Task Id" "Status" "Iterations"

    for t in tasks do
        if t.Status <> TaskStatus.Canceled then
            t.Result.ToString "N0"
        else
            "n/a"
        |> printfn "%10i %20O %14s" t.Id t.Status

// The example displays output like the following:
//    Status of tasks:
//
//       Task Id               Status     Iterations
//             1      RanToCompletion      2,000,000
//             2      RanToCompletion      2,000,000
//             3      RanToCompletion      2,000,000
//             4      RanToCompletion      2,000,000
//             5      RanToCompletion      2,000,000
//             6      RanToCompletion      2,000,000
//             7      RanToCompletion      2,000,000
//             8      RanToCompletion      2,000,000
//             9      RanToCompletion      2,000,000
//            10      RanToCompletion      1,658,326
//            11      RanToCompletion      1,988,506
//            12      RanToCompletion      2,000,000
//            13      RanToCompletion      1,942,246
//            14      RanToCompletion        950,108
//            15      RanToCompletion      1,837,832
//            16      RanToCompletion      1,687,182
//            17      RanToCompletion        194,548
//            18             Canceled    Not Started
//            19             Canceled    Not Started
//            20             Canceled    Not Started

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

Module Example

   Public Sub Main()
      Dim tasks As New List(Of Task(Of Integer))()
      Dim source As New CancellationTokenSource
      Dim token As CancellationToken = source.Token
      Dim completedIterations As Integer = 0
      
      For n As Integer = 0 To 19
         tasks.Add(Task.Run( Function()
                                Dim iterations As Integer= 0
                                For ctr As Long = 1 To 2000000
                                   If token.IsCancellationRequested Then
                                      Return iterations
                                   End If
                                   iterations += 1
                                Next
                                Interlocked.Increment(completedIterations)
                                If completedIterations >= 10 Then source.Cancel()
                                Return iterations
                             End Function, token))
      Next

      Try
         Task.WaitAll(tasks.ToArray())
      Catch e As AggregateException
         Console.WriteLine("Status of tasks:")
         Console.WriteLine()
         Console.WriteLine("{0,10} {1,20} {2,14:N0}", "Task Id",
                           "Status", "Iterations")
         For Each t In tasks
            Console.WriteLine("{0,10} {1,20} {2,14}",
                              t.Id, t.Status,
                              If(t.Status <> TaskStatus.Canceled,
                                 t.Result.ToString("N0"), "Not Started"))
         Next
      End Try
   End Sub
End Module
' The example displays output like the following:
'    Status of tasks:
'
'       Task Id               Status     Iterations
'             1      RanToCompletion      2,000,000
'             2      RanToCompletion      2,000,000
'             3      RanToCompletion      2,000,000
'             4      RanToCompletion      2,000,000
'             5      RanToCompletion      2,000,000
'             6      RanToCompletion      2,000,000
'             7      RanToCompletion      2,000,000
'             8      RanToCompletion      2,000,000
'             9      RanToCompletion      2,000,000
'            10      RanToCompletion      1,658,326
'            11      RanToCompletion      1,988,506
'            12      RanToCompletion      2,000,000
'            13      RanToCompletion      1,942,246
'            14      RanToCompletion        950,108
'            15      RanToCompletion      1,837,832
'            16      RanToCompletion      1,687,182
'            17      RanToCompletion        194,548
'            18             Canceled    Not Started
'            19             Canceled    Not Started
'            20             Canceled    Not Started

O exemplo ainda deve lidar com a exceção AggregateException, já que todas as tarefas que não foram iniciadas quando o cancelamento é solicitado ainda geram uma exceção.

Comentários

O método Run é uma alternativa mais simples ao método StartNew. Ele cria uma tarefa com os seguintes valores padrão:

Seu valor de propriedade CreationOptions é TaskCreationOptions.DenyChildAttach.
Ele usa o agendador de tarefas padrão.

Para obter informações sobre como lidar com exceções geradas por operações de tarefa, consulte de Tratamento de Exceções.

Confira também

de cancelamento de tarefa
tratamento de exceção (biblioteca paralela da tarefa)

Aplica-se a

Compartilhar via

Task.Run Método

Definição

Sobrecargas

Comentários

Run(Func<Task>, CancellationToken)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Run(Action, CancellationToken)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Run(Func<Task>)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Run(Action)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Run<TResult>(Func<Task<TResult>>)

Parâmetros de tipo

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Run<TResult>(Func<TResult>)

Parâmetros de tipo

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Run<TResult>(Func<Task<TResult>>, CancellationToken)

Parâmetros de tipo

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Run<TResult>(Func<TResult>, CancellationToken)

Parâmetros de tipo

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Recursos adicionais