TaskFactory.StartNew 方法

參考

定義

命名空間:: System.Threading.Tasks

組件:: System.Threading.Tasks.dll

組件:: System.Runtime.dll

組件:: mscorlib.dll

組件:: netstandard.dll

重要

部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。

建立並啟動工作。

多載

StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	建立並啟動所指定動作委派、狀態、取消語彙基元、建立選項以及工作排程器的工作。
StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)	建立並啟動所指定動作委派、取消語彙基元、建立選項以及狀態的工作。
StartNew(Action<Object>, Object, TaskCreationOptions)	建立並啟動所指定動作委派、狀態以及建立選項的工作。
StartNew(Action<Object>, Object, CancellationToken)	建立並啟動所指定動作委派、狀態以及取消語彙基元的工作。
StartNew(Action, CancellationToken)	建立並啟動所指定動作委派和取消語彙基元的工作。
StartNew(Action, TaskCreationOptions)	建立並啟動所指定動作委派和建立選項的工作。
StartNew(Action)	建立並啟動所指定動作委派的工作。
StartNew(Action<Object>, Object)	建立並啟動所指定動作委派和狀態的工作。
StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)	建立並啟動所指定函式委派、取消語彙基元、建立選項以及工作排程器其類型為 `TResult` 的工作。
StartNew<TResult>(Func<TResult>)	建立並啟動所指定函式委派其類型為 `TResult` 的工作。
StartNew<TResult>(Func<Object,TResult>, Object)	建立並啟動所指定函式委派其類型為 `TResult` 的工作。
StartNew<TResult>(Func<TResult>, CancellationToken)	建立並啟動所指定函式委派和取消語彙基元其類型為 `TResult` 的工作。
StartNew<TResult>(Func<TResult>, TaskCreationOptions)	建立並啟動所指定函式委派和建立選項其類型為 `TResult` 的工作。
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken)	建立並啟動所指定函式委派、狀態以及取消語彙基元其類型為 `TResult` 的工作。
StartNew<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	建立並啟動所指定函式委派、狀態以及建立選項其類型為 `TResult` 的工作。
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	建立並啟動所指定函式委派、狀態、取消語彙基元、建立選項以及工作排程器其類型為 `TResult` 的工作。

備註

從 .NET Framework 4.5 開始，方法是 Task.Run 啟動計算系結工作的建議方式。 StartNew只有在需要長時間執行且計算系結工作的精細控制時，才使用方法。這包括您想要控制下列情況的案例：

工作建立選項。根據預設， Task.Run 方法所建立的工作會使用 TaskCreationOptions.DenyChildAttach 選項來建立。若要覆寫此行為，或提供其他 TaskCreationOptions 選項，請呼叫 StartNew 多載。
參數傳遞。方法的多 Task.Run 載不允許您將參數傳遞至工作委派。方法 StartNew 的多載會執行。
工作排程器。方法的多 Task.Run 載會使用預設的工作排程器。若要控制工作排程器，請使用參數呼叫 StartNew 多 scheduler 載。如需詳細資訊，請參閱TaskScheduler。

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

建立並啟動所指定動作委派、狀態、取消語彙基元、建立選項以及工作排程器的工作。

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

參數

action: Action<Object>

要以非同步方式執行的動作委派。

state: Object

物件，包含 action 委派要使用的資料。

cancellationToken: CancellationToken

要指派給新工作的取消語彙基元。

creationOptions: TaskCreationOptions

其中一個列舉值，這些值會控制已建立之工作的行為。

scheduler: TaskScheduler

用來排定所建立之工作的工作排程器。

傳回

Task

已開始的工作。

例外狀況

ObjectDisposedException

提供的 CancellationToken 已經過處置。

ArgumentNullException

action 為 null。

-或-

scheduler 為 null。

ArgumentOutOfRangeException

creationOptions 引數指定無效的 TaskCreationOptions 值。如需詳細資訊，請參閱 FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions) 的＜備註＞

