Task Konstruktory

Reference

Definice

Obor názvů:: System.Threading.Tasks

Sestavení:: System.Threading.Tasks.dll

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

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í.

Inicializuje nový Task.

Přetížení

Task(Action)	Inicializuje nový Task pomocí zadané akce.
Task(Action, CancellationToken)	Inicializuje nový Task pomocí zadané akce a CancellationToken.
Task(Action, TaskCreationOptions)	Inicializuje nový Task pomocí zadané akce a možností vytvoření.
Task(Action<Object>, Object)	Inicializuje nový Task se zadanou akcí a stavem.
Task(Action, CancellationToken, TaskCreationOptions)	Inicializuje nový Task pomocí zadané akce a možností vytvoření.
Task(Action<Object>, Object, CancellationToken)	Inicializuje nový Task pomocí zadané akce, stavu a CancellationToken.
Task(Action<Object>, Object, TaskCreationOptions)	Inicializuje nový Task se zadanou akcí, stavem a možnostmi.
Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)	Inicializuje nový Task se zadanou akcí, stavem a možnostmi.

Task(Action)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializuje nový Task pomocí zadané akce.

public:
 Task(Action ^ action);

public Task (Action action);

new System.Threading.Tasks.Task : Action -> System.Threading.Tasks.Task

Public Sub New (action As Action)

Parametry

action: Action

Delegát, který představuje kód, který se má provést v úloze.

Výjimky

ArgumentNullException

Argument action je null.

Příklady

