Task Konstruktoren

Definition

Initialisiert eine neue Task.Initializes a new Task.

Überlädt

Task(Action)

Initialisiert eine neue Task mit der angegebenen Aktion.Initializes a new Task with the specified action.

Task(Action, CancellationToken)

Initialisiert eine neue Task mit den angegebenen Werten für Aktion und CancellationToken.Initializes a new Task with the specified action and CancellationToken.

Task(Action, TaskCreationOptions)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen.Initializes a new Task with the specified action and creation options.

Task(Action<Object>, Object)

Initialisiert eine neue Task mit den angegebenen Werten für Aktion und Zustand.Initializes a new Task with the specified action and state.

Task(Action, CancellationToken, TaskCreationOptions)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen.Initializes a new Task with the specified action and creation options.

Task(Action<Object>, Object, CancellationToken)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.Initializes a new Task with the specified action, state, and options.

Task(Action<Object>, Object, TaskCreationOptions)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.Initializes a new Task with the specified action, state, and options.

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

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.Initializes a new Task with the specified action, state, and options.

Task(Action)

Initialisiert eine neue Task mit der angegebenen Aktion.Initializes a new Task with the specified action.

public:
 Task(Action ^ action);
public Task (Action action);
new System.Threading.Tasks.Task : Action -> System.Threading.Tasks.Task

Parameter

action
Action

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.The delegate that represents the code to execute in the task.

Ausnahmen

Das action-Argument lautet null.The action argument is null.

Beispiele

Im folgenden Beispiel wird der Task(Action)-Konstruktor verwendet, um Tasks zu erstellen, die die Dateinamen in angegebenen Verzeichnissen abrufen.The following example uses the Task(Action) constructor to create tasks that retrieve the filenames in specified directories. Alle Tasks schreiben die Dateinamen in ein einzelnes ConcurrentBag<T> Objekt.All tasks write the file names to a single ConcurrentBag<T> object. Im Beispiel wird dann die WaitAll(Task[])-Methode aufgerufen, um sicherzustellen, dass alle Aufgaben abgeschlossen sind, und anschließend wird die Anzahl der in das ConcurrentBag<T> Objekt geschriebenen Dateinamen angezeigt.The example then calls the WaitAll(Task[]) method to ensure that all tasks have completed, and then displays a count of the total number of file names written to the ConcurrentBag<T> object.

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

Das folgende Beispiel ist identisch, mit der Ausnahme, dass es die Run(Action)-Methode verwendet, um die Aufgabe in einem einzigen Vorgang zu instanziieren und auszuführen.The following example is identical, except that it used the Run(Action) method to instantiate and run the task in a single operation. Die-Methode gibt das Task Objekt zurück, das die Aufgabe darstellt.The method returns the Task object that represents the 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
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

Hinweise

Dieser Konstruktor sollte nur in erweiterten Szenarien verwendet werden, in denen es erforderlich ist, dass die Erstellung und der Start der Aufgabe getrennt werden.This constructor should only be used in advanced scenarios where it is required that the creation and starting of the task is separated.

Anstatt diesen Konstruktor aufzurufen, ist die gängigste Methode zum Instanziieren eines Task Objekts und zum Starten einer Aufgabe das Aufrufen der statischen Task.Run(Action) oder TaskFactory.StartNew(Action) Methode.Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static Task.Run(Action) or TaskFactory.StartNew(Action) method.

Wenn ein Task ohne Aktion benötigt wird, damit der Consumer einer API darauf warten kann, sollte ein TaskCompletionSource<TResult> verwendet werden.If a task with no action is needed just for the consumer of an API to have something to await, a TaskCompletionSource<TResult> should be used.

Siehe auch

Task(Action, CancellationToken)

Initialisiert eine neue Task mit den angegebenen Werten für Aktion und CancellationToken.Initializes a new Task with the specified action and 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

Parameter

action
Action

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.The delegate that represents the code to execute in the task.

cancellationToken
CancellationToken

Das CancellationToken, das die neue Aufgabe berücksichtigt.The CancellationToken that the new task will observe.

Ausnahmen

Das angegebene CancellationToken wurde bereits verworfen.The provided CancellationToken has already been disposed.

Das action-Argument ist null.The action argument is null.

Beispiele

Im folgenden Beispiel wird der Task(Action, CancellationToken)-Konstruktor aufgerufen, um eine Aufgabe zu erstellen, die die Dateien im Verzeichnis c:\Windows\System32 durchläuft.The following example calls the Task(Action, CancellationToken) constructor to create a task that iterates the files in the C:\Windows\System32 directory. Der Lambda-Ausdruck ruft die Parallel.ForEach-Methode auf, um einem List<T> Objektinformationen zu jeder Datei hinzuzufügen.The lambda expression calls the Parallel.ForEach method to add information about each file to a List<T> object. Jede von der Parallel.ForEach-Schleife aufgerufene getrennte, durch die Schleife aufgerufene Aufgabe überprüft den Status des Abbruch Tokens und ruft, wenn der Abbruch angefordert wird, die CancellationToken.ThrowIfCancellationRequested-Methode auf.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. Die CancellationToken.ThrowIfCancellationRequested-Methode löst eine OperationCanceledException Ausnahme aus, die in einem catch-Block behandelt wird, wenn der aufrufende Thread die Task.Wait-Methode aufruft.The CancellationToken.ThrowIfCancellationRequested method throws an OperationCanceledException exception that is handled in a catch block when the calling thread calls the Task.Wait method. Die Start-Methode wird dann aufgerufen, um die Aufgabe zu starten.The Start method is then called to start the task.

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