備註

呼叫 StartNew 的功能相當於使用其中一個建構函式建立工作，然後呼叫 Start 以排程執行。

從 .NET Framework 4.5 開始，您可以使用 Run 方法搭配 Action 物件，以快速呼叫 StartNew 預設參數。如需詳細資訊和程式碼範例，請參閱使用 .NET 平行程式設計部落格中的 Task.Run 與 Task.Factory.StartNew 。

另請參閱

適用於

StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)

建立並啟動所指定動作委派、取消語彙基元、建立選項以及狀態的工作。

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

參數

action: Action

要以非同步方式執行的動作委派。

cancellationToken: CancellationToken

要指派給新工作的取消語彙基元。

creationOptions: TaskCreationOptions

其中一個列舉值，這些值會控制已建立之工作的行為。

scheduler: TaskScheduler

用來排定所建立之工作的工作排程器。

傳回

Task

已開始的工作。

例外狀況

ObjectDisposedException

提供的 CancellationToken 已經過處置。

ArgumentNullException

action 為 null。

-或- scheduler 為 null。

ArgumentOutOfRangeException

creationOptions 指定無效的 TaskCreationOptions 值。如需詳細資訊，請參閱 FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions) 的＜備註＞

備註

呼叫 StartNew 的功能相當於使用其中一個建構函式建立工作，然後呼叫 Start 以排程執行。

另請參閱

適用於

StartNew(Action<Object>, Object, TaskCreationOptions)

建立並啟動所指定動作委派、狀態以及建立選項的工作。

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

參數

action: Action<Object>

要以非同步方式執行的動作委派。

state: Object

物件，包含 action 委派要使用的資料。

creationOptions: TaskCreationOptions

其中一個列舉值，這些值會控制已建立之工作的行為。

傳回

Task

已開始的工作。

例外狀況

ArgumentNullException

action 為 null。

ArgumentOutOfRangeException

creationOptions 指定無效的 TaskCreationOptions 值。

備註

呼叫 StartNew 的功能相當於使用其中一個建構函式建立工作，然後呼叫 Start 以排程執行。

另請參閱

適用於

StartNew(Action<Object>, Object, CancellationToken)

建立並啟動所指定動作委派、狀態以及取消語彙基元的工作。

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

參數

action: Action<Object>

要以非同步方式執行的動作委派。

state: Object

物件，包含 action 委派要使用的資料。

cancellationToken: CancellationToken

要指派給新工作的取消語彙基元。

傳回

Task

已開始的工作。

例外狀況

ObjectDisposedException

提供的 CancellationToken 已經過處置。

ArgumentNullException

action 為 null。

範例

下列範例會定義 6 個字母字組的陣列。然後，每個單字都會傳遞至 Action<T> 委派，這會拼字並顯示原始單字及其拼字版本。

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

請注意，此範例會初始化受鎖定保護的單一亂數產生器。 For the need of a lock, see "The System.Random class and thread safety" in the Random class topic. 若要處理亂數產生器損毀的可能性，則會將取消權杖傳遞至工作。如果兩個亂數等於零，則方法會假設亂數產生器已損毀，並設定解除標記。在排序 chars 包含單字中六個字元的陣列之前，方法會呼叫 CancellationToken.ThrowIfCancellationRequested 方法，以在權杖取消時擲 OperationCanceledException 回。

備註

呼叫 StartNew 的功能相當於使用其中一個建構函式建立工作，然後呼叫 Start 以排程執行。

另請參閱

適用於

StartNew(Action, CancellationToken)

建立並啟動所指定動作委派和取消語彙基元的工作。

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

參數

action: Action

要以非同步方式執行的動作委派。

cancellationToken: CancellationToken

要指派給新工作的取消語彙基元。

傳回

Task

已開始的工作。

例外狀況

ObjectDisposedException

提供的 CancellationToken 已經過處置。

ArgumentNullException

action 為 null。

範例

