TaskFactory.StartNew Metoda

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

Vytvoří a spustí úkol.

Přetížení

StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Vytvoří a spustí úlohu pro zadaný delegát akce, stav, token zrušení, možnosti vytvoření a plánovač úkolů.
StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)	Vytvoří a spustí úlohu pro zadaného delegáta akce, token zrušení, možnosti vytvoření a stav.
StartNew(Action<Object>, Object, TaskCreationOptions)	Vytvoří a spustí úlohu pro zadaného delegáta akce, stav a možnosti vytvoření.
StartNew(Action<Object>, Object, CancellationToken)	Vytvoří a spustí úlohu pro zadaný delegát akce, stav a token zrušení.
StartNew(Action, CancellationToken)	Vytvoří a spustí úlohu pro zadaný delegát akce a token zrušení.
StartNew(Action, TaskCreationOptions)	Vytvoří a spustí úlohu pro zadané možnosti delegáta a vytvoření akce.
StartNew(Action)	Vytvoří a spustí úkol pro zadaný delegát akce.
StartNew(Action<Object>, Object)	Vytvoří a spustí úlohu pro zadaný delegát a stav akce.
StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)	Vytvoří a spustí úlohu typu `TResult` pro zadaného delegáta funkce, token zrušení, možnosti vytvoření a plánovač úkolů.
StartNew<TResult>(Func<TResult>)	Vytvoří a spustí úkol typu `TResult` pro zadaného delegáta funkce.
StartNew<TResult>(Func<Object,TResult>, Object)	Vytvoří a spustí úlohu typu `TResult` pro zadaný delegát a stav funkce.
StartNew<TResult>(Func<TResult>, CancellationToken)	Vytvoří a spustí úlohu typu `TResult` pro zadaný delegát funkce a token zrušení.
StartNew<TResult>(Func<TResult>, TaskCreationOptions)	Vytvoří a spustí úlohu typu `TResult` pro zadaného delegáta funkce a možnosti vytváření.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken)	Vytvoří a spustí úlohu typu `TResult` pro zadaný delegát funkce, stav a token zrušení.
StartNew<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	Vytvoří a spustí úlohu typu `TResult` pro zadané možnosti delegáta funkce, stavu a vytváření.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Vytvoří a spustí úlohu typu `TResult` pro zadaný delegát funkce, stav, token zrušení, možnosti vytvoření a plánovač úloh.

Poznámky

Počínaje .NET Framework 4.5 Task.Run je metoda doporučeným způsobem spuštění úlohy vázané na výpočty. Tuto metodu StartNew použijte pouze v případě, že potřebujete jemně odstupňovaný ovládací prvek pro dlouho běžící výpočetní úlohu. To zahrnuje scénáře, ve kterých chcete řídit následující:

Možnosti vytváření úkolů Úlohy vytvořené metodou Task.Run se ve výchozím nastavení vytvoří s možností TaskCreationOptions.DenyChildAttach . Chcete-li toto chování přepsat nebo poskytnout jiné TaskCreationOptions možnosti, zavolejte StartNew přetížení.
Předávání parametrů Přetížení Task.Run metody neumožňují předat parametr delegátu úkolu. StartNew Přetížení metody.
Plánovač úloh. Přetížení Task.Run metody používají výchozí plánovač úloh. Chcete-li řídit plánovač úloh, zavolejte StartNew přetížení parametrem scheduler . Další informace naleznete v tématu TaskScheduler.

StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)

Vytvoří a spustí úlohu pro zadaný delegát akce, stav, token zrušení, možnosti vytvoření a plánovač úkolů.

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

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

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

member this.StartNew : Action<obj> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task

Parametry

action: Action<Object>

Delegování akce, která se má provést asynchronně.

state: Object

Objekt obsahující data, která má delegát používat action .

cancellationToken: CancellationToken

Token zrušení, který bude přiřazen k novému úkolu.

creationOptions: TaskCreationOptions

Jedna z hodnot výčtu, která řídí chování vytvořené úlohy.

scheduler: TaskScheduler

Plánovač úloh, který se používá k naplánování vytvořené úlohy.

Návraty

Task

Zahájený úkol.

Výjimky

ObjectDisposedException

CancellationToken Poskytnutý již byl vyřazen.

ArgumentNullException

action je null.

-nebo-

scheduler je null.

ArgumentOutOfRangeException

creationOptions argument určuje neplatnou TaskCreationOptions hodnotu. Další informace najdete v poznámkách pro FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)

Poznámky

Volání StartNew je funkčně ekvivalentní k vytvoření úlohy pomocí jednoho z jeho konstruktorů a následné volání Start , které ho naplánuje ke spuštění.

Počínaje .NET Framework 4.5 můžete metodu Run použít s objektem Action jako rychlý způsob volání StartNew s výchozími parametry. Další informace a příklady kódu naleznete v tématu Task.Run vs Task.Factory.StartNew v paralelním programování s .NET blog.

Viz také

Platí pro

StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)

