TaskFactory.StartNew 方法

定义

创建并启动 任务。Creates and starts a task.

重载

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

为指定的操作委托、状态、取消令牌、创建选项和任务计划程序创建并启动任务。Creates and starts a task for the specified action delegate, state, cancellation token, creation options and task scheduler.

StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)

为指定的操作委托、取消令牌、创建选项和状态创建并启动任务。Creates and starts a task for the specified action delegate, cancellation token, creation options and state.

StartNew(Action<Object>, Object, TaskCreationOptions)

为指定的操作委托、状态和创建选项创建并启动任务。Creates and starts a task for the specified action delegate, state and creation options.

StartNew(Action<Object>, Object, CancellationToken)

为指定的动作委托、状态和取消标记创建并启动任务。Creates and starts a task for the specified action delegate, state and cancellation token.

StartNew(Action, CancellationToken)

为指定的动作委派和取消标记创建并启动任务。Creates and starts a task for the specified action delegate and cancellation token.

StartNew(Action, TaskCreationOptions)

为指定的操作委托和创建选项创建并启动任务。Creates and starts a task for the specified action delegate and creation options.

StartNew(Action)

为指定的操作委托创建并启动任务。Creates and starts a task for the specified action delegate.

StartNew(Action<Object>, Object)

为指定的操作委托和状态创建并启动任务。Creates and starts a task for the specified action delegate and state.

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

为指定的函数委托、取消标记、创建选项和任务计划程序创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate, cancellation token, creation options and task scheduler.

StartNew<TResult>(Func<TResult>)

为指定的函数委托创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate.

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

为指定的函数委托和状态创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate and state.

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

为指定的函数委托和取消标记创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate and cancellation token.

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

为指定的函数委托和创建选项创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate and creation options.

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

为指定的函数委托、状态和取消标记创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate, state and cancellation token.

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

为指定的函数委托、状态和创建选项创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate, state and creation options.

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

为指定的函数委托、状态、取消标记、创建选项和任务计划程序创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate, state, cancellation token, creation options and task scheduler.

注解

从开始 .NET Framework 4.5.NET Framework 4.5 ,建议使用 Task.Run 方法启动计算限制任务。Starting with the .NET Framework 4.5.NET Framework 4.5, the Task.Run method is the recommended way to launch a compute-bound task. StartNew仅当需要对长时间运行的、计算限制的任务进行精细控制时才使用此方法。Use the StartNew method only when you require fine-grained control for a long-running, compute-bound task. 这包括要控制以下各项的方案:This includes scenarios in which you want to control the following:

  • 任务创建选项。Task creation options. 默认情况下,由方法创建的任务 Task.Run 使用 TaskCreationOptions.DenyChildAttach 选项创建。Tasks created by the Task.Run method by default are created with the TaskCreationOptions.DenyChildAttach option. 若要重写此行为或提供其他 TaskCreationOptions 选项,请调用 StartNew 重载。To override this behavior, or to provide other TaskCreationOptions options, call a StartNew overload.

  • 参数通过。Parameter passing. 方法的重载 Task.Run 不允许将参数传递给任务委托。The overloads of the Task.Run method do not allow you to pass a parameter to the task delegate. 方法的重载 StartNew 执行。Overloads of the StartNew method do.

  • 任务计划程序。The task scheduler. 方法的重载 Task.Run 使用默认的任务计划程序。The overloads of the Task.Run method use the default task scheduler. 若要控制任务计划程序,请调用 StartNew 具有参数的重载 schedulerTo control the task scheduler, call a StartNew overload with a scheduler parameter. 有关详细信息,请参阅 TaskSchedulerFor more information, see TaskScheduler.

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

为指定的操作委托、状态、取消令牌、创建选项和任务计划程序创建并启动任务。Creates and starts a task for the specified action delegate, state, cancellation token, creation options and task scheduler.

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>

要异步执行的操作委托。The action delegate to execute asynchronously.

state
Object

一个包含由 action 委托使用的数据的对象。An object containing data to be used by the action delegate.

cancellationToken
CancellationToken

将指派给新的任务的取消标记。The cancellation token that will be assigned to the new task.