Hinweise

Anstatt diesen Konstruktor aufzurufen, ist die gängigste Methode zum Instanziieren eines Task Objekts und zum Starten einer Aufgabe das Aufrufen der statischen Methoden Task.Run(Action, CancellationToken) und TaskFactory.StartNew(Action, CancellationToken).Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static Task.Run(Action, CancellationToken) and TaskFactory.StartNew(Action, CancellationToken) methods. Der einzige von diesem Konstruktor angebotene Vorteil besteht darin, dass die Objekt Instanziierung von einem Task Aufruf getrennt werden kann.The only advantage offered by this constructor is that it allows object instantiation to be separated from task invocation.

Weitere Informationen finden Sie unter Aufgaben Parallelität (Task Parallel Library) und Abbruch in verwalteten Threads.For more information, see Task Parallelism (Task Parallel Library) and Cancellation in Managed Threads.

Task(Action, TaskCreationOptions)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen.Initializes a new Task with the specified action and creation options.

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

Parameter

action
Action

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.The delegate that represents the code to execute in the task.

creationOptions
TaskCreationOptions

Die TaskCreationOptions, die verwendet werden, um das Verhalten der Aufgabe zu ändern.The TaskCreationOptions used to customize the task's behavior.

Ausnahmen

Das action-Argument ist null.The action argument is null.

Das creationOptions-Argument gibt einen ungültigen Wert für TaskCreationOptions an.The creationOptions argument specifies an invalid value for TaskCreationOptions.

Hinweise

Anstatt diesen Konstruktor aufzurufen, wird die Methode zum Instanziieren eines Task Objekts und zum Starten einer Aufgabe durch Aufrufen der statischen TaskFactory.StartNew(Action, TaskCreationOptions)-Methode am häufigsten aufgerufen.Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static TaskFactory.StartNew(Action, TaskCreationOptions) method. Der einzige von diesem Konstruktor angebotene Vorteil besteht darin, dass die Objekt Instanziierung von einem Task Aufruf getrennt werden kann.The only advantage offered by this constructor is that it allows object instantiation to be separated from task invocation.

Task(Action<Object>, Object)

Initialisiert eine neue Task mit den angegebenen Werten für Aktion und Zustand.Initializes a new Task with the specified action and state.

public:
 Task(Action<System::Object ^> ^ action, System::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)

Parameter

action
Action<Object>

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.The delegate that represents the code to execute in the task.

state
Object

Ein Objekt, das Daten darstellt, die von der Aktion verwendet werden sollen.An object representing data to be used by the action.

Ausnahmen

Das action-Argument ist null.The action argument is null.

Beispiele

Im folgenden Beispiel wird ein Array aus 6 Buchstaben definiert.The following example defines an array of 6-letter words. Jedes Wort wird dann als Argument an den Task(Action<Object>, Object)-Konstruktor übergeben, dessen Action<T> Delegat die Zeichen im Wort abstürzt und dann das ursprüngliche Wort und seine Debugversion anzeigt.Each word is then passed as an argument to the Task(Action<Object>, Object) constructor, whose Action<T> delegate scrambles the characters in the word, then displays the original word and its scrambled version.

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

Hinweise

Anstatt diesen Konstruktor aufzurufen, wird die Methode zum Instanziieren eines Task Objekts und zum Starten einer Aufgabe durch Aufrufen der statischen TaskFactory.StartNew(Action<Object>, Object)-Methode am häufigsten aufgerufen.Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static TaskFactory.StartNew(Action<Object>, Object) method. Der einzige von diesem Konstruktor angebotene Vorteil besteht darin, dass die Objekt Instanziierung von einem Task Aufruf getrennt werden kann.The only advantage offered by this constructor is that it allows object instantiation to be separated from task invocation.

Siehe auch

Task(Action, CancellationToken, TaskCreationOptions)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen.Initializes a new Task with the specified action and creation options.

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

Parameter

action
Action

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.The delegate that represents the code to execute in the task.

cancellationToken
CancellationToken

Das CancellationToken, das die neue Aufgabe berücksichtigt.The CancellationToken that the new task will observe.

creationOptions
TaskCreationOptions

Die TaskCreationOptions, die verwendet werden, um das Verhalten der Aufgabe zu ändern.The TaskCreationOptions used to customize the task's behavior.

Ausnahmen

Die CancellationTokenSource, die cancellationToken erstellt hat, wurde bereits freigegeben.The CancellationTokenSource that created cancellationToken has already been disposed.

Das action-Argument ist null.The action argument is null.

Das creationOptions-Argument gibt einen ungültigen Wert für TaskCreationOptions an.The creationOptions argument specifies an invalid value for TaskCreationOptions.