Vytvoří a spustí úlohu pro zadaného delegáta akce, token zrušení, možnosti vytvoření a stav.

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

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

member this.StartNew : Action * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function StartNew (action As Action, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task

Parametry

action: Action

Delegování akce, která se má provést asynchronně.

cancellationToken: CancellationToken

Token zrušení, který bude přiřazen k novému úkolu.

creationOptions: TaskCreationOptions

Jedna z hodnot výčtu, která řídí chování vytvořené úlohy.

scheduler: TaskScheduler

Plánovač úloh, který se používá k naplánování vytvořené úlohy.

Návraty

Task

Zahájený úkol.

Výjimky

ObjectDisposedException

CancellationToken Poskytnutý již byl vyřazen.

ArgumentNullException

action je null.

-nebo- scheduler je null.

ArgumentOutOfRangeException

creationOptions určuje neplatnou hodnotu TaskCreationOptions. Další informace najdete v poznámkách pro FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)

Poznámky

Volání StartNew je funkčně ekvivalentní k vytvoření úlohy pomocí jednoho z jeho konstruktorů a následné volání Start , které ho naplánuje ke spuštění.

Viz také

Platí pro

StartNew(Action<Object>, Object, TaskCreationOptions)

Vytvoří a spustí úlohu pro zadaného delegáta akce, stav a možnosti vytvoření.

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

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

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

member this.StartNew : Action<obj> * obj * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object, creationOptions As TaskCreationOptions) As Task

Parametry

action: Action<Object>

Delegování akce, která se má provést asynchronně.

state: Object

Objekt obsahující data, která má delegát používat action .

creationOptions: TaskCreationOptions

Jedna z hodnot výčtu, která řídí chování vytvořené úlohy.

Návraty

Task

Zahájený úkol.

Výjimky

ArgumentNullException

action je null.

ArgumentOutOfRangeException

creationOptions určuje neplatnou TaskCreationOptions hodnotu.

Poznámky

Volání StartNew je funkčně ekvivalentní k vytvoření úlohy pomocí jednoho z jeho konstruktorů a následné volání Start , které ho naplánuje ke spuštění.

Viz také

Platí pro

StartNew(Action<Object>, Object, CancellationToken)

Vytvoří a spustí úlohu pro zadaný delegát akce, stav a token zrušení.

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

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

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

member this.StartNew : Action<obj> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object, cancellationToken As CancellationToken) As Task

Parametry

action: Action<Object>

Delegování akce, která se má provést asynchronně.

state: Object

Objekt obsahující data, která má delegát používat action .

cancellationToken: CancellationToken

Token zrušení, který bude přiřazen k novému úkolu.

Návraty

Task

Zahájený úkol.

Výjimky

ObjectDisposedException

CancellationToken Poskytnutý již byl vyřazen.

ArgumentNullException

action je null.

Příklady

Následující příklad definuje matici 6 písmen slova. Každé slovo se pak předá delegátu Action<T> , který zakóduje slovo a zobrazí původní slovo a jeho scrambled verzi.

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

public class Example
{
   public static void Main()
   {
      CancellationTokenSource cts = new CancellationTokenSource();
      CancellationToken token = cts.Token;
      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)
         tasks.Add(Task.Factory.StartNew( (word) => { Char[] chars = word.ToString().ToCharArray();
                                                      double[] order = new double[chars.Length];
                                                      token.ThrowIfCancellationRequested();
                                                      bool wasZero = false;
                                                      lock (lockObj) {
                                                         for (int ctr = 0; ctr < order.Length; ctr++) {
                                                             order[ctr] = rnd.NextDouble();
                                                             if (order[ctr] == 0) {
                                                                if (! wasZero) {
                                                                   wasZero = true;
                                                                }
                                                                else {
                                                                   cts.Cancel();
                                                                }
                                                             }
                                                         }
                                                      }
                                                      token.ThrowIfCancellationRequested();
                                                      Array.Sort(order, chars);
                                                      Console.WriteLine("{0} --> {1}", word,
                                                                        new String(chars));
                                                    }, word6, token));

      try {
         Task.WaitAll(tasks.ToArray());
      }
      catch (AggregateException e) {
         foreach (var ie in e.InnerExceptions) {
            if (ie is OperationCanceledException) {
               Console.WriteLine("The word scrambling operation has been cancelled.");
               break;
            }
            else {
               Console.WriteLine(ie.GetType().Name + ": " + ie.Message);
            }
         }
      }
      finally {
         cts.Dispose();
      }
   }
}
// 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
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim cts As New CancellationTokenSource()
      Dim token As CancellationToken = cts.Token
      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
         tasks.Add(Task.Factory.StartNew( Sub(word)
                                              Dim chars() As Char = word.ToString().ToCharArray()
                                              Dim order(chars.Length - 1) As Double
                                              Dim wasZero As Boolean = False
                                              SyncLock lockObj
                                                 For ctr As Integer = 0 To order.Length - 1
                                                    order(ctr) = rnd.NextDouble()
                                                    If order(ctr) = 0 Then
                                                       If Not wasZero Then
                                                          wasZero = True
                                                       Else
                                                          cts.Cancel()
                                                       End If
                                                    End If
                                                 Next
                                              End SyncLock
                                              token.ThrowIfCancellationRequested()
                                              Array.Sort(order, chars)
                                              Console.WriteLine("{0} --> {1}", word,
                                                                new String(chars))
                                          End Sub, word6))
      Next
      Try
         Task.WaitAll(tasks.ToArray())
      Catch e As AggregateException
         For Each ie In e.InnerExceptions
            If TypeOf ie Is OperationCanceledException
               Console.WriteLine("The word scrambling operation has been cancelled.")
               Exit For
            Else
               Console.WriteLine(ie.GetType().Name + ": " + ie.Message)
            End If
         Next
      Finally
         cts.Dispose()
      End Try
   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

