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)

來源:: Task.cs

來源:: Task.cs

來源:: 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.Run(Action)或TaskFactory.StartNew(Action)方法，而不是呼叫這個建構函式，這是具現化Task物件並啟動工作最常見的方式。

如果只需要 API 的取用者要等候某個專案，就不需要採取任何動作的工作， TaskCompletionSource<TResult> 就應該使用。

另請參閱

Run(Action)

適用於

Task(Action, CancellationToken)

來源:: Task.cs

來源:: Task.cs

來源:: 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 方法。方法CancellationToken.ThrowIfCancellationRequested會在OperationCanceledException呼叫線程呼叫 Task.Wait 方法時擲回區塊中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.Run(Action, CancellationToken)和TaskFactory.StartNew(Action, CancellationToken)方法，而不是呼叫這個建構函式，將物件具現化Task並啟動工作最常見的方式。這個建構函式所提供的唯一優點是它允許物件具現化與工作調用分開。

如需詳細資訊，請參閱工作平行處理原則 (受控線程中的工作平行連結庫) 和取消。

適用於

Task(Action, TaskCreationOptions)

來源:: Task.cs

來源:: Task.cs

來源:: 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)

來源:: Task.cs

來源:: Task.cs

來源:: 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)

來源:: Task.cs

來源:: Task.cs

來源:: 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)

來源:: Task.cs

來源:: Task.cs

來源:: 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)

來源:: Task.cs

來源:: Task.cs

來源:: 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)

來源:: Task.cs

來源:: Task.cs

來源:: 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)

參數

例外狀況

備註

適用於

其他資源