Task 构造函数

参考

定义

命名空间:: System.Threading.Tasks

程序集:: System.Threading.Tasks.dll

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

初始化新的 Task。

重载

Task(Action)	使用指定的操作初始化新的 Task。
Task(Action, CancellationToken)	使用指定的操作和 Task 初始化新的 CancellationToken。
Task(Action, TaskCreationOptions)	使用指定的操作和创建选项初始化新的 Task。
Task(Action<Object>, Object)	使用指定的操作和状态初始化新的 Task。
Task(Action, CancellationToken, TaskCreationOptions)	使用指定的操作和创建选项初始化新的 Task。
Task(Action<Object>, Object, CancellationToken)	使用指定的操作、状态和 CancellationToken初始化新的 Task 。
Task(Action<Object>, Object, TaskCreationOptions)	使用指定的操作、状态和选项初始化新的 Task。
Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)	使用指定的操作、状态和选项初始化新的 Task。

Task(Action)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

使用指定的操作初始化新的 Task。

public:
 Task(Action ^ action);

public Task (Action action);

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

Public Sub New (action As Action)

参数

action: Action

表示要在任务中执行的代码的委托。

例外

ArgumentNullException

action 参数为 null。

示例

以下示例使用 Task(Action) 构造函数创建检索指定目录中文件名的任务。所有任务都会将文件名写入单个 ConcurrentBag<T> 对象。然后，该示例调用 WaitAll(Task[]) 方法以确保所有任务都已完成，然后显示写入 ConcurrentBag<T> 对象的文件名总数的计数。

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

public class Example
{
   public static async Task Main()
   {
      var list = new ConcurrentBag<string>();
      string[] dirNames = { ".", ".." };
      List<Task> tasks = new List<Task>();
      foreach (var dirName in dirNames) {
         Task t = new Task( () => { foreach(var path in Directory.GetFiles(dirName))
                                    list.Add(path); }  );
         tasks.Add(t);
         t.Start();
      }
      await Task.WhenAll(tasks.ToArray());
      foreach (Task t in tasks)
         Console.WriteLine("Task {0} Status: {1}", t.Id, t.Status);
         
      Console.WriteLine("Number of files read: {0}", list.Count);
   }
}
// The example displays output like the following:
//       Task 1 Status: RanToCompletion
//       Task 2 Status: RanToCompletion
//       Number of files read: 23

open System.Collections.Concurrent
open System.IO
open System.Threading.Tasks

let main =
    task {
        let list = ConcurrentBag<string>()
        let dirNames = [ "."; ".." ]
        let tasks = ResizeArray()

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

            tasks.Add t
            t.Start()

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

        for t in tasks do
            printfn $"Task {t.Id} Status: {t.Status}"

        printfn $"Number of files read: {list.Count}"
    }

// The example displays output like the following:
//       Task 1 Status: RanToCompletion
//       Task 2 Status: RanToCompletion
//       Number of files read: 23

Imports System.Collections.Concurrent
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim list As New ConcurrentBag(Of String)()
      Dim dirNames() As String = { ".", ".." }
      Dim tasks As New List(Of Task)()
      For Each dirName In dirNames 
         Dim t As New Task( Sub()
                               For Each path In Directory.GetFiles(dirName)
                                  list.Add(path)
                               Next
                            End Sub  )
         tasks.Add(t)
         t.Start()
      Next
      Task.WaitAll(tasks.ToArray())
      For Each t In tasks
         Console.WriteLine("Task {0} Status: {1}", t.Id, t.Status)
      Next   
      Console.WriteLine("Number of files read: {0}", list.Count)
   End Sub
End Module
' The example displays output like the following:
'       Task 1 Status: RanToCompletion
'       Task 2 Status: RanToCompletion
'       Number of files read: 23

以下示例是相同的，只不过它使用 Run(Action) 方法在单个操作中实例化和运行任务。方法返回 Task 表示任务的对象。

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

public class Example
{
   public static void Main()
   {
      var list = new ConcurrentBag<string>();
      string[] dirNames = { ".", ".." };
      List<Task> tasks = new List<Task>();
      foreach (var dirName in dirNames) {
         Task t = Task.Run( () => { foreach(var path in Directory.GetFiles(dirName)) 
                                       list.Add(path); }  );
         tasks.Add(t);
      }
      Task.WaitAll(tasks.ToArray());
      foreach (Task t in tasks)
         Console.WriteLine("Task {0} Status: {1}", t.Id, t.Status);
         
      Console.WriteLine("Number of files read: {0}", list.Count);
   }
}
// The example displays output like the following:
//       Task 1 Status: RanToCompletion
//       Task 2 Status: RanToCompletion
//       Number of files read: 23