下列範例會呼叫 StartNew(Action, CancellationToken) 方法來建立工作，以逐一查看 C：\Windows\System32 目錄中的檔案。 Lambda 運算式會呼叫方法， Parallel.ForEach 將每個檔案的相關資訊新增至 List<T> 物件。迴圈所 Parallel.ForEach 叫用的每個中斷連結巢狀工作都會檢查取消權杖的狀態，如果要求取消，則會呼叫 CancellationToken.ThrowIfCancellationRequested 方法。方法 CancellationToken.ThrowIfCancellationRequested 會在 OperationCanceledException 呼叫執行緒呼叫 Task.Wait 方法時，擲回區塊中 catch 處理的例外狀況。

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

備註

呼叫 StartNew 的功能相當於使用其中一個建構函式建立 Task，然後呼叫 Start 以排程執行。

從 .NET Framework 4.5 開始，您可以使用方法來快速 StartNew(Action, CancellationToken) 呼叫 Task.Run(Action, CancellationToken) 預設參數。不過，請注意，這兩個方法之間的行為有差異： Task.Run(Action, CancellationToken) 根據預設，不允許使用附加至目前 Task 實例的選項啟動 TaskCreationOptions.AttachedToParent 子工作，而會 StartNew(Action, CancellationToken) 這樣做。如需詳細資訊和程式碼範例，請參閱使用 .NET 平行程式設計部落格中的 Task.Run 與 Task.Factory.StartNew 。

另請參閱

適用於

StartNew(Action, TaskCreationOptions)

建立並啟動所指定動作委派和建立選項的工作。

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

參數

action: Action

要以非同步方式執行的動作委派。

creationOptions: TaskCreationOptions

其中一個列舉值，這些值會控制已建立之工作的行為。

傳回

Task

已開始的工作。

例外狀況

ArgumentNullException

action 為 null。

ArgumentOutOfRangeException

creationOptions 指定無效的 TaskCreationOptions 值。

備註

呼叫 StartNew 的功能相當於使用其中一個建構函式建立工作，然後呼叫 Start 以排程執行。

另請參閱

適用於

StartNew(Action)

建立並啟動所指定動作委派的工作。

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

參數

action: Action

要以非同步方式執行的動作委派。

傳回

Task

已開始的工作。

例外狀況

ArgumentNullException

action 引數為 null。

範例

下列範例會 StartNew(Action) 使用方法來重複叫 Action 用產生亂數的委派、將它解譯為 Unicode 字碼點、將它轉換成 UTF16 編碼的程式碼單位，以及顯示所產生字元或字元的相關資訊。

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)

備註

呼叫 StartNew 的功能相當於使用其中一個建構函式建立工作，然後呼叫 Task.Start 方法來排程工作執行。

從 .NET Framework 4.5 開始，您可以使用方法來快速 StartNew(Action) 呼叫 Task.Run(Action) 預設參數。不過，請注意，這兩個方法之間的行為有差異： Task.Run(Action) 根據預設，不允許使用附加至目前 Task 實例的選項啟動 TaskCreationOptions.AttachedToParent 子工作，而會 StartNew(Action) 這樣做。如需詳細資訊和程式碼範例，請參閱使用 .NET 平行程式設計部落格中的 Task.Run 與 Task.Factory.StartNew 。

另請參閱

適用於

StartNew(Action<Object>, Object)

建立並啟動所指定動作委派和狀態的工作。

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

參數

action: Action<Object>

要以非同步方式執行的動作委派。

state: Object

物件，包含 action 委派要使用的資料。

傳回

Task

已開始的工作。

例外狀況

ArgumentNullException

action 引數為 null。

範例

下列範例會定義 6 個字母字組的陣列。然後，每個單字都會傳遞至 Action<T> 委派，這會拼字並顯示原始單字及其拼字版本。

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

請注意，此範例會初始化受鎖定保護的單一亂數產生器。 For the need of a lock, see "The System.Random class and thread safety" in the Random class topic.

