Task.Run Metoda
Definice
Důležité
Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.
Fronty zadanou práci ke spuštění na fondu vláken a vrátí úlohu nebo Task<TResult> popisovač pro danou práci.
Přetížení
Run(Func<Task>, CancellationToken) |
Fronty, aby se zadaná práce spustila ve fondu vláken, a vrátí proxy server pro úlohu vrácenou nástrojem |
Run(Action, CancellationToken) |
Fronty zadanou práci spustit ve fondu vláken a vrátí objekt, který představuje danou Task práci. Token zrušení umožňuje zrušit práci, pokud ještě nezačala. |
Run(Func<Task>) |
Fronty, aby se zadaná práce spustila ve fondu vláken, a vrátí proxy server pro úlohu vrácenou nástrojem |
Run(Action) |
Fronty zadanou práci spustit ve fondu vláken a vrátí objekt, který představuje danou Task práci. |
Run<TResult>(Func<Task<TResult>>) |
Fronty, aby se zadaná práce spustila ve fondu vláken, a vrátí proxy server pro |
Run<TResult>(Func<TResult>) |
Fronty zadanou práci spustit ve fondu vláken a vrátí objekt, který představuje danou Task<TResult> práci. Token zrušení umožňuje zrušit práci, pokud ještě nezačala. |
Run<TResult>(Func<Task<TResult>>, CancellationToken) |
Fronty, aby se zadaná práce spustila ve fondu vláken, a vrátí proxy server pro |
Run<TResult>(Func<TResult>, CancellationToken) |
Fronty zadanou práci spustit ve fondu vláken a vrátí objekt, který představuje danou |
Poznámky
Metoda Run poskytuje sadu přetížení, která usnadňují spuštění úlohy pomocí výchozích hodnot. Jedná se o odlehčenou alternativu StartNew k přetížení.
Run(Func<Task>, CancellationToken)
- Zdroj:
- Task.cs
- Zdroj:
- Task.cs
- Zdroj:
- Task.cs
Fronty, aby se zadaná práce spustila ve fondu vláken, a vrátí proxy server pro úlohu vrácenou nástrojem function
. Token zrušení umožňuje zrušit práci, pokud ještě nezačala.
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
- 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
Úloha, která představuje proxy server pro úlohu vrácenou nástrojem function
.
Výjimky
Parametr function
byl null
.
Úkol byl zrušen. Tato výjimka se uloží do vrácené úlohy.
Přidružená CancellationTokenSource k cancellationToken
byla odstraněna.
Poznámky
Informace o zpracování výjimek vyvolaných operacemi úloh najdete v tématu Zpracování výjimek.
Viz také
Platí pro
Run(Action, CancellationToken)
- Zdroj:
- Task.cs
- Zdroj:
- Task.cs
- Zdroj:
- Task.cs
Fronty zadanou práci spustit ve fondu vláken a vrátí objekt, který představuje danou Task práci. Token zrušení umožňuje zrušit práci, pokud ještě nezačala.
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
Úloha, která představuje práci zařazenou do fronty ke spuštění ve fondu vláken.
Výjimky
Parametr action
byl null
.
Úkol byl zrušen. Tato výjimka se uloží do vrácené úlohy.
Přidružená CancellationTokenSource k cancellationToken
byla odstraněna.
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á metodu Parallel.ForEach pro přidání informací o každém souboru do objektu List<T> . Každá odpojená vnořená úloha vyvolaná smyčkou Parallel.ForEach kontroluje stav tokenu zrušení a v případě požadavku na zrušení volá metodu CancellationToken.ThrowIfCancellationRequested . Metoda CancellationToken.ThrowIfCancellationRequested vyvolá OperationCanceledException výjimku, která je zpracována v catch
bloku při volání vlákna volání Task.Wait metody .
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 se před zahájením provádění úlohy požaduje zrušení, úloha se nespustí. Místo toho se nastaví na Canceled stav a vyvolá TaskCanceledException výjimku.
Metoda Run(Action, CancellationToken) je jednodušší alternativou metody TaskFactory.StartNew(Action, CancellationToken) . Vytvoří úlohu s následujícími výchozími hodnotami:
Hodnota CreationOptions vlastnosti je TaskCreationOptions.DenyChildAttach.
Používá výchozí plánovač úloh.
Informace o zpracování výjimek vyvolaných operacemi úloh najdete v tématu Zpracování výjimek.
Viz také
Platí pro
Run(Func<Task>)
- Zdroj:
- Task.cs
- Zdroj:
- Task.cs
- Zdroj:
- Task.cs
Fronty, aby se zadaná práce spustila ve fondu vláken, a vrátí proxy server pro úlohu vrácenou nástrojem 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
Návraty
Úloha, která představuje proxy server pro úlohu vrácenou nástrojem function
.
Výjimky
Parametr function
byl null
.
Poznámky
Informace o zpracování výjimek vyvolaných operacemi úloh najdete v tématu Zpracování výjimek.
Viz také
Platí pro
Run(Action)
- Zdroj:
- Task.cs
- Zdroj:
- Task.cs
- Zdroj:
- Task.cs
Fronty zadanou práci spustit ve fondu vláken a vrátí objekt, který představuje danou Task 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
Úloha, která představuje práci zařazenou do fronty ke spuštění v ThreadPool.
Výjimky
Parametr action
byl null
.
Příklady
Následující příklad definuje metodu ShowThreadInfo
, která zobrazuje Thread.ManagedThreadId aktuální vlákno. Je volána přímo z vlákna aplikace a je volána z delegáta Action předaného metodě 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
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á úkol 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 provádí v jiném vlákně než hlavní vlákno aplikace.
Volání Wait metody zajišťuje, že se úloha dokončí a zobrazí její výstup před ukončením aplikace. Jinak je možné, že Main
se metoda dokončí před dokončením úkolu.
Následující příklad ukazuje metodu Run(Action) . Definuje pole názvů adresářů a spustí samostatnou úlohu, která načte názvy souborů v každém adresáři. Všechny úkoly zapisuje názvy souborů do jednoho ConcurrentBag<T> objektu. Příklad pak zavolá metodu WaitAll(Task[]) , aby se zajistilo, že všechny úkoly byly dokončeny, a zobrazí celkový počet názvů souborů zapsaných do objektu 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
Poznámky
Metoda Run umožňuje vytvořit a spustit úlohu v jednom volání metody a je jednodušší alternativou k StartNew metodě . Vytvoří úlohu s následujícími výchozími hodnotami:
Jeho token zrušení je CancellationToken.None.
Hodnota CreationOptions vlastnosti je TaskCreationOptions.DenyChildAttach.
Používá výchozí plánovač úloh.
Informace o zpracování výjimek vyvolaných operacemi úloh najdete 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
Fronty, aby se zadaná práce spustila ve fondu vláken, a vrátí proxy server pro Task(TResult)
server vrácený nástrojem function
. Token zrušení umožňuje zrušit práci, pokud ještě nezačala.
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.
Parametry
Návraty
A Task(TResult)
, který představuje proxy server pro vrácený Task(TResult)
objektem function
.
Výjimky
Parametr function
byl null
.
Poznámky
Informace o zpracování výjimek vyvolaných operacemi úloh najdete v tématu Zpracování výjimek.
Viz také
Platí pro
Run<TResult>(Func<TResult>)
- Zdroj:
- Task.cs
- Zdroj:
- Task.cs
- Zdroj:
- Task.cs
Fronty zadanou práci spustit ve fondu vláken a vrátí objekt, který představuje danou Task<TResult> práci. Token zrušení umožňuje zrušit práci, pokud ještě nezačala.
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
Objekt úlohy, který představuje práci zařazenou do fronty ke spuštění ve fondu vláken.
Výjimky
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 jeho obsahu a výpočet počtu slov pomocí regulárního výrazu. Metoda WaitAll(Task[]) je volána, aby se zajistilo, že všechny úkoly byly dokončeny před zobrazením počtu slov každé knihy 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 znakům interpunkce 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ém počtu slov.
Poznámky
Metoda Run je jednodušší alternativou metody TaskFactory.StartNew(Action) . Vytvoří úlohu s následujícími výchozími hodnotami:
Jeho token zrušení je CancellationToken.None.
Hodnota CreationOptions vlastnosti je TaskCreationOptions.DenyChildAttach.
Používá výchozí plánovač úloh.
Informace o zpracování výjimek vyvolaných operacemi úloh najdete 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
Fronty, aby se zadaná práce spustila ve fondu vláken, a vrátí proxy server pro Task(TResult)
server vrácený nástrojem 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.
Parametry
- 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
A Task(TResult)
, který představuje proxy server pro vrácený Task(TResult)
objektem function
.
Výjimky
Parametr function
byl null
.
Úkol byl zrušen. Tato výjimka se uloží do vrácené úlohy.
Přidružená CancellationTokenSource k cancellationToken
byla odstraněna.
Poznámky
Informace o zpracování výjimek vyvolaných operacemi úloh najdete 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
Fronty zadanou práci spustit ve fondu vláken a vrátí objekt, který představuje danou Task(TResult)
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
A Task(TResult)
, který představuje práci zařazenou do fronty ke spuštění ve fondu vláken.
Výjimky
Parametr function
je null
.
Úkol byl zrušen. Tato výjimka se uloží do vrácené úlohy.
Přidružená CancellationTokenSource k cancellationToken
byla odstraněna.
Příklady
Následující příklad vytvoří 20 úloh, které budou ve smyčce, dokud se čítač nenavýší na hodnotu 2 milionů. Když prvních 10 úkolů dosáhne 2 milionů, token zrušení se zruší a všechny úkoly, jejichž čítače nedosáhly 2 milionů, 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í InnerExceptions vlastnosti ke zkoumání výjimek tento příklad iteruje všechny úlohy, aby zjistil, které byly úspěšně dokončeny a které byly zrušeny. U dokončených zobrazí hodnotu vrácenou úkolem.
Vzhledem k tomu, že zrušení spolupracuje, může se každý úkol rozhodnout, jak na zrušení reagovat. Následující příklad se podobá prvnímu příkladu s tím rozdílem, že po zrušení tokenu úkoly vrátí počet iterací, které dokončily, a nevyvolají výjimku.
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 AggregateException výjimku, protože všechny úlohy, které nebyly spuštěny při požadavku na zrušení, stále vyvolat výjimku.
Poznámky
Pokud se před zahájením provádění úlohy požaduje zrušení, úloha se nespustí. Místo toho se nastaví na Canceled stav a vyvolá TaskCanceledException výjimku.
Metoda Run je jednodušší alternativou metody StartNew . Vytvoří úlohu s následujícími výchozími hodnotami:
Hodnota CreationOptions vlastnosti je TaskCreationOptions.DenyChildAttach.
Používá výchozí plánovač úloh.
Informace o zpracování výjimek vyvolaných operacemi úloh najdete v tématu Zpracování výjimek.
Viz také
Platí pro
Váš názor
https://aka.ms/ContentUserFeedback.
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu:Odeslat a zobrazit názory pro