Následující příklad používá Task(Action) konstruktor k vytvoření úloh, které načítají názvy souborů v zadaných adresářích. 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 pak zobrazí počet celkového počtu 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 async Task Main()
   {
      var list = new ConcurrentBag<string>();
      string[] dirNames = { ".", ".." };
      List<Task> tasks = new List<Task>();
      foreach (var dirName in dirNames) {
         Task t = new Task( () => { foreach(var path in Directory.GetFiles(dirName))
                                    list.Add(path); }  );
         tasks.Add(t);
         t.Start();
      }
      await Task.WhenAll(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 main =
    task {
        let list = ConcurrentBag<string>()
        let dirNames = [ "."; ".." ]
        let tasks = ResizeArray()

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

            tasks.Add t
            t.Start()

        do! tasks.ToArray() |> Task.WhenAll

        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 New Task( Sub()
                               For Each path In Directory.GetFiles(dirName)
                                  list.Add(path)
                               Next
                            End Sub  )
         tasks.Add(t)
         t.Start()
      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

Následující příklad je shodný s tím rozdílem, že použil metodu Run(Action) k vytvoření instance a spuštění úlohy v jedné operaci. Metoda vrátí Task objekt, který představuje úlohu.

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

Tento konstruktor by měl být použit pouze v pokročilých scénářích, kde je vyžadováno, aby vytvoření a spuštění úlohy byly odděleny.

Místo volání tohoto konstruktoru je nejběžnějším způsobem vytvoření instance objektu Task a spuštění úlohy volání statické Task.Run(Action) metody nebo TaskFactory.StartNew(Action) metody.

Pokud je úloha bez akce potřebná jenom k tomu, aby měl uživatel rozhraní API na co čekat, TaskCompletionSource<TResult> měl by se použít.

Viz také

Run(Action)

Platí pro

Task(Action, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializuje nový Task pomocí zadané akce a CancellationToken.

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

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

new System.Threading.Tasks.Task : Action * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Sub New (action As Action, cancellationToken As CancellationToken)

Parametry

action: Action

Delegát, který představuje kód, který se má provést v úloze.

cancellationToken: CancellationToken

To CancellationToken , co bude nový úkol sledovat.

Výjimky

ObjectDisposedException

Poskytnutá hodnota CancellationToken již byla odstraněna.

ArgumentNullException

Argument action má hodnotu null.

Příklady

Následující příklad volá Task(Action, CancellationToken) konstruktor 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, když volající vlákno volá metodu Task.Wait . Metoda Start je pak volána, aby se spustila úloha.

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 = new Task(() => { 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);
      t.Start();
      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.
//       
//       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 =
            new Task(
                (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
            )

        t.Start()
        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.
//
//       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 New Task(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)
      t.Start()
      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

Místo volání tohoto konstruktoru je nejběžnějším způsobem vytvoření instance objektu Task a spuštění úlohy volání statických Task.Run(Action, CancellationToken) metod a TaskFactory.StartNew(Action, CancellationToken) metod. Jedinou výhodou, kterou tento konstruktor nabízí, je, že umožňuje oddělit vytváření instancí objektů od vyvolání úkolu.

Další informace najdete v tématech Paralelismus úloh (paralelní knihovna úloh) a Zrušení ve spravovaných vláknech.

Platí pro

Task(Action, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializuje nový Task pomocí zadané akce a možností vytvoření.

public:
 Task(Action ^ action, System::Threading::Tasks::TaskCreationOptions creationOptions);

public Task (Action action, System.Threading.Tasks.TaskCreationOptions creationOptions);

new System.Threading.Tasks.Task : Action * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Sub New (action As Action, creationOptions As TaskCreationOptions)

Parametry

action: Action

Delegát, který představuje kód, který se má provést v úloze.

creationOptions: TaskCreationOptions

Slouží TaskCreationOptions k přizpůsobení chování úkolu.

Výjimky

ArgumentNullException

Argument action má hodnotu null.

ArgumentOutOfRangeException

Argument creationOptions určuje neplatnou hodnotu pro TaskCreationOptions.

Poznámky

Místo volání tohoto konstruktoru je nejběžnějším způsobem vytvoření instance objektu Task a spuštění úlohy volání statické TaskFactory.StartNew(Action, TaskCreationOptions) metody. Jedinou výhodou, kterou tento konstruktor nabízí, je, že umožňuje oddělit vytváření instancí objektů od vyvolání úkolu.

Platí pro

Task(Action<Object>, Object)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializuje nový Task se zadanou akcí a stavem.

public:
 Task(Action<System::Object ^> ^ action, System::Object ^ state);

public Task (Action<object> action, object state);

public Task (Action<object?> action, object? state);

new System.Threading.Tasks.Task : Action<obj> * obj -> System.Threading.Tasks.Task

Public Sub New (action As Action(Of Object), state As Object)

Parametry

action: Action<Object>

Delegát, který představuje kód, který se má provést v úloze.

state: Object

Objekt představující data, která má akce použít.

Výjimky

ArgumentNullException

Argument action má hodnotu null.

Příklady

Následující příklad definuje pole slov o délce 6 písmen. Každé slovo se pak předá konstruktoru Task(Action<Object>, Object) jako argument, jehož Action<T> delegát zakóduje znaky ve slově a pak zobrazí původní slovo a jeho zakódovanou verzi.

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

public class Example
{
   public static async Task Main()
   {
      var tasks = new List<Task>();
      Random rnd = new Random();
      Object lockObj = new Object();
      String[] words6 = { "reason", "editor", "rioter", "rental",
                          "senior", "regain", "ordain", "rained" };

      foreach (var word6 in words6) {
         Task t = new Task( (word) => { Char[] chars = word.ToString().ToCharArray();
                                        double[] order = new double[chars.Length];
                                        lock (lockObj) {
                                           for (int ctr = 0; ctr < order.Length; ctr++)
                                              order[ctr] = rnd.NextDouble();
                                           }
                                        Array.Sort(order, chars);
                                        Console.WriteLine("{0} --> {1}", word,
                                                          new String(chars));
                                      }, word6);
         t.Start();
         tasks.Add(t);
      }
      await Task.WhenAll(tasks.ToArray());
   }
}
// The example displays output like the following:
//    regain --> irnaeg
//    ordain --> rioadn
//    reason --> soearn
//    rained --> rinade
//    rioter --> itrore
//    senior --> norise
//    rental --> atnerl
//    editor --> oteird

open System
open System.Threading.Tasks

let main =
    task {
        let tasks = ResizeArray()
        let rnd = Random()
        let lockObj = obj ()

        let words6 =
            [ "reason"
              "editor"
              "rioter"
              "rental"
              "senior"
              "regain"
              "ordain"
              "rained" ]

        for word6 in words6 do
            let t =
                new Task(
                    (fun word ->
                        let chars = (string word).ToCharArray()
                        let order = Array.zeroCreate<double> chars.Length

                        lock lockObj (fun () ->
                            for i = 0 to order.Length - 1 do
                                order[i] <- rnd.NextDouble())

                        Array.Sort(order, chars)
                        printfn $"{word} --> {new String(chars)}"),
                    word6
                )

            t.Start()
            tasks.Add t

        do! tasks.ToArray() |> Task.WhenAll
    }

main.Wait()

// The example displays output like the following:
//    regain --> irnaeg
//    ordain --> rioadn
//    reason --> soearn
//    rained --> rinade
//    rioter --> itrore
//    senior --> norise
//    rental --> atnerl
//    editor --> oteird

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

Module Example
   Public Sub Main()
      Dim tasks As New List(Of Task)()
      Dim rnd As New Random()
      Dim lockObj As New Object()
      Dim words6() As String = { "reason", "editor", "rioter", "rental",
                                 "senior", "regain", "ordain", "rained" }

      For Each word6 in words6
         Dim t As New Task( Sub(word)
                               Dim chars() As Char = word.ToString().ToCharArray()
                               Dim order(chars.Length - 1) As Double
                               SyncLock lockObj
                                  For ctr As Integer = 0 To order.Length - 1
                                     order(ctr) = rnd.NextDouble()
                                  Next
                               End SyncLock
                               Array.Sort(order, chars)
                               Console.WriteLine("{0} --> {1}", word,
                                                 New String(chars))
                            End Sub, word6)
         t.Start()
         tasks.Add(t)
      Next
      Task.WaitAll(tasks.ToArray())
   End Sub
End Module
' The example displays output like the following:
'       regain --> irnaeg
'       ordain --> rioadn
'       reason --> soearn
'       rained --> rinade
'       rioter --> itrore
'       senior --> norise
'       rental --> atnerl
'       editor --> oteird

Poznámky

Místo volání tohoto konstruktoru je nejběžnějším způsobem vytvoření instance objektu Task a spuštění úlohy volání statické TaskFactory.StartNew(Action<Object>, Object) metody. Jedinou výhodou, kterou tento konstruktor nabízí, je, že umožňuje oddělit vytváření instancí objektů od vyvolání úkolu.

Viz také

StartNew(Action<Object>, Object)

Platí pro

Task(Action, CancellationToken, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializuje nový Task pomocí zadané akce a možností vytvoření.

public:
 Task(Action ^ action, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions);

public Task (Action action, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions);

new System.Threading.Tasks.Task : Action * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Sub New (action As Action, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions)

Parametry

action: Action

Delegát, který představuje kód, který se má provést v úloze.

cancellationToken: CancellationToken

To CancellationToken , co bude nový úkol sledovat.

creationOptions: TaskCreationOptions

Slouží TaskCreationOptions k přizpůsobení chování úkolu.

Výjimky

ObjectDisposedException

Vytvořený CancellationTokenSource objekt cancellationToken již byl odstraněn.

ArgumentNullException

Argument action má hodnotu null.

ArgumentOutOfRangeException

Argument creationOptions určuje neplatnou hodnotu pro TaskCreationOptions.

Poznámky

Místo volání tohoto konstruktoru je nejběžnějším způsobem vytvoření instance objektu Task a spuštění úlohy volání statické TaskFactory.StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler) metody. Jedinou výhodou, kterou tento konstruktor nabízí, je, že umožňuje oddělit vytváření instancí objektů od vyvolání úkolu.

Další informace najdete v tématech Paralelismus úloh (paralelní knihovna úkolů) a Zrušení úkolů.

Platí pro

Task(Action<Object>, Object, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializuje nový Task pomocí zadané akce, stavu a CancellationToken.

public:
 Task(Action<System::Object ^> ^ action, System::Object ^ state, System::Threading::CancellationToken cancellationToken);

public Task (Action<object> action, object state, System.Threading.CancellationToken cancellationToken);

public Task (Action<object?> action, object? state, System.Threading.CancellationToken cancellationToken);

new System.Threading.Tasks.Task : Action<obj> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Sub New (action As Action(Of Object), state As Object, cancellationToken As CancellationToken)

Parametry

action: Action<Object>

Delegát, který představuje kód, který se má provést v úloze.

state: Object

Objekt představující data, která má akce použít.

cancellationToken: CancellationToken

To CancellationToken , co bude nový úkol sledovat.

Výjimky

ObjectDisposedException

Vytvořený CancellationTokenSource objekt cancellationToken již byl odstraněn.

ArgumentNullException

Argument action má hodnotu null.

Poznámky

Místo volání tohoto konstruktoru je nejběžnějším způsobem vytvoření instance objektu Task a spuštění úlohy volání statické TaskFactory.StartNew(Action<Object>, Object, CancellationToken) metody. Jedinou výhodou, kterou tento konstruktor nabízí, je, že umožňuje oddělit vytváření instancí objektů od vyvolání úkolu.

Platí pro

Task(Action<Object>, Object, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializuje nový Task se zadanou akcí, stavem a možnostmi.

public:
 Task(Action<System::Object ^> ^ action, System::Object ^ state, System::Threading::Tasks::TaskCreationOptions creationOptions);

public Task (Action<object> action, object state, System.Threading.Tasks.TaskCreationOptions creationOptions);

public Task (Action<object?> action, object? state, System.Threading.Tasks.TaskCreationOptions creationOptions);

new System.Threading.Tasks.Task : Action<obj> * obj * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Sub New (action As Action(Of Object), state As Object, creationOptions As TaskCreationOptions)

Parametry

action: Action<Object>

Delegát, který představuje kód, který se má provést v úloze.

state: Object

Objekt představující data, která má akce použít.

creationOptions: TaskCreationOptions

Slouží TaskCreationOptions k přizpůsobení chování úkolu.

Výjimky

ArgumentNullException

Argument action má hodnotu null.

ArgumentOutOfRangeException

Argument creationOptions určuje neplatnou hodnotu pro TaskCreationOptions.

Poznámky

Místo volání tohoto konstruktoru je nejběžnějším způsobem vytvoření instance objektu Task a spuštění úlohy volání statické TaskFactory.StartNew(Action<Object>, Object, TaskCreationOptions) metody. Jedinou výhodou, kterou tento konstruktor nabízí, je, že umožňuje oddělit vytváření instancí objektů od vyvolání úkolu.

Platí pro

Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializuje nový Task se zadanou akcí, stavem a možnostmi.

public:
 Task(Action<System::Object ^> ^ action, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions);

public Task (Action<object> action, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions);

public Task (Action<object?> action, object? state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions);

new System.Threading.Tasks.Task : Action<obj> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Sub New (action As Action(Of Object), state As Object, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions)

Parametry

action: Action<Object>

Delegát, který představuje kód, který se má provést v úloze.

state: Object

Objekt představující data, která má akce použít.

cancellationToken: CancellationToken

To CancellationToken , co bude nový úkol sledovat.

creationOptions: TaskCreationOptions

Slouží TaskCreationOptions k přizpůsobení chování úkolu.

Výjimky

ObjectDisposedException

Vytvořený CancellationTokenSource objekt cancellationToken již byl odstraněn.

ArgumentNullException

Argument action má hodnotu null.

ArgumentOutOfRangeException

Argument creationOptions určuje neplatnou hodnotu pro TaskCreationOptions.

Poznámky

Místo volání tohoto konstruktoru je nejběžnějším způsobem vytvoření instance objektu Task a spuštění úlohy volání statické TaskFactory.StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler) metody. Jedinou výhodou, kterou tento konstruktor nabízí, je, že umožňuje oddělit vytváření instancí objektů od vyvolání úkolu.

Platí pro

Task Konstruktory

Definice

Přetížení

Task(Action)

Parametry

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Task(Action, CancellationToken)

Parametry

Výjimky

Příklady

Poznámky

Platí pro

Task(Action, TaskCreationOptions)

Parametry

Výjimky

Poznámky

Platí pro

Task(Action<Object>, Object)

Parametry

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Task(Action, CancellationToken, TaskCreationOptions)

Parametry

Výjimky

Poznámky

Platí pro

Task(Action<Object>, Object, CancellationToken)

Parametry

Výjimky

Poznámky

Platí pro

Task(Action<Object>, Object, TaskCreationOptions)

Parametry

Výjimky

Poznámky

Platí pro

Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)

Parametry

Výjimky

Poznámky

Platí pro

Váš názor

Další materiály