備註

呼叫 StartNew 的功能相當於使用其中一個建構函式建立 Task ，然後呼叫 Start 方法來排程執行。

另請參閱

適用於

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

建立並啟動所指定函式委派、取消語彙基元、建立選項以及工作排程器其類型為 TResult 的工作。

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)

類型參數

TResult

可透過工作取得的結果類型。

參數

function: Func<TResult>

函式委派，會傳回將可透過工作使用的未來結果。

cancellationToken: CancellationToken

要指派給新工作的取消語彙基元。

creationOptions: TaskCreationOptions

其中一個列舉值，這些值會控制已建立之工作的行為。

scheduler: TaskScheduler

用來排定所建立之工作的工作排程器。

傳回

Task<TResult>

已開始的工作。

例外狀況

ObjectDisposedException

提供的 CancellationToken 已經過處置。

ArgumentNullException

function 為 null。

-或- scheduler 為 null。

ArgumentOutOfRangeException

備註

呼叫 StartNew 的功能相當於使用其中一個建構函式建立 Task<TResult> ，然後呼叫 Start 以排程執行。

從 .NET Framework 4.5 開始，您可以使用 Run 方法搭配 Action 物件，以快速方式呼叫 StartNew 預設參數。如需詳細資訊和程式碼範例，請參閱使用 .NET 平行程式設計部落格中的 Task.Run 與 Task.Factory.StartNew 專案。

另請參閱

適用於

StartNew<TResult>(Func<TResult>)

建立並啟動所指定函式委派其類型為 TResult 的工作。

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)

類型參數

TResult

可透過工作取得的結果類型。

參數

function: Func<TResult>

函式委派，會傳回將可透過工作使用的未來結果。

傳回

Task<TResult>

已開始的工作。

例外狀況

ArgumentNullException

function 引數為 null。

範例

下列範例是一個簡單的加法應用程式，會產生兩個亂數，並提示使用者輸入其總和。然後會指出答案是否正確，或者，如果使用者的回應不是有效的數位，則會提示使用者重新輸入有效的數位。 StartNew用來建立 Task<TResult> 物件，以傳回要加入的亂數。

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

備註

呼叫 StartNew 的功能相當於使用其中一個建構函式建立 Task<TResult> ，然後呼叫 Start 以排程執行。

從 .NET Framework 4.5 開始，您可以使用預設參數快速呼叫 Task.Run<TResult>(Func<TResult>) StartNew 方法。不過，請注意，這兩個方法之間的行為有差異： Task.Run<TResult>(Func<TResult>) 根據預設，不允許使用附加至目前 Task<TResult> 實例的選項啟動 TaskCreationOptions.AttachedToParent 子工作，而會 StartNew<TResult>(Func<TResult>) 這樣做。如需詳細資訊和程式碼範例，請參閱使用 .NET 平行程式設計部落格中的 Task.Run 與 Task.Factory.StartNew 專案。

另請參閱

適用於

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

建立並啟動所指定函式委派其類型為 TResult 的工作。

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)

類型參數

TResult

可透過工作取得的結果類型。

參數

function: Func<Object,TResult>

函式委派，會傳回將可透過工作使用的未來結果。

state: Object

物件，包含 function 委派要使用的資料。

傳回

Task<TResult>

已開始的工作。

例外狀況

ArgumentNullException

function 為 null。

備註

呼叫 StartNew 的功能相當於使用其中一個建構函式建立 Task<TResult> ，然後呼叫 Start 以排程執行。

從 .NET Framework 4.5 開始，您可以使用 Run 方法搭配 Action 物件，以快速呼叫 StartNew 預設參數。如需詳細資訊和程式碼範例，請參閱使用 .NET 平行程式設計部落格中的 Task.Run 與 Task.Factory.StartNew 專案。

另請參閱

適用於

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

建立並啟動所指定函式委派和取消語彙基元其類型為 TResult 的工作。

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)

類型參數

TResult

可透過工作取得的結果類型。