creationOptions
TaskCreationOptions

控制所创建的任务的行为的枚举值之一。One of the enumeration values that controls the behavior of the created task.

scheduler
TaskScheduler

用于计划所创建的任务的任务计划程序。The task scheduler that is used to schedule the created task.

返回

Task

已启动的任务。The started task.

例外

已释放提供的 CancellationTokenThe provided CancellationToken has already been disposed.

action 上声明的默认值为 nullaction is null.

-or-

scheduler 上声明的默认值为 nullscheduler is null.

creationOptions 参数指定了一个无效的 TaskCreationOptions 值。creationOptions argument specifies an invalid TaskCreationOptions value. 有关更多信息,请参见 FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions) 的备注For more information, see the Remarks for FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)

注解

调用 StartNew 在功能上等效于使用它的一个构造函数创建任务,然后调用 Start 以计划执行该任务。Calling StartNew is functionally equivalent to creating a Task using one of its constructors and then calling Start to schedule it for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,你可以将 Run 方法与对象结合使用, Action 作为 StartNew 使用默认参数调用的快速方法。Starting with the .NET Framework 4.5.NET Framework 4.5, you can use the Run method with an Action object as a quick way to call StartNew with default parameters. 有关详细信息和代码示例,请参阅与 .NET 并行编程中的 StartNew Vs 任务For more information and code examples, see Task.Run vs Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于

StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)

为指定的操作委托、取消令牌、创建选项和状态创建并启动任务。Creates and starts a task for the specified action delegate, cancellation token, creation options and state.

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

要异步执行的操作委托。The action delegate to execute asynchronously.

cancellationToken
CancellationToken

将指派给新的任务的取消标记。The cancellation token that will be assigned to the new task.

creationOptions
TaskCreationOptions

控制所创建的任务的行为的枚举值之一。One of the enumeration values that controls the behavior of the created task.

scheduler
TaskScheduler

用于计划所创建的任务的任务计划程序。The task scheduler that is used to schedule the created task.

返回

Task

已启动的任务。The started task.

例外

已释放提供的 CancellationTokenThe provided CancellationToken has already been disposed.

action 上声明的默认值为 nullaction is null.

-or- scheduler 上声明的默认值为 nullscheduler is null.

creationOptions 指定了无效的 TaskCreationOptions 值。creationOptions specifies an invalid TaskCreationOptions value. 有关更多信息,请参见 FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions) 的备注For more information, see the Remarks for FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)

注解

调用 StartNew 在功能上等效于使用它的一个构造函数创建任务,然后调用 Start 以计划执行该任务。Calling StartNew is functionally equivalent to creating a Task using one of its constructors and then calling Start to schedule it for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,你可以将 Run 方法与对象结合使用, Action 作为 StartNew 使用默认参数调用的快速方法。Starting with the .NET Framework 4.5.NET Framework 4.5, you can use the Run method with an Action object as a quick way to call StartNew with default parameters. 有关详细信息和代码示例,请参阅与 .NET 并行编程中的 StartNew Vs 任务For more information and code examples, see Task.Run vs Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于

StartNew(Action<Object>, Object, TaskCreationOptions)

为指定的操作委托、状态和创建选项创建并启动任务。Creates and starts a task for the specified action delegate, state and creation options.

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>

要异步执行的操作委托。The action delegate to execute asynchronously.

state
Object

一个包含由 action 委托使用的数据的对象。An object containing data to be used by the action delegate.

creationOptions
TaskCreationOptions

控制所创建的任务的行为的枚举值之一。One of the enumeration values that controls the behavior of the created task.

返回

Task

已启动的任务。The started task.

例外

action 上声明的默认值为 nullaction is null.

creationOptions 指定了一个无效的 TaskCreationOptions 值。creationOptions specifies an invalid TaskCreationOptions value.

注解

调用 StartNew 在功能上等效于使用它的一个构造函数创建任务,然后调用 Start 以计划执行该任务。Calling StartNew is functionally equivalent to creating a Task using one of its constructors and then calling Start to schedule it for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,你可以将 Run 方法与对象结合使用, Action 作为 StartNew 使用默认参数调用的快速方法。Starting with the .NET Framework 4.5.NET Framework 4.5, you can use the Run method with an Action object as a quick way to call StartNew with default parameters. 有关详细信息和代码示例,请参阅与 .NET 并行编程中的 StartNew Vs 任务For more information and code examples, see Task.Run vs Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于

