C# TaskFactory.StartNew 方法

要异步执行的操作委托。

state

一个包含由 action 委托使用的数据的对象。

cancellationToken

将指派给新的任务的取消标记。

creationOptions

控制所创建的任务的行为的枚举值之一。

scheduler

用于计划所创建的任务的任务计划程序。

已启动的任务。

例外

已释放提供的 CancellationToken。

action 为 null。

或

scheduler 为 null。

creationOptions 参数指定了一个无效的 TaskCreationOptions 值。有关更多信息，请参见 FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions) 的备注

注解

调用 StartNew 在功能上等效于使用它的一个构造函数创建任务，然后调用 Start 以计划执行该任务。

从 .NET Framework 4.5 开始，可以将 Run 方法与对象结合使用， Action 作为使用默认参数调用的快速方法 StartNew 。有关详细信息和代码示例，请参阅与 .NET 并行编程中的 StartNew Vs 任务。

适用于

.NET 6 和其他版本

StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)

为指定的操作委托、取消令牌、创建选项和状态创建并启动任务。

C#复制

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

参数

action

要异步执行的操作委托。

cancellationToken

将指派给新的任务的取消标记。

creationOptions

控制所创建的任务的行为的枚举值之一。

scheduler

用于计划所创建的任务的任务计划程序。

已启动的任务。

例外

已释放提供的 CancellationToken。

action 为 null。

或 scheduler 为 null。

creationOptions 指定了无效的 TaskCreationOptions 值。有关更多信息，请参见 FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions) 的备注

注解

调用 StartNew 在功能上等效于使用它的一个构造函数创建任务，然后调用 Start 以计划执行该任务。

适用于

.NET 6 和其他版本

StartNew(Action<Object>, Object, TaskCreationOptions)

为指定的操作委托、状态和创建选项创建并启动任务。

参数

action

要异步执行的操作委托。

state

一个包含由 action 委托使用的数据的对象。

creationOptions

控制所创建的任务的行为的枚举值之一。

已启动的任务。

例外

action 为 null。

creationOptions 指定了一个无效的 TaskCreationOptions 值。

注解

调用 StartNew 在功能上等效于使用它的一个构造函数创建任务，然后调用 Start 以计划执行该任务。

适用于

.NET 6 和其他版本

StartNew(Action<Object>, Object, CancellationToken)

为指定的动作委托、状态和取消标记创建并启动任务。

参数

action

要异步执行的操作委托。

state

一个包含由 action 委托使用的数据的对象。

cancellationToken

将指派给新的任务的取消标记。

已启动的任务。

例外

已释放提供的 CancellationToken。

action 为 null。

示例

下面的示例定义了一个由6个字母构成的单词的数组。然后，每个单词都将传递给一个 Action<T> 委托，该委托会打乱该词并显示原始单词及其已打乱的版本。

C#复制

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

请注意，此示例初始化一个由锁保护的单个随机数生成器。对于锁的需要，请参阅类主题中的 "系统随机类和线程安全" Random 。若要处理随机数生成器损坏的可能性，请将取消标记传递给任务。如果两个随机数等于零，则该方法假定随机数生成器已损坏并设置取消标记。在对 chars 包含单词中的六个字符的数组进行排序之前，该方法会调用 CancellationToken.ThrowIfCancellationRequested 方法以 OperationCanceledException 在标记已取消的情况下引发。

注解

调用 StartNew 在功能上等效于使用它的一个构造函数创建任务，然后调用 Start 以计划执行该任务。

适用于

.NET 6 和其他版本

StartNew(Action, CancellationToken)

为指定的动作委派和取消标记创建并启动任务。

C#复制

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

参数

action

要异步执行的操作委托。

cancellationToken

将指派给新的任务的取消标记。

已启动的任务。

例外

已释放提供的 CancellationToken。

action 为 null。

示例

下面的示例调用 StartNew(Action, CancellationToken) 方法，以创建一个循环访问 C:\Windows\System32 目录中的文件的任务。 Lambda 表达式调用 Parallel.ForEach 方法，将有关每个文件的信息添加到 List<T> 对象。循环调用的每个分离的嵌套任务会 Parallel.ForEach 检查取消标记的状态，如果请求取消，则调用 CancellationToken.ThrowIfCancellationRequested 方法。 CancellationToken.ThrowIfCancellationRequested OperationCanceledException catch 当调用线程调用方法时，方法将引发在块中处理的异常 Task.Wait 。

C#复制

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

注解

调用 StartNew 在功能上等效于使用它的一个构造函数创建任务，然后调用 Start 来计划它的执行。