Všimněte si, že příklad inicializuje jeden generátor náhodných čísel, který je chráněn zámkem. Pokud potřebujete zámek, přečtěte si téma třídy "System.Random – třída a zabezpečení vláken" Random . Aby bylo možné zvládnout možnost poškození generátoru náhodných čísel, předá se úkolu token zrušení. Pokud se dvě náhodná čísla rovná nule, metoda předpokládá, že generátor náhodných čísel je poškozen a nastaví token zrušení. Před řazením chars pole, které obsahuje šest znaků ve slově, metoda volá metodu CancellationToken.ThrowIfCancellationRequested , která OperationCanceledException vyvolá metodu, pokud byl token zrušen.

Poznámky

Volání StartNew je funkčně ekvivalentní k vytvoření úlohy pomocí jednoho z jeho konstruktorů a následné volání Start , které ho naplánuje ke spuštění.

Viz také

Platí pro

StartNew(Action, CancellationToken)

Vytvoří a spustí úlohu pro zadaný delegát akce a token zrušení.

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

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

member this.StartNew : Action * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Function StartNew (action As Action, cancellationToken As CancellationToken) As Task

Parametry

action: Action

Delegování akce, která se má provést asynchronně.

cancellationToken: CancellationToken

Token zrušení, který bude přiřazen k novému úkolu.

Návraty

Task

Zahájený úkol.

Výjimky

ObjectDisposedException

CancellationToken Poskytnutý již byl vyřazen.

ArgumentNullException

action je null.

Příklady