Hinweise

Anstatt diesen Konstruktor aufzurufen, wird die Methode zum Instanziieren eines Task Objekts und zum Starten einer Aufgabe durch Aufrufen der statischen TaskFactory.StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)-Methode am häufigsten aufgerufen.Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static TaskFactory.StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler) method. Der einzige von diesem Konstruktor angebotene Vorteil besteht darin, dass die Objekt Instanziierung von einem Task Aufruf getrennt werden kann.The only advantage offered by this constructor is that it allows object instantiation to be separated from task invocation.

Weitere Informationen finden Sie unter Aufgaben Parallelität (Task Parallel Library) und Aufgaben Abbruch.For more information, see Task Parallelism (Task Parallel Library) and Task Cancellation.

Task(Action<Object>, Object, CancellationToken)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.Initializes a new Task with the specified action, state, and options.

public:
 Task(Action<System::Object ^> ^ action, System::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

Parameter

action
Action<Object>

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.The delegate that represents the code to execute in the task.

state
Object

Ein Objekt, das Daten darstellt, die von der Aktion verwendet werden sollen.An object representing data to be used by the action.

cancellationToken
CancellationToken

Das CancellationToken, das die neue Aufgabe berücksichtigt.The CancellationToken that the new task will observe.

Ausnahmen

Die CancellationTokenSource, die cancellationToken erstellt hat, wurde bereits freigegeben.The CancellationTokenSource that created cancellationToken has already been disposed.

Das action-Argument ist null.The action argument is null.

Hinweise

Anstatt diesen Konstruktor aufzurufen, wird die Methode zum Instanziieren eines Task Objekts und zum Starten einer Aufgabe durch Aufrufen der statischen TaskFactory.StartNew(Action<Object>, Object, CancellationToken)-Methode am häufigsten aufgerufen.Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static TaskFactory.StartNew(Action<Object>, Object, CancellationToken) method. Der einzige von diesem Konstruktor angebotene Vorteil besteht darin, dass die Objekt Instanziierung von einem Task Aufruf getrennt werden kann.The only advantage offered by this constructor is that it allows object instantiation to be separated from task invocation.

Task(Action<Object>, Object, TaskCreationOptions)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.Initializes a new Task with the specified action, state, and options.

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

Parameter

action
Action<Object>

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.The delegate that represents the code to execute in the task.

state
Object

Ein Objekt, das Daten darstellt, die von der Aktion verwendet werden sollen.An object representing data to be used by the action.

creationOptions
TaskCreationOptions

Die TaskCreationOptions, die verwendet werden, um das Verhalten der Aufgabe zu ändern.The TaskCreationOptions used to customize the task's behavior.

Ausnahmen

Das action-Argument ist null.The action argument is null.

Das creationOptions-Argument gibt einen ungültigen Wert für TaskCreationOptions an.The creationOptions argument specifies an invalid value for TaskCreationOptions.

Hinweise

Anstatt diesen Konstruktor aufzurufen, wird die Methode zum Instanziieren eines Task Objekts und zum Starten einer Aufgabe durch Aufrufen der statischen TaskFactory.StartNew(Action<Object>, Object, TaskCreationOptions)-Methode am häufigsten aufgerufen.Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static TaskFactory.StartNew(Action<Object>, Object, TaskCreationOptions) method. Der einzige von diesem Konstruktor angebotene Vorteil besteht darin, dass die Objekt Instanziierung von einem Task Aufruf getrennt werden kann.The only advantage offered by this constructor is that it allows object instantiation to be separated from task invocation.

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

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.Initializes a new Task with the specified action, state, and options.

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);
new System.Threading.Tasks.Task : Action<obj> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Parameter

action
Action<Object>

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.The delegate that represents the code to execute in the task.

state
Object

Ein Objekt, das Daten darstellt, die von der Aktion verwendet werden sollen.An object representing data to be used by the action.

cancellationToken
CancellationToken

Das CancellationToken, das die neue Aufgabe berücksichtigt.The CancellationToken that the new task will observe.

creationOptions
TaskCreationOptions

Die TaskCreationOptions, die verwendet werden, um das Verhalten der Aufgabe zu ändern.The TaskCreationOptions used to customize the task's behavior.

Ausnahmen

Die CancellationTokenSource, die cancellationToken erstellt hat, wurde bereits freigegeben.The CancellationTokenSource that created cancellationToken has already been disposed.

Das action-Argument ist null.The action argument is null.

Das creationOptions-Argument gibt einen ungültigen Wert für TaskCreationOptions an.The creationOptions argument specifies an invalid value for TaskCreationOptions.

Hinweise

Anstatt diesen Konstruktor aufzurufen, wird die Methode zum Instanziieren eines Task Objekts und zum Starten einer Aufgabe durch Aufrufen der statischen TaskFactory.StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)-Methode am häufigsten aufgerufen.Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static TaskFactory.StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler) method. Der einzige von diesem Konstruktor angebotene Vorteil besteht darin, dass die Objekt Instanziierung von einem Task Aufruf getrennt werden kann.The only advantage offered by this constructor is that it allows object instantiation to be separated from task invocation.

Gilt für: