Task.Run Metoda

  • Reference

Definice

Obor názvů:
System.Threading.Tasks
Sestavení:
System.Threading.Tasks.dll
Sestavení:
System.Runtime.dll
Sestavení:
mscorlib.dll
Sestavení:
netstandard.dll

Zařadí zadanou práci, která se má spustit na fondu vláken, a vrátí úlohu nebo Task<TResult> popisovač pro danou práci.

Přetížení

Run(Func<Task>, CancellationToken)

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí proxy server pro úlohu vrácenou function. Token zrušení umožňuje zrušit práci, pokud ještě nebyla spuštěna.
Run(Action, CancellationToken)

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí Task objekt, který představuje danou práci. Token zrušení umožňuje zrušit práci, pokud ještě nebyla spuštěna.
Run(Func<Task>)

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí proxy server pro úlohu vrácenou function.
Run(Action)

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí Task objekt, který představuje danou práci.
Run<TResult>(Func<Task<TResult>>)

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí proxy server pro Task(TResult) vrácenou function. Token zrušení umožňuje zrušit práci, pokud ještě nebyla spuštěna.
Run<TResult>(Func<TResult>)

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí Task<TResult> objekt, který představuje danou práci. Token zrušení umožňuje zrušit práci, pokud ještě nebyla spuštěna.
Run<TResult>(Func<Task<TResult>>, CancellationToken)

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí proxy server pro Task(TResult) vrácenou function.
Run<TResult>(Func<TResult>, CancellationToken)

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí Task(TResult) objekt, který představuje danou práci.

Poznámky

Metoda Run poskytuje sadu přetížení, které usnadňují spuštění úlohy pomocí výchozích hodnot. Jedná se o jednoduchou alternativu k přetížení StartNew.

Run(Func<Task>, CancellationToken)

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí proxy server pro úlohu vrácenou function. Token zrušení umožňuje zrušit práci, pokud ještě nebyla spuštěna.

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

Parametry

function
Func<Task>

Práce, která se má provést asynchronně.

cancellationToken
CancellationToken

Token zrušení, který lze použít ke zrušení práce, pokud ještě nezačala. Run(Func<Task>, CancellationToken) nepředává cancellationToken do action.

Návraty

Task

Úkol, který představuje proxy pro úlohu vrácenou function.

Výjimky

ArgumentNullException

Parametr function byl null.

OperationCanceledException

Úkol byl zrušen. Tato výjimka je uložena do vrácené úlohy.

ObjectDisposedException

Byla odstraněna CancellationTokenSource přidružená k cancellationToken.

TaskCanceledException

Úkol byl zrušen.

Poznámky

Informace o zpracování výjimek vyvolaných operacemi úloh naleznete v tématu Zpracování výjimek.

Viz také

Platí pro

Run(Action, CancellationToken)

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí Task objekt, který představuje danou práci. Token zrušení umožňuje zrušit práci, pokud ještě nebyla spuštěna.

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

Parametry

action
Action

Práce, která se má provést asynchronně.

cancellationToken
CancellationToken

Token zrušení, který lze použít ke zrušení práce, pokud ještě nezačala. Run(Action, CancellationToken) nepředává cancellationToken do action.

Návraty

Task

Úloha, která představuje práci zařazenou do fronty pro spuštění ve fondu vláken.

Výjimky

ArgumentNullException

Parametr action byl null.

OperationCanceledException

Úkol byl zrušen. Tato výjimka je uložena do vrácené úlohy.

ObjectDisposedException

Byla odstraněna CancellationTokenSource přidružená k cancellationToken.

TaskCanceledException

Úkol byl zrušen.

Příklady

Následující příklad volá metodu Run(Action, CancellationToken) k vytvoření úlohy, která iteruje soubory v adresáři C:\Windows\System32. Výraz lambda volá Parallel.ForEach metodu pro přidání informací o každém souboru do List<T> objektu. Každá odpojená vnořená úloha vyvolaná smyčkou Parallel.ForEach zkontroluje stav tokenu zrušení a v případě požadavku zrušení volá metodu CancellationToken.ThrowIfCancellationRequested. Metoda CancellationToken.ThrowIfCancellationRequested vyvolá výjimku OperationCanceledException, která je zpracována v bloku catch při volání vlákna volá metodu 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

Poznámky

Pokud je zrušení požadováno před zahájením provádění úkolu, úloha se nespustí. Místo toho je nastavena na Canceled stav a vyvolá výjimku TaskCanceledException.

Metoda Run(Action, CancellationToken) je jednodušší alternativou k metodě TaskFactory.StartNew(Action, CancellationToken). Vytvoří úlohu s následujícími výchozími hodnotami:

Informace o zpracování výjimek vyvolaných operacemi úloh naleznete v tématu Zpracování výjimek.

Viz také

Platí pro

Run(Func<Task>)

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí proxy server pro úlohu vrácenou 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

Parametry

function
Func<Task>

Práce, která se má provést asynchronně.

Návraty

Task

Úkol, který představuje proxy pro úlohu vrácenou function.

Výjimky

ArgumentNullException

Parametr function byl null.

Poznámky

Informace o zpracování výjimek vyvolaných operacemi úloh naleznete v tématu Zpracování výjimek.

Viz také

Platí pro

Run(Action)

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí Task objekt, který představuje danou práci.

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

Parametry

action
Action

Práce, která se má provést asynchronně.

Návraty

Task

Úloha, která představuje práci zařazenou do fronty ke spuštění v fondu vláken.

Výjimky

ArgumentNullException

Parametr action byl null.

Příklady

Následující příklad definuje ShowThreadInfo metodu, která zobrazuje Thread.ManagedThreadId aktuálního vlákna. Volá se přímo z vlákna aplikace a je volána z Action delegát předán do Run(Action) metody.

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

Následující příklad je podobný předchozímu, s tím rozdílem, že používá výraz lambda k definování kódu, který má úloha provést.

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

Příklady ukazují, že asynchronní úloha se spouští na jiném vlákně než v hlavním vlákně aplikace.

Volání metody Wait zajišťuje, že se úloha dokončí a zobrazí její výstup před ukončením aplikace. Jinak je možné, že se metoda Main dokončí před dokončením úkolu.

Následující příklad znázorňuje Run(Action) metodu. Definuje pole názvů adresářů a spustí samostatnou úlohu pro načtení názvů souborů v každém adresáři. Všechny úkoly zapisuje názvy souborů do jednoho objektu ConcurrentBag<T>. Příklad pak volá WaitAll(Task[]) metodu, aby se zajistilo, že všechny úkoly byly dokončeny, a pak zobrazí počet celkového počtu názvů souborů zapsaných do ConcurrentBag<T> objektu.

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

Poznámky

Metoda Run umožňuje vytvořit a spustit úlohu v jednom volání metody a je jednodušší alternativou k metodě StartNew. Vytvoří úlohu s následujícími výchozími hodnotami:

Informace o zpracování výjimek vyvolaných operacemi úloh naleznete v tématu Zpracování výjimek.

Viz také

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí proxy server pro Task(TResult) vrácenou function. Token zrušení umožňuje zrušit práci, pokud ještě nebyla spuštěna.

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)

Parametry typu

TResult

Typ výsledku vráceného úlohou proxy serveru.

Parametry

function
Func<Task<TResult>>

Práce, která se má provést asynchronně.

Návraty

Task<TResult>

Task(TResult), který představuje proxy server pro Task(TResult) vrácený function.

Výjimky

ArgumentNullException

Parametr function byl null.

Poznámky

Informace o zpracování výjimek vyvolaných operacemi úloh naleznete v tématu Zpracování výjimek.

Viz také

Platí pro

Run<TResult>(Func<TResult>)

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí Task<TResult> objekt, který představuje danou práci. Token zrušení umožňuje zrušit práci, pokud ještě nebyla spuštěna.

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)

Parametry typu

TResult

Návratový typ úkolu.

Parametry

function
Func<TResult>

Práce, která se má provést asynchronně.

Návraty

Task<TResult>

Objekt úlohy, který představuje pracovní frontu ke spuštění ve fondu vláken.

Výjimky

ArgumentNullException

Parametr function je null.

Příklady