Následující příklad volá metodu StartNew(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 jednotlivých souborech do objektu List<T> . Každý odpojený vnořený úkol vyvolaný smyčkou Parallel.ForEach zkontroluje stav tokenu zrušení a pokud je požadováno zrušení, zavolá metodu CancellationToken.ThrowIfCancellationRequested . Metoda CancellationToken.ThrowIfCancellationRequested vyvolá OperationCanceledException výjimku, která je zpracována catch v bloku 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 void Main()
   {
      var tokenSource = new CancellationTokenSource();
      var token = tokenSource.Token;
      var files = new List<Tuple<string, string, long, DateTime>>();

      var t = Task.Factory.StartNew( () => { 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);
      tokenSource.Cancel();
      try {
         t.Wait(); 
         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

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.Factory.StartNew( 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

Volání StartNew je funkčně ekvivalentní k vytvoření úlohy pomocí jednoho z jejích konstruktorů a následné volání, které ho naplánuje Start ke spuštění.

Počínaje .NET Framework 4.5 můžete metodu Task.Run(Action, CancellationToken) použít jako rychlý způsob volání StartNew(Action, CancellationToken) s výchozími parametry. Všimněte si však, že mezi těmito dvěma metodami Task.Run(Action, CancellationToken) existuje rozdíl: Ve výchozím nastavení neumožňuje podřízené úkoly, které jsou spuštěny s TaskCreationOptions.AttachedToParent možností připojit k aktuální Task instanci, zatímco StartNew(Action, CancellationToken) to dělá. Další informace a příklady kódu naleznete v tématu Task.Run vs Task.Factory.StartNew v paralelním programování s .NET blog.

Viz také

Platí pro

StartNew(Action, TaskCreationOptions)

Vytvoří a spustí úlohu pro zadané možnosti delegáta a vytvoření akce.

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

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

member this.StartNew : Action * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Function StartNew (action As Action, creationOptions As TaskCreationOptions) As Task

Parametry

action: Action

Delegování akce, která se má provést asynchronně.

creationOptions: TaskCreationOptions

Jedna z hodnot výčtu, která řídí chování vytvořené úlohy.

Návraty

Task

Zahájený úkol.

Výjimky

ArgumentNullException

action je null.

ArgumentOutOfRangeException

creationOptions určuje neplatnou TaskCreationOptions hodnotu.

Poznámky

Volání StartNew je funkčně ekvivalentní k vytvoření úlohy pomocí jednoho z jeho konstruktorů a následné volání Start , které ho naplánuje ke spuštění.

Viz také

Platí pro

StartNew(Action)

Vytvoří a spustí úkol pro zadaný delegát akce.

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

public System.Threading.Tasks.Task StartNew (Action action);

member this.StartNew : Action -> System.Threading.Tasks.Task

Public Function StartNew (action As Action) As Task

Parametry

action: Action

Delegování akce, která se má provést asynchronně.

Návraty

Task

Zahájený úkol.

Výjimky

ArgumentNullException

Argument action je null.

Příklady

Následující příklad používá metodu StartNew(Action) k opakovanému vyvolání delegáta Action , který generuje náhodné číslo, interpretuje ho jako bod kódu Unicode, převede ji na jednotku kódu kódování UTF16 a zobrazí informace o výsledném znaku nebo znaky.

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

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      List<Task> tasks  = new List<Task>();
      // Execute the task 10 times.
      for (int ctr = 1; ctr <= 9; ctr++) {
         tasks.Add(Task.Factory.StartNew( () => {
                                            int utf32 = 0;
                                            lock(rnd) {
                                               // Get UTF32 value.
                                               utf32 = rnd.Next(0, 0xE01F0);
                                            }
                                            // Convert it to a UTF16-encoded character.
                                            string utf16 = Char.ConvertFromUtf32(utf32);
                                            // Display information about the character.
                                            Console.WriteLine("0x{0:X8} --> '{1,2}' ({2})", 
                                                              utf32, utf16, ShowHex(utf16));
                                         }));                           
      }
      Task.WaitAll(tasks.ToArray()); 
   }

   private static string ShowHex(string value)
   {
      string hexString = null;
      // Handle only non-control characters.
      if (! Char.IsControl(value, 0)) {
         foreach (var ch in value)
            hexString += $"0x{(ushort)ch:X} ";
      }   
      return hexString.Trim();
   }
}
// The example displays the following output:
//       0x00097103 --> '򗄃' (0x55836 0x56579)
//       0x000A98A1 --> '򩢡' (0x55910 0x56481)
//       0x00050002 --> '񐀂' (0x55552 0x56322)
//       0x0000FEF1 --> 'ﻱ' (0x65265)
//       0x0008BC0A --> '򋰊' (0x55791 0x56330)
//       0x000860EA --> '򆃪' (0x55768 0x56554)
//       0x0009AC5A --> '򚱚' (0x55851 0x56410)
//       0x00053320 --> '񓌠' (0x55564 0x57120)
//       0x000874EF --> '򇓯' (0x55773 0x56559)

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

Public Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim tasks As New List(Of Task)
      ' Execute the task 10 times.
      For ctr As Integer = 1 To 9
         tasks.Add(Task.Factory.StartNew(Sub()
                                            Dim utf32 As Integer
                                            SyncLock(rnd)
                                               ' Get UTF32 value.
                                               utf32 = rnd.Next(0, &hE01F0)
                                            End SyncLock
                                            ' Convert it to a UTF16-encoded character.
                                            Dim utf16 As String = Char.ConvertFromUtf32(utf32)
                                            ' Display information about the character.
                                            Console.WriteLine("0x{0:X8} --> '{1,2}' ({2})", 
                                                              utf32, utf16, ShowHex(utf16))
                                         End Sub))                           
      Next
      Task.WaitAll(tasks.ToArray()) 
   End Sub
   
   Private Function ShowHex(value As String) As String
      Dim hexString As String = Nothing
      ' Handle only non-control characters.
      If Not Char.IsControl(value, 0) Then
         For Each ch In value
            hexString += String.Format("0x{0} ", Convert.ToUInt16(ch))
         Next
      End If   
      Return hexString.Trim()
   End Function
End Module
' The example displays output similar to the following:
'       0x00097103 --> '򗄃' (0x55836 0x56579)
'       0x000A98A1 --> '򩢡' (0x55910 0x56481)
'       0x00050002 --> '񐀂' (0x55552 0x56322)
'       0x0000FEF1 --> 'ﻱ' (0x65265)
'       0x0008BC0A --> '򋰊' (0x55791 0x56330)
'       0x000860EA --> '򆃪' (0x55768 0x56554)
'       0x0009AC5A --> '򚱚' (0x55851 0x56410)
'       0x00053320 --> '񓌠' (0x55564 0x57120)
'       0x000874EF --> '򇓯' (0x55773 0x56559)

Poznámky

Volání StartNew je funkčně ekvivalentní k vytvoření úlohy pomocí jednoho z jeho konstruktorů a následné volání Task.Start metody naplánovat úlohu pro provádění.

Počínaje .NET Framework 4.5 můžete metodu Task.Run(Action) použít jako rychlý způsob volání StartNew(Action) s výchozími parametry. Všimněte si však, že mezi těmito dvěma metodami Task.Run(Action) existuje rozdíl: Ve výchozím nastavení neumožňuje podřízené úkoly, které jsou spuštěny s TaskCreationOptions.AttachedToParent možností připojit k aktuální Task instanci, zatímco StartNew(Action) to dělá. Další informace a příklady kódu naleznete v tématu Task.Run vs Task.Factory.StartNew v paralelním programování s .NET blog.

Viz také

Platí pro

StartNew(Action<Object>, Object)

Vytvoří a spustí úlohu pro zadaný delegát a stav akce.

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

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

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

member this.StartNew : Action<obj> * obj -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object) As Task

Parametry

action: Action<Object>

Delegování akce, která se má provést asynchronně.

state: Object

Objekt obsahující data, která má delegát používat action .

Návraty

Task

Zahájený úkol.

Výjimky

ArgumentNullException

Argument action je null.

Příklady

Následující příklad definuje matici 6 písmen slova. Každé slovo se pak předá delegátu Action<T> , který zakóduje slovo a zobrazí původní slovo a jeho scrambled verzi.

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

public class Example
{
   public static void 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)
         tasks.Add(Task.Factory.StartNew( (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));

      Task.WaitAll(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

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
         tasks.Add(Task.Factory.StartNew( 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))
      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

Volání StartNew je funkčně ekvivalentní vytvoření Task pomocí jednoho z jeho konstruktorů a následné volání Start metody naplánovat jeho spuštění.

Viz také

Platí pro

StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)

Vytvoří a spustí úlohu typu TResult pro zadaného delegáta funkce, token zrušení, možnosti vytvoření a plánovač úkolů.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<TResult> ^ function, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<TResult> function, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.StartNew : Func<'Result> * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of TResult), cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task(Of TResult)

Parametry typu

TResult

Typ výsledku, který je k dispozici prostřednictvím úkolu.

Parametry

function: Func<TResult>

Delegát funkce, který vrátí budoucí výsledek, který bude dostupný prostřednictvím úkolu.

cancellationToken: CancellationToken

Token zrušení, který bude přiřazen k novému úkolu.

creationOptions: TaskCreationOptions

Jedna z hodnot výčtu, která řídí chování vytvořené úlohy.

scheduler: TaskScheduler

Plánovač úloh, který se používá k naplánování vytvořené úlohy.

Návraty

Task<TResult>

Zahájený úkol.

Výjimky

ObjectDisposedException

CancellationToken Poskytnutý již byl vyřazen.

ArgumentNullException

function je null.

-nebo- scheduler je null.

ArgumentOutOfRangeException

creationOptions určuje neplatnou TaskCreationOptions hodnotu. Další informace najdete v poznámkách pro FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)

Poznámky

Volání StartNew je funkčně ekvivalentní vytvoření Task<TResult> pomocí jednoho z jeho konstruktorů a následné volání, které ho naplánuje Start ke spuštění.

Počínaje .NET Framework 4.5 můžete metodu Run použít s objektem Action jako rychlý způsob volání StartNew s výchozími parametry. Další informace a příklady kódu naleznete v položce Task.Run vs. Task.Factory.StartNew v paralelním programování s .NET blog.

Viz také

Platí pro

StartNew<TResult>(Func<TResult>)

Vytvoří a spustí úkol typu TResult pro zadaného delegáta funkce.

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

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

member this.StartNew : Func<'Result> -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of TResult)) As Task(Of TResult)

Parametry typu

TResult

Typ výsledku, který je k dispozici prostřednictvím úkolu.

Parametry

function: Func<TResult>

Delegát funkce, který vrátí budoucí výsledek, který bude dostupný prostřednictvím úkolu.

Návraty

Task<TResult>

Zahájený úkol.

Výjimky

ArgumentNullException

Argument function je null.

Příklady

Následující příklad je jednoduchá aplikace sčítání, která vygeneruje dvě náhodná čísla a vyzve uživatele k zadání součtu. Pak označuje, jestli je odpověď správná, nebo pokud odpověď uživatele není platné číslo, vyzve uživatele k opětovnému zadání platného čísla. Slouží StartNew k vytvoření Task<TResult> objektů, které vracejí náhodná čísla, která se mají sčítat.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      Task<int>[] tasks = new Task<int>[2];
      Object obj = new Object();
      
      while (true) {
         for (int ctr = 0; ctr <= 1; ctr++)
            tasks[ctr] = Task.Factory.StartNew(() => { int i = 0;
                                                       lock(obj) {
                                                          i = rnd.Next(101);
                                                       }
                                                       return i; });

         Task.WaitAll(tasks);
         int n1 = tasks[0].Result;
         int n2 = tasks[1].Result;
         int result = n1 + n2;
         bool validInput = false;
         while (! validInput) {
            ShowMessage(n1, n2);
            string userInput = Console.ReadLine();
            // Process user input.
            if (userInput.Trim().ToUpper() == "X") return;
            int answer;
            validInput = Int32.TryParse(userInput, out answer);
            if (! validInput)
               Console.WriteLine("Invalid input. Try again, but enter only numbers. ");
            else if (answer == result)
               Console.WriteLine("Correct!");
            else
               Console.WriteLine("Incorrect. The correct answer is {0}.", result);
         }
      }
   }

   private static void ShowMessage(int n1, int n2)
   {
      Console.WriteLine("\nEnter 'x' to exit...");
      Console.Write("{0} + {1} = ", n1, n2);
   }
}
// The example displays the following output:
//       Enter 'x' to exit...
//       15 + 11 = 26
//       Correct!
//
//       Enter 'x' to exit...
//       75 + 33 = adc
//       Invalid input. Try again, but enter only numbers.
//
//       Enter 'x' to exit...
//       75 + 33 = 108
//       Correct!
//
//       Enter 'x' to exit...
//       67 + 55 = 133
//       Incorrect. The correct answer is 122.
//
//       Enter 'x' to exit...
//       92 + 51 = 133
//       Incorrect. The correct answer is 143.
//
//       Enter 'x' to exit...
//       81 + 65 = x

   
Imports System.Threading.Tasks