參數

function: Func<TResult>

函式委派，會傳回將可透過工作使用的未來結果。

cancellationToken: CancellationToken

要指派給新工作的取消語彙基元。

傳回

Task<TResult>

已開始的工作。

例外狀況

ObjectDisposedException

提供的 CancellationToken 已經過處置。

ArgumentNullException

function 為 null。

範例

下列範例會使用兩個工作來計算 F100 = F100 = F100-1 + F100-2 結尾的 Fibonacci 序列，其種子值 F1= 1、F2 = 1 和 F1 = 0、F2= 1。大約一半的時間，取消權杖會設定為作業執行。如果兩個工作順利完成，以及權杖已取消，則此範例的輸出會顯示結果。

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.

備註

呼叫 StartNew 的功能相當於使用其中一個建構函式建立 Task<TResult> ，然後呼叫 Start 以排程執行。

從 .NET Framework 4.5 開始，您可以使用方法來快速 StartNew<TResult>(Func<TResult>, CancellationToken) 呼叫 Task.Run<TResult>(Func<TResult>, CancellationToken) 預設參數。不過，請注意，這兩個方法之間的行為有差異： Task.Run<TResult>(Func<TResult>, CancellationToken) 根據預設，不允許使用附加至目前 Task<TResult> 實例的選項啟動 TaskCreationOptions.AttachedToParent 子工作，而會 StartNew<TResult>(Func<TResult>, CancellationToken) 這樣做。如需詳細資訊和程式碼範例，請參閱使用 .NET 平行程式設計部落格中的 Task.Run 與 Task.Factory.StartNew 專案。

另請參閱

適用於

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

建立並啟動所指定函式委派和建立選項其類型為 TResult 的工作。

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)

類型參數

TResult

可透過工作取得的結果類型。

參數

function: Func<TResult>

函式委派，會傳回將可透過工作使用的未來結果。

creationOptions: TaskCreationOptions

其中一個列舉值，這些值會控制已建立之工作的行為。

傳回

Task<TResult>

已開始的工作。

例外狀況

ArgumentNullException

function 為 null。

ArgumentOutOfRangeException

備註

呼叫 StartNew 的功能相當於使用其中一個建構函式建立 Task<TResult> ，然後呼叫 Start 以排程執行。

另請參閱

適用於

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

建立並啟動所指定函式委派、狀態以及取消語彙基元其類型為 TResult 的工作。

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)

類型參數

TResult

可透過工作取得的結果類型。

參數

function: Func<Object,TResult>

函式委派，會傳回將可透過工作使用的未來結果。

state: Object

物件，包含 function 委派要使用的資料。

cancellationToken: CancellationToken

要指派給新工作的取消語彙基元。

傳回

Task<TResult>

已開始的工作。

例外狀況

ObjectDisposedException

提供的 CancellationToken 已經過處置。

ArgumentNullException

function 為 null。

備註

呼叫 StartNew 的功能相當於使用其中一個建構函式建立 Task<TResult> ，然後呼叫 Start 以排程執行。

另請參閱

適用於

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

建立並啟動所指定函式委派、狀態以及建立選項其類型為 TResult 的工作。

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)

類型參數

TResult

可透過工作取得的結果類型。

參數

function: Func<Object,TResult>

函式委派，會傳回將可透過工作使用的未來結果。

state: Object

物件，包含 function 委派要使用的資料。

creationOptions: TaskCreationOptions

其中一個列舉值，這些值會控制已建立之工作的行為。

傳回

Task<TResult>

已開始的工作。

例外狀況

ArgumentNullException

function 為 null。

ArgumentOutOfRangeException

備註

呼叫 StartNew 的功能相當於使用其中一個建構函式建立 Task<TResult> ，然後呼叫 Start 以排程執行。

另請參閱

適用於

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

建立並啟動所指定函式委派、狀態、取消語彙基元、建立選項以及工作排程器其類型為 TResult 的工作。

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)