StartNew(Action<Object>, Object, CancellationToken)

为指定的动作委托、状态和取消标记创建并启动任务。Creates and starts a task for the specified action delegate, state and cancellation token.

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>

要异步执行的操作委托。The action delegate to execute asynchronously.

state
Object

一个包含由 action 委托使用的数据的对象。An object containing data to be used by the action delegate.

cancellationToken
CancellationToken

将指派给新的任务的取消标记。The cancellation token that will be assigned to the new task.

返回

Task

已启动的任务。The started task.

例外

已释放提供的 CancellationTokenThe provided CancellationToken has already been disposed.

action 上声明的默认值为 nullaction is null.

示例

下面的示例定义了一个由6个字母构成的单词的数组。The following example defines an array of 6-letter words. 然后,每个单词都将传递给一个 Action<T> 委托,该委托会打乱该词并显示原始单词及其已打乱的版本。Each word is then passed to an Action<T> delegate, which scrambles the word and displays the original word and its scrambled version.

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

请注意,此示例初始化一个由锁保护的单个随机数生成器。Note that the example initializes a single random number generator, which is protected by a lock. 对于锁的需要,请参阅类主题中的 "系统随机类和线程安全" RandomFor the need of a lock, see "The System.Random class and thread safety" in the Random class topic. 若要处理随机数生成器损坏的可能性,请将取消标记传递给任务。To handle the possibility of corruption of the random number generator, a cancellation token is passed to task. 如果两个随机数等于零,则该方法假定随机数生成器已损坏并设置取消标记。If two random numbers equal zero, the method assumes that the random number generator is corrupted and sets the cancellation token. 在对 chars 包含单词中的六个字符的数组进行排序之前,该方法会调用 CancellationToken.ThrowIfCancellationRequested 方法以 OperationCanceledException 在标记已取消的情况下引发。Before sorting the chars array that contains the six characters in a word, the method calls the CancellationToken.ThrowIfCancellationRequested method to throw an OperationCanceledException if the token has been canceled.

注解

调用 StartNew 在功能上等效于使用它的一个构造函数创建任务,然后调用 Start 以计划执行该任务。Calling StartNew is functionally equivalent to creating a Task using one of its constructors and then calling Start to schedule it for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,你可以将 Run 方法与对象结合使用, Action 作为 StartNew 使用默认参数调用的快速方法。Starting with the .NET Framework 4.5.NET Framework 4.5, you can use the Run method with an Action object as a quick way to call StartNew with default parameters. 有关详细信息和代码示例,请参阅与 .NET 并行编程中的 StartNew Vs 任务For more information and code examples, see Task.Run vs Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于

StartNew(Action, CancellationToken)

为指定的动作委派和取消标记创建并启动任务。Creates and starts a task for the specified action delegate and cancellation token.

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

要异步执行的操作委托。The action delegate to execute asynchronously.

cancellationToken
CancellationToken

将指派给新的任务的取消标记。The cancellation token that will be assigned to the new task.

返回

Task

已启动的任务。The started task.

例外

已释放提供的 CancellationTokenThe provided CancellationToken has already been disposed.

action 上声明的默认值为 nullaction is null.

示例