Module AdditionTester
   Public Sub Main()
      Dim rnd As New Random()
      Dim tasks(1) As Task(Of Integer)
      Dim obj As New Object()
      
      Do While True
         For ctr As Integer = 0 To 1
            tasks(ctr) = Task.Factory.StartNew(Function()
                                                  Dim i As Integer
                                                  SyncLock(obj)
                                                     i = rnd.Next(101)
                                                  End SyncLock
                                                  Return i
                                               End Function)
         Next
         Task.WaitAll(tasks)
         Dim n1 As Integer = tasks(0).Result
         Dim n2 As Integer = tasks(1).Result
         Dim result As Integer = n1 + n2
         Dim validInput As Boolean = False
         Do While Not validInput
            ShowMessage(n1, n2)
            Dim userInput As String = Console.ReadLine()
            ' Process user input.
            If userInput.Trim().ToUpper = "X" Then Exit Sub
            Dim answer As Integer
            validInput = Int32.TryParse(userInput, answer)
            If Not validInput Then
               Console.WriteLine("Invalid input. Try again, but enter only numbers. ")
            Else If answer = result Then
               Console.WriteLine("Correct!")
            Else
               Console.WriteLine("Incorrect. The correct answer is {0}.", result)
            End If
         Loop
      Loop
   End Sub
   
   Private Sub ShowMessage(n1 As Integer, n2 As Integer)
      Console.WriteLine()
      Console.WriteLine("Enter 'x' to exit...")
      Console.Write("{0} + {1} = ", n1, n2)
   End Sub