从 .NET Framework 4.5 开始，可以使用 Task.Run(Action, CancellationToken) 方法作为使用默认参数进行调用的快速方法 StartNew(Action, CancellationToken) 。但请注意，这两个方法之间的行为有不同之处： Task.Run(Action, CancellationToken) 默认情况下，不允许使用 TaskCreationOptions.AttachedToParent 附加到当前实例的选项启动子任务 Task ，而是 StartNew(Action, CancellationToken) 。有关详细信息和代码示例，请参阅与 .NET 并行编程中的 StartNew Vs 任务。

适用于

.NET 6 和其他版本

StartNew(Action, TaskCreationOptions)

为指定的操作委托和创建选项创建并启动任务。

C#复制

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

参数

action

要异步执行的操作委托。

creationOptions

控制所创建任务的行为的枚举值之一>

已启动的任务。

例外

action 为 null。

creationOptions 指定了一个无效的 TaskCreationOptions 值。

注解

调用 StartNew 在功能上等效于使用它的一个构造函数创建任务，然后调用 Start 以计划执行该任务。

适用于

.NET 6 和其他版本

StartNew(Action)

为指定的操作委托创建并启动任务。

C#复制

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

参数

action

要异步执行的操作委托。

已启动的任务。

例外

action 参数为 null。

示例

下面的示例使用 StartNew(Action) 方法来重复调用一个 Action 委托，该委托生成一个随机数，将其解释为 Unicode 码位，并将其转换为 UTF16 编码的代码单元，并显示有关生成的一个或多个字符的信息。

C#复制

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 += String.Format("0x{0} ", Convert.ToUInt16(ch));
      }   
      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)

注解

调用 StartNew 在功能上等效于使用它的一个构造函数创建任务，然后调用 Task.Start 方法来计划任务的执行。

从 .NET Framework 4.5 开始，可以使用 Task.Run(Action) 方法作为使用默认参数进行调用的快速方法 StartNew(Action) 。但请注意，这两个方法之间的行为有不同之处： Task.Run(Action) 默认情况下，不允许使用 TaskCreationOptions.AttachedToParent 附加到当前实例的选项启动子任务 Task ，而是 StartNew(Action) 。有关详细信息和代码示例，请参阅与 .NET 并行编程中的 StartNew Vs 任务。

适用于

.NET 6 和其他版本

StartNew(Action<Object>, Object)

为指定的操作委托和状态创建并启动任务。

参数

action

要异步执行的操作委托。

state

一个包含由 action 委托使用的数据的对象。

已启动的任务。

例外

action 参数为 null。

示例

C#复制

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

请注意，此示例初始化一个由锁保护的单个随机数生成器。对于锁的需要，请参阅类主题中的 "系统随机类和线程安全" Random 。

注解

调用 StartNew 在功能上等效于 Task 使用它的一个构造函数创建，然后调用 Start 方法来计划执行。

适用于

.NET 6 和其他版本

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

为指定的函数委托、取消标记、创建选项和任务计划程序创建并启动 TResult 类型的任务。

C#复制

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);

类型参数

TResult

可通过任务获得的结果的类型。

参数

function

一个函数委托，可返回能够通过任务获得的将来结果。

cancellationToken

将指派给新的任务的取消标记。

creationOptions

控制所创建的任务的行为的枚举值之一。

scheduler

用于计划所创建的任务的任务计划程序。

已启动的任务。

例外

已释放提供的 CancellationToken。

function 为 null。

或 scheduler 为 null。

creationOptions 指定了一个无效的 TaskCreationOptions 值。有关更多信息，请参见 FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions) 的备注

注解

调用 StartNew 在功能上等效于 Task<TResult> 使用它的一个构造函数创建，然后调用 Start 以计划执行。

从 .NET Framework 4.5 开始，可以将 Run 方法与对象结合使用， Action 作为使用默认参数调用的快速方法 StartNew 。有关详细信息和代码示例，请参阅入门任务。在与 .Net 的并行编程中运行 StartNew。

适用于

.NET 6 和其他版本

StartNew<TResult>(Func<TResult>)

为指定的函数委托创建并启动 TResult 类型的任务。

C#复制

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

类型参数

TResult

可通过任务获得的结果的类型。

参数

function

一个函数委托，可返回能够通过任务获得的将来结果。

已启动的任务。

例外

function 参数为 null。

示例

下面的示例是一个简单的加法应用，它会生成两个随机数并提示用户输入其总和。然后，它指示答案是否正确，或者如果用户的响应不是有效的数字，则会提示用户重新输入有效的数字。 StartNew用于创建 Task<TResult> 返回要添加的随机数的对象。

C#复制

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

注解

调用 StartNew 在功能上等效于 Task<TResult> 使用它的一个构造函数创建，然后调用 Start 以计划执行。