open System.Collections.Concurrent
open System.IO
open System.Threading.Tasks

let list = ConcurrentBag<string>()
let dirNames = [ "."; ".." ]
let tasks = ResizeArray()

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

    tasks.Add t

tasks.ToArray() |> Task.WaitAll

for t in tasks do
    printfn $"Task {t.Id} Status: {t.Status}"

printfn $"Number of files read: {list.Count}"

// The example displays output like the following:
//       Task 1 Status: RanToCompletion
//       Task 2 Status: RanToCompletion
//       Number of files read: 23

Imports System.Collections.Concurrent
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim list As New ConcurrentBag(Of String)()
      Dim dirNames() As String = { ".", ".." }
      Dim tasks As New List(Of Task)()
      For Each dirName In dirNames 
         Dim t As Task = Task.Run( Sub()
                                      For Each path In Directory.GetFiles(dirName) 
                                         list.Add(path)
                                      Next
                                   End Sub  )
         tasks.Add(t)
      Next
      Task.WaitAll(tasks.ToArray())
      For Each t In tasks
         Console.WriteLine("Task {0} Status: {1}", t.Id, t.Status)
      Next   
      Console.WriteLine("Number of files read: {0}", list.Count)
   End Sub
End Module
' The example displays output like the following:
'       Task 1 Status: RanToCompletion
'       Task 2 Status: RanToCompletion
'       Number of files read: 23

注解

此构造函数仅应用于需要分离任务创建和启动的高级方案。

实例化 Task 对象并启动任务的最常见方法是调用静态 Task.Run(Action) 或 TaskFactory.StartNew(Action) 方法，而不是调用此构造函数。

如果 API 使用者需要执行没有操作的任务才能等待某些内容， TaskCompletionSource<TResult> 则应使用。

另请参阅

Run(Action)

适用于