End Module
' The example displays output like the following:
'       Enter 'x' to exit...
'       15 + 11 = 26
'       Correct!
'
'       Enter 'x' to exit...
'       75 + 33 = adc
'       Invalid input. Try again, but enter only numbers.
'
'       Enter 'x' to exit...
'       75 + 33 = 108
'       Correct!
'
'       Enter 'x' to exit...
'       67 + 55 = 133
'       Incorrect. The correct answer is 122.
'
'       Enter 'x' to exit...
'       92 + 51 = 133
'       Incorrect. The correct answer is 143.
'
'       Enter 'x' to exit...
'       81 + 65 = x

Poznámky

Volání StartNew je funkčně ekvivalentní vytvoření Task<TResult> pomocí jednoho z jeho konstruktorů a následné volání, které ho naplánuje Start ke spuštění.

Počínaje .NET Framework 4.5 můžete metodu Task.Run<TResult>(Func<TResult>) volat jako rychlý způsob volání StartNew s výchozími parametry. Všimněte si však, že mezi těmito dvěma metodami Task.Run<TResult>(Func<TResult>) existuje rozdíl: Ve výchozím nastavení neumožňuje podřízené úkoly, které jsou spuštěny s TaskCreationOptions.AttachedToParent možností připojit k aktuální Task<TResult> instanci, zatímco StartNew<TResult>(Func<TResult>) to dělá. Další informace a příklady kódu naleznete v položce Task.Run vs. Task.Factory.StartNew v paralelním programování s .NET blog.

Viz také

Platí pro

StartNew<TResult>(Func<Object,TResult>, Object)

Vytvoří a spustí úlohu typu TResult pro zadaný delegát a stav funkce.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<System::Object ^, TResult> ^ function, System::Object ^ state);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object,TResult> function, object state);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object?,TResult> function, object? state);

member this.StartNew : Func<obj, 'Result> * obj -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object) As Task(Of TResult)

Parametry typu

TResult

Typ výsledku, který je k dispozici prostřednictvím úkolu.

Parametry

function: Func<Object,TResult>

Delegát funkce, který vrátí budoucí výsledek, který bude dostupný prostřednictvím úkolu.

state: Object

Objekt obsahující data, která má delegát používat function .

Návraty

Task<TResult>

Zahájený úkol.

Výjimky

ArgumentNullException

function je null.

Poznámky

Volání StartNew je funkčně ekvivalentní vytvoření Task<TResult> pomocí jednoho z jeho konstruktorů a následné volání, které ho naplánuje Start ke spuštění.

Viz také

Platí pro

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

Vytvoří a spustí úlohu typu TResult pro zadaný delegát funkce a token zrušení.

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

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

member this.StartNew : Func<'Result> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

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

Parametry typu

TResult