下面的示例调用 StartNew(Action, CancellationToken) 方法,以创建一个循环访问 C:\Windows\System32 目录中的文件的任务。The following example calls the StartNew(Action, CancellationToken) method to create a task that iterates the files in the C:\Windows\System32 directory. Lambda 表达式调用 Parallel.ForEach 方法,将有关每个文件的信息添加到 List<T> 对象。The lambda expression calls the Parallel.ForEach method to add information about each file to a List<T> object. 循环调用的每个分离的嵌套任务会 Parallel.ForEach 检查取消标记的状态,如果请求取消,则调用 CancellationToken.ThrowIfCancellationRequested 方法。Each detached nested task invoked by the Parallel.ForEach loop checks the state of the cancellation token and, if cancellation is requested, calls the CancellationToken.ThrowIfCancellationRequested method. CancellationToken.ThrowIfCancellationRequested OperationCanceledException catch 当调用线程调用方法时,方法将引发在块中处理的异常 Task.WaitThe CancellationToken.ThrowIfCancellationRequested method throws an OperationCanceledException exception that is handled in a catch block when the calling thread calls the Task.Wait method.

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 在功能上等效于使用它的一个构造函数创建任务,然后调用 Start 来计划它的执行。Calling StartNew is functionally equivalent to creating a Task using one of its constructors and then calling Start to schedule it for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,可以使用 Task.Run(Action, CancellationToken) 方法作为使用默认参数进行调用的快速方法 StartNew(Action, CancellationToken)Starting with the .NET Framework 4.5.NET Framework 4.5, you can use the Task.Run(Action, CancellationToken) method as a quick way to call StartNew(Action, CancellationToken) with default parameters. 但请注意,这两个方法之间的行为有不同之处: Task.Run(Action, CancellationToken) 默认情况下,不允许使用 TaskCreationOptions.AttachedToParent 附加到当前实例的选项启动子任务 Task ,而是 StartNew(Action, CancellationToken)Note, however, that there is a difference in behavior between the two methods regarding : Task.Run(Action, CancellationToken) by default does not allow child tasks started with the TaskCreationOptions.AttachedToParent option to attach to the current Task instance, whereas StartNew(Action, CancellationToken) does. 有关详细信息和代码示例,请参阅与 .NET 并行编程中的 StartNew Vs 任务For more information and code examples, see Task.Run vs Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于

StartNew(Action, TaskCreationOptions)

为指定的操作委托和创建选项创建并启动任务。Creates and starts a task for the specified action delegate and creation options.

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

要异步执行的操作委托。The action delegate to execute asynchronously.

creationOptions
TaskCreationOptions

控制所创建任务的行为的枚举值之一>One of the enumeration values that controls the behavior of the created task>

返回

Task

已启动的任务。The started task.

例外

action 上声明的默认值为 nullaction is null.

creationOptions 指定了一个无效的 TaskCreationOptions 值。creationOptions specifies an invalid TaskCreationOptions value.

注解

调用 StartNew 在功能上等效于使用它的一个构造函数创建任务,然后调用 Start 以计划执行该任务。Calling StartNew is functionally equivalent to creating a Task using one of its constructors and then calling Start to schedule it for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,你可以将 Run 方法与对象结合使用, Action 作为 StartNew 使用默认参数调用的快速方法。Starting with the .NET Framework 4.5.NET Framework 4.5, you can use the Run method with an Action object as a quick way to call StartNew with default parameters. 有关详细信息和代码示例,请参阅与 .NET 并行编程中的 StartNew Vs 任务For more information and code examples, see Task.Run vs Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于

StartNew(Action)

为指定的操作委托创建并启动任务。Creates and starts a task for the specified action delegate.

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

要异步执行的操作委托。The action delegate to execute asynchronously.

返回

Task

已启动的任务。The started task.

例外

action 参数为 nullThe action argument is null.

示例

下面的示例使用 StartNew(Action) 方法来重复调用一个 Action 委托,该委托生成一个随机数,将其解释为 Unicode 码位,并将其转换为 UTF16 编码的代码单元,并显示有关生成的一个或多个字符的信息。The following example uses the StartNew(Action) method to repeatedly invoke an Action delegate that generates a random number, interprets it as a Unicode code point, converts it to a UTF16-encoded code unit, and displays information about the resulting character or characters.

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)
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 方法来计划任务的执行。Calling StartNew is functionally equivalent to creating a task by using one of its constructors, and then calling the Task.Start method to schedule the task for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,可以使用 Task.Run(Action) 方法作为使用默认参数进行调用的快速方法 StartNew(Action)Starting with the .NET Framework 4.5.NET Framework 4.5, you can use the Task.Run(Action) method as a quick way to call StartNew(Action) with default parameters. 但请注意,这两个方法之间的行为有不同之处: Task.Run(Action) 默认情况下,不允许使用 TaskCreationOptions.AttachedToParent 附加到当前实例的选项启动子任务 Task ,而是 StartNew(Action)Note, however, that there is a difference in behavior between the two methods regarding : Task.Run(Action) by default does not allow child tasks started with the TaskCreationOptions.AttachedToParent option to attach to the current Task instance, whereas StartNew(Action) does. 有关详细信息和代码示例,请参阅与 .NET 并行编程中的 StartNew Vs 任务For more information and code examples, see Task.Run vs Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于

StartNew(Action<Object>, Object)

为指定的操作委托和状态创建并启动任务。Creates and starts a task for the specified action delegate and state.

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>

要异步执行的操作委托。The action delegate to execute asynchronously.

state
Object

一个包含由 action 委托使用的数据的对象。An object containing data to be used by the action delegate.

返回

Task

已启动的任务。The started task.

例外

action 参数为 nullThe action argument is null.

示例

下面的示例定义了一个由6个字母构成的单词的数组。The following example defines an array of 6-letter words. 然后,每个单词都将传递给一个 Action<T> 委托,该委托会打乱该词并显示原始单词及其已打乱的版本。Each word is then passed to an Action<T> delegate, which scrambles the word and displays the original word and its scrambled version.

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

请注意,此示例初始化一个由锁保护的单个随机数生成器。Note that the example initializes a single random number generator, which is protected by a lock. 对于锁的需要,请参阅类主题中的 "系统随机类和线程安全" RandomFor the need of a lock, see "The System.Random class and thread safety" in the Random class topic.

注解

调用 StartNew 在功能上等效于 Task 使用它的一个构造函数创建,然后调用 Start 方法来计划执行。Calling StartNew is functionally equivalent to creating a Task using one of its constructors and then calling the Start method to schedule it for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,你可以将 Run 方法与对象结合使用, Action 作为 StartNew 使用默认参数调用的快速方法。Starting with the .NET Framework 4.5.NET Framework 4.5, you can use the Run method with an Action object as a quick way to call StartNew with default parameters. 有关详细信息和代码示例,请参阅与 .NET 并行编程中的 StartNew Vs 任务For more information and code examples, see Task.Run vs Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于

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

为指定的函数委托、取消标记、创建选项和任务计划程序创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate, cancellation token, creation options and task scheduler.

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

可通过任务获得的结果的类型。The type of the result available through the task.

参数

function
Func<TResult>

一个函数委托,可返回能够通过任务获得的将来结果。A function delegate that returns the future result to be available through the task.

cancellationToken
CancellationToken

将指派给新的任务的取消标记。The cancellation token that will be assigned to the new task.

creationOptions
TaskCreationOptions

控制所创建的任务的行为的枚举值之一。One of the enumeration values that controls the behavior of the created task.

scheduler
TaskScheduler

用于计划所创建的任务的任务计划程序。The task scheduler that is used to schedule the created task.

返回

Task<TResult>

已启动的任务。The started task.

例外

已释放提供的 CancellationTokenThe provided CancellationToken has already been disposed.

function 上声明的默认值为 nullfunction is null.

-or- scheduler 上声明的默认值为 nullscheduler is null.

creationOptions 指定了一个无效的 TaskCreationOptions 值。creationOptions specifies an invalid TaskCreationOptions value. 有关更多信息,请参见 FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions) 的备注For more information, see the Remarks for FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)

注解

调用 StartNew 在功能上等效于 Task<TResult> 使用它的一个构造函数创建,然后调用 Start 以计划执行。Calling StartNew is functionally equivalent to creating a Task<TResult> using one of its constructors and then calling Start to schedule it for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,你可以将 Run 方法与对象结合使用, Action 作为 StartNew 使用默认参数调用的快速方法。Starting with the .NET Framework 4.5.NET Framework 4.5, you can use the Run method with an Action object as a quick way to call StartNew with default parameters. 有关详细信息和代码示例,请参阅入门 任务。 在与 .Net 的并行编程中运行 StartNew。For more information and code examples, see the entry Task.Run vs. Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于

StartNew<TResult>(Func<TResult>)

为指定的函数委托创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate.

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

可通过任务获得的结果的类型。The type of the result available through the task.

参数

function
Func<TResult>

一个函数委托,可返回能够通过任务获得的将来结果。A function delegate that returns the future result to be available through the task.

返回

Task<TResult>

已启动的任务。The started task.

例外

function 参数为 nullThe function argument is null.

示例

下面的示例是一个简单的加法应用,它会生成两个随机数并提示用户输入其总和。The following example is a simple addition app that generates two random numbers and prompts the user to enter their sum. 然后,它指示答案是否正确,或者如果用户的响应不是有效的数字,则会提示用户重新输入有效的数字。It then indicates whether the answer is correct or, if the user's response is not a valid number, prompts the user to re-enter a valid number. StartNew用于创建 Task<TResult> 返回要添加的随机数的对象。The StartNew is used to create the Task<TResult> objects that return the random numbers to add.

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 以计划执行。Calling StartNew is functionally equivalent to creating a Task<TResult> using one of its constructors and then calling Start to schedule it for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,你可以调用方法, Task.Run<TResult>(Func<TResult>) 作为使用默认参数进行调用的快速方法 StartNewStarting with the .NET Framework 4.5.NET Framework 4.5, you can call the Task.Run<TResult>(Func<TResult>) method as a quick way to call StartNew with default parameters. 但请注意,这两个方法之间的行为有不同之处: Task.Run<TResult>(Func<TResult>) 默认情况下,不允许使用 TaskCreationOptions.AttachedToParent 附加到当前实例的选项启动子任务 Task<TResult> ,而是 StartNew<TResult>(Func<TResult>)Note, however, that there is a difference in behavior between the two methods regarding : Task.Run<TResult>(Func<TResult>) by default does not allow child tasks started with the TaskCreationOptions.AttachedToParent option to attach to the current Task<TResult> instance, whereas StartNew<TResult>(Func<TResult>) does. 有关详细信息和代码示例,请参阅入门 任务。 在与 .Net 的并行编程中运行 StartNew。For more information and code examples, see the entry Task.Run vs. Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于

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

为指定的函数委托和状态创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate and state.

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

可通过任务获得的结果的类型。The type of the result available through the task.

参数

function
Func<Object,TResult>

一个函数委托,可返回能够通过任务获得的将来结果。A function delegate that returns the future result to be available through the task.

state
Object

一个包含由 function 委托使用的数据的对象。An object containing data to be used by the function delegate.

返回

Task<TResult>

已启动的任务。The started task.

例外

function 上声明的默认值为 nullfunction is null.

注解

调用 StartNew 在功能上等效于 Task<TResult> 使用它的一个构造函数创建,然后调用 Start 以计划执行。Calling StartNew is functionally equivalent to creating a Task<TResult> using one of its constructors and then calling Start to schedule it for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,你可以将 Run 方法与对象结合使用, Action 作为 StartNew 使用默认参数调用的快速方法。Starting with the .NET Framework 4.5.NET Framework 4.5, you can use the Run method with an Action object as a quick way to call StartNew with default parameters. 有关详细信息和代码示例,请参阅入门 任务。 在与 .Net 的并行编程中运行 StartNew。For more information and code examples, see the entry Task.Run vs. Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于

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

为指定的函数委托和取消标记创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate and cancellation token.

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

可通过任务获得的结果的类型。The type of the result available through the task.

参数

function
Func<TResult>

一个函数委托,可返回能够通过任务获得的将来结果。A function delegate that returns the future result to be available through the task.

cancellationToken
CancellationToken

将指派给新的任务的取消标记。The cancellation token that will be assigned to the new task.

返回

Task<TResult>

已启动的任务。The started task.

例外

已释放提供的 CancellationTokenThe provided CancellationToken has already been disposed.

function 上声明的默认值为 nullfunction is null.

示例