从 .NET Framework 4.5 开始，可以调用 Task.Run<TResult>(Func<TResult>) 方法，作为使用默认参数进行调用的快速方法 StartNew 。但请注意，这两个方法之间的行为有不同之处： Task.Run<TResult>(Func<TResult>) 默认情况下，不允许使用 TaskCreationOptions.AttachedToParent 附加到当前实例的选项启动子任务 Task<TResult> ，而是 StartNew<TResult>(Func<TResult>) 。有关详细信息和代码示例，请参阅入门任务。在与 .Net 的并行编程中运行 StartNew。

适用于

.NET 6 和其他版本

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

为指定的函数委托和状态创建并启动 TResult 类型的任务。

类型参数

TResult

可通过任务获得的结果的类型。

参数

function

Func<Object,TResult>

一个函数委托，可返回能够通过任务获得的将来结果。

state

一个包含由 function 委托使用的数据的对象。

已启动的任务。

例外

function 为 null。

注解

调用 StartNew 在功能上等效于 Task<TResult> 使用它的一个构造函数创建，然后调用 Start 以计划执行。

适用于

.NET 6 和其他版本

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

为指定的函数委托和取消标记创建并启动 TResult 类型的任务。

C#复制

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

类型参数

TResult

可通过任务获得的结果的类型。

参数

function

一个函数委托，可返回能够通过任务获得的将来结果。

cancellationToken

将指派给新的任务的取消标记。

已启动的任务。

例外

已释放提供的 CancellationToken。

function 为 null。

示例

下面的示例使用两个任务来计算以 F100 = F100 + F100-2 （种子值为 F1 = 1，F2 = 1，F1 = 0，F2 = 1）结尾的斐波那契序列。大约一半时间，将在操作执行时设置取消标记。如果两个任务成功完成且标记已取消，则示例的输出将显示结果。

C#复制

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.

注解

调用 StartNew 在功能上等效于 Task<TResult> 使用它的一个构造函数创建，然后调用 Start 以计划执行。

从 .NET Framework 4.5 开始，可以使用 Task.Run<TResult>(Func<TResult>, CancellationToken) 方法作为使用默认参数进行调用的快速方法 StartNew<TResult>(Func<TResult>, CancellationToken) 。但请注意，这两个方法之间的行为有不同之处： Task.Run<TResult>(Func<TResult>, CancellationToken) 默认情况下，不允许使用 TaskCreationOptions.AttachedToParent 附加到当前实例的选项启动子任务 Task<TResult> ，而是 StartNew<TResult>(Func<TResult>, CancellationToken) 。有关详细信息和代码示例，请参阅入门任务。在与 .Net 的并行编程中运行 StartNew。

适用于

.NET 6 和其他版本

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

为指定的函数委托和创建选项创建并启动 TResult 类型的任务。

C#复制

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

类型参数

TResult

可通过任务获得的结果的类型。

参数

function

一个函数委托，可返回能够通过任务获得的将来结果。

creationOptions

控制所创建的任务的行为的枚举值之一。

已启动的任务。

例外

function 为 null。

注解

调用 StartNew 在功能上等效于 Task<TResult> 使用它的一个构造函数创建，然后调用 Start 以计划执行。

适用于

.NET 6 和其他版本

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

为指定的函数委托、状态和取消标记创建并启动 TResult 类型的任务。

类型参数

TResult

可通过任务获得的结果的类型。

参数

function

Func<Object,TResult>

一个函数委托，可返回能够通过任务获得的将来结果。

state

一个包含由 function 委托使用的数据的对象。

cancellationToken

将指派给新的任务的取消标记。

已启动的任务。

例外

已释放提供的 CancellationToken。

function 为 null。

注解

调用 StartNew 在功能上等效于 Task<TResult> 使用它的一个构造函数创建，然后调用 Start 以计划执行。

适用于

.NET 6 和其他版本

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

为指定的函数委托、状态和创建选项创建并启动 TResult 类型的任务。

类型参数

TResult

可通过任务获得的结果的类型。

参数

function

Func<Object,TResult>

一个函数委托，可返回能够通过任务获得的将来结果。

state

一个包含由 function 委托使用的数据的对象。

creationOptions

控制所创建的任务的行为的枚举值之一。

已启动的任务。

例外

function 为 null。

注解

调用 StartNew 在功能上等效于 Task<TResult> 使用它的一个构造函数创建，然后调用 Start 以计划执行。

适用于

.NET 6 和其他版本

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

为指定的函数委托、状态、取消标记、创建选项和任务计划程序创建并启动 TResult 类型的任务。

类型参数

TResult

可通过任务获得的结果的类型。

参数

function

Func<Object,TResult>

一个函数委托，可返回能够通过任务获得的将来结果。

state

一个包含由 function 委托使用的数据的对象。

cancellationToken

将指派给新的任务的取消标记。

creationOptions

控制所创建的任务的行为的枚举值之一。

scheduler

用于计划所创建的任务的任务计划程序。

已启动的任务。

例外

已释放提供的 CancellationToken。

function 为 null。

或 scheduler 为 null。