Typ výsledku, který je k dispozici prostřednictvím úkolu.

Parametry

function: Func<TResult>

Delegát funkce, který vrátí budoucí výsledek, který bude dostupný prostřednictvím úkolu.

cancellationToken: CancellationToken

Token zrušení, který bude přiřazen k novému úkolu.

Návraty

Task<TResult>

Zahájený úkol.

Výjimky

ObjectDisposedException

CancellationToken Poskytnutý již byl vyřazen.

ArgumentNullException

function je null.

Příklady

Následující příklad používá dva úkoly k výpočtu fibonacciho sekvence končící na F100 = F100-1 + F100-2 s počátečními hodnotami F1= 1, F2 = 1 a F1 = 0, F2= 1. Přibližně polovina času se při provádění operací nastaví token zrušení. Výstup z příkladu ukazuje výsledek, pokud se dva úkoly úspěšně dokončily a pokud je token zrušen.

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

public class Example
{
   public static void Main()
   {
      var rnd = new Random();
      var tasks = new List<Task<BigInteger[]>>();
      var source = new CancellationTokenSource();
      var token = source.Token;
      for (int ctr = 0; ctr <= 1; ctr++) {
         int start = ctr;
         tasks.Add(Task.Run( () => { BigInteger[] sequence = new BigInteger[100];
                                     sequence[0] = start;
                                     sequence[1] = 1;
                                     for (int index = 2; index <= sequence.GetUpperBound(0); index++) {
                                        token.ThrowIfCancellationRequested();
                                        sequence[index] = sequence[index - 1] + sequence[index - 2];
                                     }
                                     return sequence;
                                   }, token));
      }
      if (rnd.Next(0, 2) == 1)
         source.Cancel();
      try {
         Task.WaitAll(tasks.ToArray());
         foreach (var t in tasks)
            Console.WriteLine("{0}, {1}...{2:N0}", t.Result[0], t.Result[1],
                              t.Result[99]);
      }
      catch (AggregateException e) {
         foreach (var ex in e.InnerExceptions)
            Console.WriteLine("{0}: {1}", ex.GetType().Name, ex.Message);
      }
   }
}
// The example displays either the following output:
//    0, 1...218,922,995,834,555,169,026
//    1, 1...354,224,848,179,261,915,075
// or the following output:
//    TaskCanceledException: A task was canceled.
//    TaskCanceledException: A task was canceled.

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

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim tasks As New List(Of Task(Of BigInteger()))
      Dim source As New CancellationTokenSource
      Dim token As CancellationToken = source.Token
      For ctr As Integer = 0 To 1
         Dim start As Integer = ctr
         tasks.Add(Task.Run(Function()
                               Dim sequence(99) As BigInteger
                               sequence(0) = start
                               sequence(1) = 1
                               For index As Integer = 2 To sequence.GetUpperBound(0)
                                  token.ThrowIfCancellationRequested()
                                  sequence(index) = sequence(index - 1) + sequence(index - 2)
                               Next
                               Return sequence
                            End Function, token))
      Next
      If rnd.Next(0, 2) = 1 Then source.Cancel
      Try
         Task.WaitAll(tasks.ToArray())
         For Each t In tasks
            Console.WriteLine("{0}, {1}...{2:N0}", t.Result(0), t.Result(1),
                              t.Result(99))
         Next
      Catch e As AggregateException
         For Each ex In e.InnerExceptions
            Console.WriteLine("{0}: {1}", ex.GetType().Name, ex.Message)
         Next
      End Try
   End Sub
End Module
' The example displays either the following output:
'    0, 1...218,922,995,834,555,169,026
'    1, 1...354,224,848,179,261,915,075
' or the following output:
'    TaskCanceledException: A task was canceled.
'    TaskCanceledException: A task was canceled.

Poznámky

Volání StartNew je funkčně ekvivalentní vytvoření Task<TResult> pomocí jednoho z jeho konstruktorů a následné volání, které ho naplánuje Start ke spuštění.

Počínaje .NET Framework 4.5 můžete metodu Task.Run<TResult>(Func<TResult>, CancellationToken) použít jako rychlý způsob volání StartNew<TResult>(Func<TResult>, CancellationToken) s výchozími parametry. Všimněte si však, že mezi těmito dvěma metodami Task.Run<TResult>(Func<TResult>, CancellationToken) existuje rozdíl: Ve výchozím nastavení neumožňuje podřízené úkoly, které jsou spuštěny s TaskCreationOptions.AttachedToParent možností připojit k aktuální Task<TResult> instanci, zatímco StartNew<TResult>(Func<TResult>, CancellationToken) to dělá. Další informace a příklady kódu naleznete v položce Task.Run vs. Task.Factory.StartNew v paralelním programování s .NET blog.

Viz také

Platí pro

StartNew<TResult>(Func<TResult>, TaskCreationOptions)

Vytvoří a spustí úlohu typu TResult pro zadaného delegáta funkce a možnosti vytváření.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<TResult> ^ function, System::Threading::Tasks::TaskCreationOptions creationOptions);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<TResult> function, System.Threading.Tasks.TaskCreationOptions creationOptions);