下面的示例使用两个任务来计算以 F100 = F100 + F100-2 (种子值为 F1 = 1,F2 = 1,F1 = 0,F2 = 1)结尾的斐波那契序列。The following example uses two tasks to compute the Fibonacci sequence ending in F100 = F100-1 + F100-2 with seed values F1= 1, F2 = 1 and F1 = 0, F2= 1. 大约一半时间,将在操作执行时设置取消标记。Approximately half of the time, a cancellation token is set as the operations execute. 如果两个任务成功完成且标记已取消,则示例的输出将显示结果。The output from the example shows the result if the two tasks complete successfully and if the token is cancelled.

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 以计划执行。Calling StartNew is functionally equivalent to creating a Task<TResult> using one of its constructors and then calling Start to schedule it for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,可以使用 Task.Run<TResult>(Func<TResult>, CancellationToken) 方法作为使用默认参数进行调用的快速方法 StartNew<TResult>(Func<TResult>, CancellationToken)Starting with the .NET Framework 4.5.NET Framework 4.5, you can use the Task.Run<TResult>(Func<TResult>, CancellationToken) method as a quick way to call StartNew<TResult>(Func<TResult>, CancellationToken) with default parameters. 但请注意,这两个方法之间的行为有不同之处: Task.Run<TResult>(Func<TResult>, CancellationToken) 默认情况下,不允许使用 TaskCreationOptions.AttachedToParent 附加到当前实例的选项启动子任务 Task<TResult> ,而是 StartNew<TResult>(Func<TResult>, CancellationToken)Note, however, that there is a difference in behavior between the two methods regarding : Task.Run<TResult>(Func<TResult>, CancellationToken) by default does not allow child tasks started with the TaskCreationOptions.AttachedToParent option to attach to the current Task<TResult> instance, whereas StartNew<TResult>(Func<TResult>, CancellationToken) does. 有关详细信息和代码示例,请参阅入门 任务。 在与 .Net 的并行编程中运行 StartNew。For more information and code examples, see the entry Task.Run vs. Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于

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

为指定的函数委托和创建选项创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate and creation options.

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

可通过任务获得的结果的类型。The type of the result available through the task.

参数

function
Func<TResult>

一个函数委托,可返回能够通过任务获得的将来结果。A function delegate that returns the future result to be available through the task.

creationOptions
TaskCreationOptions

控制所创建的任务的行为的枚举值之一。One of the enumeration values that controls the behavior of the created task.

返回

Task<TResult>

已启动的任务。The started task.

例外

function 上声明的默认值为 nullfunction is null.

creationOptions 指定了一个无效的 TaskCreationOptions 值。creationOptions specifies an invalid TaskCreationOptions value. 有关更多信息,请参见 FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions) 的备注For more information, see the Remarks for FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)

注解

调用 StartNew 在功能上等效于 Task<TResult> 使用它的一个构造函数创建,然后调用 Start 以计划执行。Calling StartNew is functionally equivalent to creating a Task<TResult> using one of its constructors and then calling Start to schedule it for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,你可以将 Run 方法与对象结合使用, Action 作为 StartNew 使用默认参数调用的快速方法。Starting with the .NET Framework 4.5.NET Framework 4.5, you can use the Run method with an Action object as a quick way to call StartNew with default parameters. 有关详细信息和代码示例,请参阅入门 任务。 在与 .Net 的并行编程中运行 StartNew。For more information and code examples, see the entry Task.Run vs. Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于

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

为指定的函数委托、状态和取消标记创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate, state and cancellation token.

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

可通过任务获得的结果的类型。The type of the result available through the task.

参数

function
Func<Object,TResult>

一个函数委托,可返回能够通过任务获得的将来结果。A function delegate that returns the future result to be available through the task.

state
Object

一个包含由 function 委托使用的数据的对象。An object containing data to be used by the function delegate.

cancellationToken
CancellationToken

将指派给新的任务的取消标记。The cancellation token that will be assigned to the new task.

返回

Task<TResult>

已启动的任务。The started task.

例外

已释放提供的 CancellationTokenThe provided CancellationToken has already been disposed.

function 上声明的默认值为 nullfunction is null.

注解

调用 StartNew 在功能上等效于 Task<TResult> 使用它的一个构造函数创建,然后调用 Start 以计划执行。Calling StartNew is functionally equivalent to creating a Task<TResult> using one of its constructors and then calling Start to schedule it for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,你可以将 Run 方法与对象结合使用, Action 作为 StartNew 使用默认参数调用的快速方法。Starting with the .NET Framework 4.5.NET Framework 4.5, you can use the Run method with an Action object as a quick way to call StartNew with default parameters. 有关详细信息和代码示例,请参阅入门 任务。 在与 .Net 的并行编程中运行 StartNew。For more information and code examples, see the entry Task.Run vs. Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于

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

为指定的函数委托、状态和创建选项创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate, state and creation options.

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

可通过任务获得的结果的类型。The type of the result available through the task.

参数

function
Func<Object,TResult>

一个函数委托,可返回能够通过任务获得的将来结果。A function delegate that returns the future result to be available through the task.

state
Object

一个包含由 function 委托使用的数据的对象。An object containing data to be used by the function delegate.

creationOptions
TaskCreationOptions

控制所创建的任务的行为的枚举值之一。One of the enumeration values that controls the behavior of the created task.

返回

Task<TResult>

已启动的任务。The started task.

例外

function 上声明的默认值为 nullfunction is null.

creationOptions 指定了一个无效的 TaskCreationOptions 值。creationOptions specifies an invalid TaskCreationOptions value. 有关更多信息,请参见 FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions) 的备注For more information, see the Remarks for FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)

注解

调用 StartNew 在功能上等效于 Task<TResult> 使用它的一个构造函数创建,然后调用 Start 以计划执行。Calling StartNew is functionally equivalent to creating a Task<TResult> using one of its constructors and then calling Start to schedule it for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,你可以将 Run 方法与对象结合使用, Action 作为 StartNew 使用默认参数调用的快速方法。Starting with the .NET Framework 4.5.NET Framework 4.5, you can use the Run method with an Action object as a quick way to call StartNew with default parameters. 有关详细信息和代码示例,请参阅入门 任务。 在与 .Net 的并行编程中运行 StartNew。For more information and code examples, see the entry Task.Run vs. Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于

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

为指定的函数委托、状态、取消标记、创建选项和任务计划程序创建并启动 TResult 类型的任务。Creates and starts a task of type TResult for the specified function delegate, state, cancellation token, creation options and task scheduler.

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)

类型参数

TResult

可通过任务获得的结果的类型。The type of the result available through the task.

参数

function
Func<Object,TResult>

一个函数委托,可返回能够通过任务获得的将来结果。A function delegate that returns the future result to be available through the task.

state
Object

一个包含由 function 委托使用的数据的对象。An object containing data to be used by the function delegate.

cancellationToken
CancellationToken

将指派给新的任务的取消标记。The cancellation token that will be assigned to the new task.

creationOptions
TaskCreationOptions

控制所创建的任务的行为的枚举值之一。One of the enumeration values that controls the behavior of the created task.

scheduler
TaskScheduler

用于计划所创建的任务的任务计划程序。The task scheduler that is used to schedule the created task.

返回

Task<TResult>

已启动的任务。The started task.

例外

已释放提供的 CancellationTokenThe provided CancellationToken has already been disposed.

function 上声明的默认值为 nullfunction is null.

-or- scheduler 上声明的默认值为 nullscheduler is null.

creationOptions 指定了一个无效的 TaskCreationOptions 值。creationOptions specifies an invalid TaskCreationOptions value. 有关更多信息,请参见 FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions) 的备注For more information, see the Remarks for FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)

注解

调用 StartNew 在功能上等效于 Task<TResult> 使用它的一个构造函数创建,然后调用 Start 以计划执行。Calling StartNew is functionally equivalent to creating a Task<TResult> using one of its constructors and then calling Start to schedule it for execution.

从开始 .NET Framework 4.5.NET Framework 4.5 ,你可以将 Run 方法与对象结合使用, Action 作为 StartNew 使用默认参数调用的快速方法。Starting with the .NET Framework 4.5.NET Framework 4.5, you can use the Run method with an Action object as a quick way to call StartNew with default parameters. 有关详细信息和代码示例,请参阅入门 任务。 在与 .Net 的并行编程中运行 StartNew。For more information and code examples, see the entry Task.Run vs. Task.Factory.StartNew in the Parallel Programming with .NET blog.

另请参阅

适用于