Následující příklad spočítá přibližný počet slov v textových souborech, které představují publikované knihy. Každý úkol je zodpovědný za otevření souboru, asynchronní čtení celého obsahu a výpočet počtu slov pomocí regulárního výrazu. Volá se metoda WaitAll(Task[]), aby se zajistilo, že všechny úkoly byly dokončeny před zobrazením počtu slov jednotlivých knih v konzole.

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

Regulární výraz \p{P}*\s+ odpovídá nule, jednomu nebo více interpunkčním znakům následovaným jedním nebo více prázdnými znaky. Předpokládá se, že celkový počet shod se rovná přibližný počet slov.

Poznámky

Metoda Run je jednodušší alternativou k metodě TaskFactory.StartNew(Action). Vytvoří úlohu s následujícími výchozími hodnotami:

Informace o zpracování výjimek vyvolaných operacemi úloh naleznete v tématu Zpracování výjimek.

Viz také

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí proxy server pro Task(TResult) vrácenou 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)

Parametry typu

TResult

Typ výsledku vráceného úlohou proxy serveru.

Parametry

function
Func<Task<TResult>>

Práce, která se má provést asynchronně.

cancellationToken
CancellationToken

Token zrušení, který lze použít ke zrušení práce, pokud ještě nezačala. Run<TResult>(Func<Task<TResult>>, CancellationToken) nepředává cancellationToken do action.

Návraty

Task<TResult>

Task(TResult), který představuje proxy server pro Task(TResult) vrácený function.

Výjimky

ArgumentNullException

Parametr function byl null.

OperationCanceledException

Úkol byl zrušen. Tato výjimka je uložena do vrácené úlohy.

ObjectDisposedException

Byla odstraněna CancellationTokenSource přidružená k cancellationToken.

TaskCanceledException

Úkol byl zrušen.

Poznámky

Informace o zpracování výjimek vyvolaných operacemi úloh naleznete v tématu Zpracování výjimek.

Viz také

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Zařadí zadanou práci pro spuštění ve fondu vláken a vrátí Task(TResult) objekt, který představuje danou práci.

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)

Parametry typu

TResult

Typ výsledku úkolu.

Parametry

function
Func<TResult>

Práce, která se má provést asynchronně.

cancellationToken
CancellationToken

Token zrušení, který lze použít ke zrušení práce, pokud ještě nezačala. Run<TResult>(Func<TResult>, CancellationToken) nepředává cancellationToken do action.

Návraty

Task<TResult>

Task(TResult), která představuje pracovní frontu pro spuštění ve fondu vláken.

Výjimky

ArgumentNullException

Parametr function je null.

OperationCanceledException

Úkol byl zrušen. Tato výjimka je uložena do vrácené úlohy.

ObjectDisposedException

Byla odstraněna CancellationTokenSource přidružená k cancellationToken.

TaskCanceledException

Úkol byl zrušen.

Příklady

Následující příklad vytvoří 20 úkolů, které budou opakovat, dokud se čítač nezvýší na hodnotu 2 miliony. Když prvních 10 úkolů dosáhne 2 milionů, token zrušení se zruší a všechny úkoly, jejichž čítače nedosáhly 2 miliony, se zruší. Příklad ukazuje možný výstup.

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

Místo použití vlastnosti InnerExceptions k prozkoumání výjimek příklad iteruje všechny úkoly k určení, které byly úspěšně dokončeny a které byly zrušeny. U dokončených položek zobrazí hodnotu vrácenou úkolem.

Vzhledem k tomu, že zrušení je spolupráce, může každý úkol rozhodnout, jak reagovat na zrušení. Následující příklad je podobný prvnímu, s tím rozdílem, že jakmile je token zrušen, vrátí úkoly počet iterací, které dokončily, místo vyvolání výjimky.

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

Příklad stále musí zpracovat výjimku AggregateException, protože všechny úlohy, které nebyly spuštěny při vyžádání zrušení, stále vyvolá výjimku.

Poznámky

Pokud je zrušení požadováno před zahájením provádění úkolu, úloha se nespustí. Místo toho je nastavena na Canceled stav a vyvolá výjimku TaskCanceledException.

Metoda Run je jednodušší alternativou k metodě StartNew. Vytvoří úlohu s následujícími výchozími hodnotami:

Informace o zpracování výjimek vyvolaných operacemi úloh naleznete v tématu Zpracování výjimek.

Viz také

Platí pro