member this.StartNew : Func<'Result> * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of TResult), creationOptions As TaskCreationOptions) As Task(Of TResult)

Parametry typu

TResult

Typ výsledku, který je k dispozici prostřednictvím úkolu.

Parametry

function: Func<TResult>

Delegát funkce, který vrátí budoucí výsledek, který bude dostupný prostřednictvím úkolu.

creationOptions: TaskCreationOptions

Jedna z hodnot výčtu, která řídí chování vytvořené úlohy.

Návraty

Task<TResult>

Zahájený úkol.

Výjimky

ArgumentNullException

function je null.

ArgumentOutOfRangeException

Poznámky

Volání StartNew je funkčně ekvivalentní vytvoření Task<TResult> pomocí jednoho z jeho konstruktorů a následné volání, které ho naplánuje Start ke spuštění.

Viz také

Platí pro

StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken)

Vytvoří a spustí úlohu typu TResult pro zadaný delegát funkce, stav a token zrušení.

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

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object,TResult> function, object state, System.Threading.CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object?,TResult> function, object? state, System.Threading.CancellationToken cancellationToken);

member this.StartNew : Func<obj, 'Result> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object, cancellationToken As CancellationToken) As Task(Of TResult)

Parametry typu

TResult

Typ výsledku, který je k dispozici prostřednictvím úkolu.

Parametry

function: Func<Object,TResult>

Delegát funkce, který vrátí budoucí výsledek, který bude dostupný prostřednictvím úkolu.

state: Object

Objekt obsahující data, která má delegát používat function .

cancellationToken: CancellationToken

Token zrušení, který bude přiřazen k novému úkolu.

Návraty

Task<TResult>

Zahájený úkol.

Výjimky

ObjectDisposedException

CancellationToken Poskytnutý již byl vyřazen.

ArgumentNullException

function je null.

Poznámky

Volání StartNew je funkčně ekvivalentní vytvoření Task<TResult> pomocí jednoho z jeho konstruktorů a následné volání, které ho naplánuje Start ke spuštění.

Viz také

Platí pro

StartNew<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)

Vytvoří a spustí úlohu typu TResult pro zadané možnosti delegáta funkce, stavu a vytváření.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<System::Object ^, TResult> ^ function, System::Object ^ state, System::Threading::Tasks::TaskCreationOptions creationOptions);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object,TResult> function, object state, System.Threading.Tasks.TaskCreationOptions creationOptions);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object?,TResult> function, object? state, System.Threading.Tasks.TaskCreationOptions creationOptions);

member this.StartNew : Func<obj, 'Result> * obj * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object, creationOptions As TaskCreationOptions) As Task(Of TResult)

Parametry typu

TResult

Typ výsledku, který je k dispozici prostřednictvím úkolu.

Parametry

function: Func<Object,TResult>

Delegát funkce, který vrátí budoucí výsledek, který bude dostupný prostřednictvím úkolu.

state: Object

Objekt obsahující data, která má delegát používat function .

creationOptions: TaskCreationOptions

Jedna z hodnot výčtu, která řídí chování vytvořené úlohy.

Návraty

Task<TResult>

Zahájený úkol.

Výjimky

ArgumentNullException

function je null.

ArgumentOutOfRangeException

Poznámky

Volání StartNew je funkčně ekvivalentní vytvoření Task<TResult> pomocí jednoho z jeho konstruktorů a následné volání, které ho naplánuje Start ke spuštění.

Viz také

Platí pro

StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)

Vytvoří a spustí úlohu typu TResult pro zadaný delegát funkce, stav, token zrušení, možnosti vytvoření a plánovač úloh.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<System::Object ^, TResult> ^ function, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object,TResult> function, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object?,TResult> function, object? state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.StartNew : Func<obj, 'Result> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task(Of TResult)

Parametry typu

TResult

Typ výsledku, který je k dispozici prostřednictvím úkolu.

Parametry

function: Func<Object,TResult>

Delegát funkce, který vrátí budoucí výsledek, který bude dostupný prostřednictvím úkolu.

state: Object

Objekt obsahující data, která má delegát používat function .

cancellationToken: CancellationToken

Token zrušení, který bude přiřazen k novému úkolu.

creationOptions: TaskCreationOptions

Jedna z hodnot výčtu, která řídí chování vytvořené úlohy.

scheduler: TaskScheduler

Plánovač úloh, který se používá k naplánování vytvořené úlohy.

Návraty

Task<TResult>

Zahájený úkol.

Výjimky

ObjectDisposedException

CancellationToken Poskytnutý již byl vyřazen.

ArgumentNullException

function je null.

-nebo- scheduler je null.

ArgumentOutOfRangeException

Poznámky

Volání StartNew je funkčně ekvivalentní vytvoření Task<TResult> pomocí jednoho z jeho konstruktorů a následné volání, které ho naplánuje Start ke spuštění.

Viz také

Platí pro