Task(Action, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

使用指定的操作和 Task 初始化新的 CancellationToken。

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

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

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

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

参数

action: Action

表示要在任务中执行的代码的委托。

cancellationToken: CancellationToken

新任务将观察的 CancellationToken。

例外

ObjectDisposedException

已释放提供的 CancellationToken。

ArgumentNullException

action 参数为 null。

示例

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

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

public class Example
{
   public static async Task Main()
   {
      var tokenSource = new CancellationTokenSource();
      var token = tokenSource.Token;
      var files = new List<Tuple<string, string, long, DateTime>>();
      
      var t = new Task(() => { string dir = "C:\\Windows\\System32\\";
                               object obj = new Object();
                               if (Directory.Exists(dir)) {
                                  Parallel.ForEach(Directory.GetFiles(dir),
                                  f => {
                                          if (token.IsCancellationRequested)
                                             token.ThrowIfCancellationRequested();
                                          var fi = new FileInfo(f);
                                          lock(obj) {
                                             files.Add(Tuple.Create(fi.Name, fi.DirectoryName, fi.Length, fi.LastWriteTimeUtc));          
                                          }
                                     });
                                }
                              } , token);
      t.Start();
      tokenSource.Cancel();
      try {
         await t; 
         Console.WriteLine("Retrieved information for {0} files.", files.Count);
      }
      catch (AggregateException e) {
         Console.WriteLine("Exception messages:");
         foreach (var ie in e.InnerExceptions)
            Console.WriteLine("   {0}: {1}", ie.GetType().Name, ie.Message);

         Console.WriteLine("\nTask status: {0}", t.Status);       
      }
      finally {
         tokenSource.Dispose();
      }
   }
}
// The example displays the following output:
//       Exception messages:
//          TaskCanceledException: A task was canceled.
//       
//       Task status: Canceled

open System
open System.IO
open System.Threading
open System.Threading.Tasks

let main =
    task {
        use tokenSource = new CancellationTokenSource()
        let token = tokenSource.Token
        let files = ResizeArray()

        let t =
            new Task(
                (fun () ->
                    let dir = @"C:\Windows\System32\"
                    let obj = obj ()

                    if Directory.Exists dir then
                        Parallel.ForEach(
                            Directory.GetFiles dir,
                            fun f ->
                                if token.IsCancellationRequested then
                                    token.ThrowIfCancellationRequested()

                                let fi = FileInfo f
                                lock obj (fun () -> files.Add(fi.Name, fi.DirectoryName, fi.Length, fi.LastWriteTimeUtc))
                        )
                        |> ignore),
                token
            )

        t.Start()
        tokenSource.Cancel()

        try
            do! t
            printfn $"Retrieved information for {files.Count} files."

        with :? AggregateException as e ->
            printfn "Exception messages:"

            for ie in e.InnerExceptions do
                printfn $"   {ie.GetType().Name}: {ie.Message}"

            printfn $"Task status: {t.Status}"
    }

main.Wait()

// The example displays the following output:
//       Exception messages:
//          TaskCanceledException: A task was canceled.
//
//       Task status: Canceled

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

Module Example
   Public Sub Main()
      Dim tokenSource As New CancellationTokenSource()
      Dim token As CancellationToken = tokenSource.Token
      Dim files As New List(Of Tuple(Of String, String, Long, Date))()
      Dim t As New Task(Sub()
                           Dim dir As String = "C:\Windows\System32\"
                           Dim obj As New Object()
                           If Directory.Exists(dir)Then
                              Parallel.ForEach(Directory.GetFiles(dir), 
                                 Sub(f)
                                    If token.IsCancellationRequested Then
                                       token.ThrowIfCancellationRequested()
                                    End If  
                                    Dim fi As New FileInfo(f)
                                    SyncLock(obj)
                                       files.Add(Tuple.Create(fi.Name, fi.DirectoryName, fi.Length, fi.LastWriteTimeUtc))          
                                    End SyncLock
                                 End Sub)
                           End If
                        End Sub, token)
      t.Start()
      tokenSource.Cancel()
      Try
         t.Wait() 
         Console.WriteLine("Retrieved information for {0} files.", files.Count)
      Catch e As AggregateException
         Console.WriteLine("Exception messages:")
         For Each ie As Exception In e.InnerExceptions
            Console.WriteLine("   {0}:{1}", ie.GetType().Name, ie.Message)
         Next
         Console.WriteLine()
         Console.WriteLine("Task status: {0}", t.Status)       
      Finally
         tokenSource.Dispose()
      End Try
   End Sub
End Module
' The example displays the following output:
'       Exception messages:
'          TaskCanceledException: A task was canceled.
'       
'       Task status: Canceled

注解

实例化 Task 对象并启动任务的最常见方法是调用 static Task.Run(Action, CancellationToken) 和 TaskFactory.StartNew(Action, CancellationToken) 方法，而不是调用此构造函数。此构造函数提供的唯一优点是，它允许将对象实例化与任务调用分开。

有关详细信息，请参阅任务并行 (托管线程中的任务并行库) 和取消。

适用于

Task(Action, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

使用指定的操作和创建选项初始化新的 Task。

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

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

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

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

参数

action: Action

表示要在任务中执行的代码的委托。

creationOptions: TaskCreationOptions

用于自定义任务的行为的 TaskCreationOptions。

例外

ArgumentNullException

action 参数为 null。

ArgumentOutOfRangeException

creationOptions 参数为 TaskCreationOptions 指定无效值。

注解

实例化 Task 对象并启动任务的最常见方法是调用静态 TaskFactory.StartNew(Action, TaskCreationOptions) 方法，而不是调用此构造函数。此构造函数提供的唯一优点是，它允许将对象实例化与任务调用分开。

适用于

Task(Action<Object>, Object)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

使用指定的操作和状态初始化新的 Task。

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

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

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

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

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

参数

action: Action<Object>

表示要在任务中执行的代码的委托。

state: Object

一个表示由该操作使用的数据的对象。

例外

ArgumentNullException

action 参数为 null。

示例

以下示例定义一个由 6 个字母的单词的数组。然后，每个单词作为参数传递给 Task(Action<Object>, Object) 构造函数，该构造函数的 Action<T> 委托会打乱单词中的字符，然后显示原始单词及其乱码版本。

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

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

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

open System
open System.Threading.Tasks

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

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

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

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

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

            t.Start()
            tasks.Add t

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

main.Wait()

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

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

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

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

注解

实例化 Task 对象并启动任务的最常见方法是调用静态 TaskFactory.StartNew(Action<Object>, Object) 方法，而不是调用此构造函数。此构造函数提供的唯一优点是，它允许将对象实例化与任务调用分开。

另请参阅

StartNew(Action<Object>, Object)

适用于

Task(Action, CancellationToken, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

使用指定的操作和创建选项初始化新的 Task。

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

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

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

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

参数

action: Action

表示要在任务中执行的代码的委托。

cancellationToken: CancellationToken

新任务将观察的 CancellationToken。

creationOptions: TaskCreationOptions

用于自定义任务的行为的 TaskCreationOptions。

例外

ObjectDisposedException

创建了 cancellationToken 的 CancellationTokenSource 已经被释放。

ArgumentNullException

action 参数为 null。

ArgumentOutOfRangeException

creationOptions 参数为 TaskCreationOptions 指定无效值。

注解

实例化 Task 对象并启动任务的最常见方法是调用静态 TaskFactory.StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler) 方法，而不是调用此构造函数。此构造函数提供的唯一优点是，它允许将对象实例化与任务调用分开。

有关详细信息，请参阅任务并行 (任务并行库) 和任务取消。

适用于

Task(Action<Object>, Object, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

使用指定的操作、状态和 CancellationToken初始化新的 Task 。

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

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

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

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

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

参数

action: Action<Object>

表示要在任务中执行的代码的委托。

state: Object

一个表示由该操作使用的数据的对象。

cancellationToken: CancellationToken

新任务将观察的 CancellationToken。

例外

ObjectDisposedException

创建了 cancellationToken 的 CancellationTokenSource 已经被释放。

ArgumentNullException

action 参数为 null。

注解

实例化 Task 对象并启动任务的最常见方法是调用静态 TaskFactory.StartNew(Action<Object>, Object, CancellationToken) 方法，而不是调用此构造函数。此构造函数提供的唯一优点是，它允许将对象实例化与任务调用分开。

适用于

Task(Action<Object>, Object, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

使用指定的操作、状态和选项初始化新的 Task。

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

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

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

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

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

参数

action: Action<Object>

表示要在任务中执行的代码的委托。

state: Object

一个表示由该操作使用的数据的对象。

creationOptions: TaskCreationOptions

用于自定义任务的行为的 TaskCreationOptions。

例外

ArgumentNullException

action 参数为 null。

ArgumentOutOfRangeException

creationOptions 参数为 TaskCreationOptions 指定无效值。

注解

实例化 Task 对象并启动任务的最常见方法是调用静态 TaskFactory.StartNew(Action<Object>, Object, TaskCreationOptions) 方法，而不是调用此构造函数。此构造函数提供的唯一优点是，它允许将对象实例化与任务调用分开。

适用于

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

使用指定的操作、状态和选项初始化新的 Task。

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

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

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

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

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

参数

action: Action<Object>

表示要在任务中执行的代码的委托。

state: Object

一个表示由该操作使用的数据的对象。

cancellationToken: CancellationToken

新任务将观察的 CancellationToken。

creationOptions: TaskCreationOptions

用于自定义任务的行为的 TaskCreationOptions。

例外

ObjectDisposedException

创建了 cancellationToken 的 CancellationTokenSource 已经被释放。

ArgumentNullException

action 参数为 null。

ArgumentOutOfRangeException

creationOptions 参数为 TaskCreationOptions 指定无效值。

注解

实例化 Task 对象并启动任务的最常见方法是调用静态 TaskFactory.StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler) 方法，而不是调用此构造函数。此构造函数提供的唯一优点是，它允许将对象实例化与任务调用分开。

适用于

Task 构造函数

定义

重载

Task(Action)

参数

例外

示例

注解

另请参阅

适用于

Task(Action, CancellationToken)

参数

例外

示例

注解

适用于

Task(Action, TaskCreationOptions)

参数

例外

注解

适用于

Task(Action<Object>, Object)

参数

例外

示例

注解

另请参阅

适用于

Task(Action, CancellationToken, TaskCreationOptions)

参数

例外

注解

适用于

Task(Action<Object>, Object, CancellationToken)

参数

例外

注解

适用于

Task(Action<Object>, Object, TaskCreationOptions)

参数

例外

注解

适用于

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

参数

例外

注解

适用于

反馈

其他资源