Task Konstruktoren

Referenz

Definition

Namespace:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Initialisiert eine neue Task.

Überlädt

Task(Action)	Initialisiert eine neue Task mit der angegebenen Aktion.
Task(Action, CancellationToken)	Initialisiert eine neue Task mit den angegebenen Werten für Aktion und CancellationToken.
Task(Action, TaskCreationOptions)	Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen.
Task(Action<Object>, Object)	Initialisiert eine neue Task mit den angegebenen Werten für Aktion und Zustand.
Task(Action, CancellationToken, TaskCreationOptions)	Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen.
Task(Action<Object>, Object, CancellationToken)	Initialisiert eine neue Task mit der angegebenen Aktion, dem angegebenen Zustand und CancellationToken.
Task(Action<Object>, Object, TaskCreationOptions)	Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.
Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)	Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.

Task(Action)

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Initialisiert eine neue Task mit der angegebenen Aktion.

public:
 Task(Action ^ action);

public Task (Action action);

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

Public Sub New (action As Action)

Parameter

action: Action

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.

Ausnahmen

ArgumentNullException

Das action-Argument lautet null.

Beispiele

Im folgenden Beispiel wird der Task(Action) Konstruktor verwendet, um Aufgaben zu erstellen, die die Dateinamen in angegebenen Verzeichnissen abrufen. Alle Aufgaben schreiben die Dateinamen in ein einzelnes ConcurrentBag<T> Objekt. Das Beispiel ruft dann die WaitAll(Task[]) -Methode auf, um sicherzustellen, dass alle Aufgaben abgeschlossen sind, und zeigt dann eine Anzahl der Gesamtzahl der in das ConcurrentBag<T> Objekt geschriebenen Dateinamen an.

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

Das folgende Beispiel ist identisch, mit der Ausnahme, dass die Run(Action) -Methode verwendet wurde, um den Task in einem einzelnen Vorgang zu instanziieren und auszuführen. Die -Methode gibt das Task Objekt zurück, das die Aufgabe darstellt.

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

Hinweise

Dieser Konstruktor sollte nur in erweiterten Szenarien verwendet werden, in denen es erforderlich ist, dass die Erstellung und der Start der Aufgabe getrennt sind.

Anstatt diesen Konstruktor aufzurufen, besteht die häufigste Methode zum Instanziieren eines Task Objekts und Starten einer Aufgabe darin, die statische Task.Run(Action) Methode oder TaskFactory.StartNew(Action) methode aufzurufen.

Wenn eine Aufgabe ohne Aktion benötigt wird, damit der Consumer einer API etwas erwartet, sollte ein TaskCompletionSource<TResult> verwendet werden.

Weitere Informationen

Run(Action)

Gilt für:

Task(Action, CancellationToken)

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Initialisiert eine neue Task mit den angegebenen Werten für Aktion und 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)

Parameter

action: Action

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.

cancellationToken: CancellationToken

Das CancellationToken, das die neue Aufgabe berücksichtigt.

Ausnahmen

ObjectDisposedException

Das angegebene CancellationToken wurde bereits verworfen.

ArgumentNullException

Das action-Argument ist 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. Der Lambdaausdruck ruft die Parallel.ForEach -Methode auf, um einem List<T> Objekt Informationen zu jeder Datei hinzuzufügen. Jede getrennt geschachtelte Aufgabe, die von der Parallel.ForEach Schleife aufgerufen wird, überprüft den Zustand des Abbruchtokens und ruft die Methode auf, wenn der CancellationToken.ThrowIfCancellationRequested Abbruch angefordert wird. 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. Die Start -Methode wird dann aufgerufen, um die Aufgabe zu starten.

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

Hinweise

Anstatt diesen Konstruktor aufzurufen, besteht die häufigste Methode zum Instanziieren eines Task Objekts und zum Starten einer Aufgabe darin, die statischen Task.Run(Action, CancellationToken) Methoden und TaskFactory.StartNew(Action, CancellationToken) die Methoden aufzurufen. Der einzige Vorteil dieses Konstruktors besteht darin, dass die Objektinstanziierung vom Vorgangsaufruf getrennt werden kann.

Weitere Informationen finden Sie unter Aufgabenparallelität (Taskparallele Bibliothek) und Abbruch in verwalteten Threads.

Gilt für:

Task(Action, TaskCreationOptions)

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen.

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)

Parameter

action: Action

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.

creationOptions: TaskCreationOptions

Die TaskCreationOptions, die verwendet werden, um das Verhalten der Aufgabe zu ändern.

Ausnahmen

ArgumentNullException

Das action-Argument ist null.

ArgumentOutOfRangeException

Das creationOptions-Argument gibt einen ungültigen Wert für TaskCreationOptions an.

Hinweise

Anstatt diesen Konstruktor aufzurufen, besteht die häufigste Methode zum Instanziieren eines Task Objekts und Starten einer Aufgabe darin, die statische TaskFactory.StartNew(Action, TaskCreationOptions) Methode aufzurufen. Der einzige Vorteil dieses Konstruktors besteht darin, dass die Objektinstanziierung vom Vorgangsaufruf getrennt werden kann.

Gilt für:

Task(Action<Object>, Object)

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Initialisiert eine neue Task mit den angegebenen Werten für Aktion und Zustand.

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)

Parameter

action: Action<Object>

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.

state: Object

Ein Objekt, das Daten darstellt, die von der Aktion verwendet werden sollen.

Ausnahmen

ArgumentNullException

Das action-Argument ist null.

Beispiele

Im folgenden Beispiel wird ein Array von Wörtern mit 6 Buchstaben definiert. Jedes Wort wird dann als Argument an den Task(Action<Object>, Object) Konstruktor übergeben, dessen Action<T> Delegat die Zeichen im Wort veredelt, und dann das ursprüngliche Wort und seine verschlüsselte Version anzeigt.

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

Hinweise

Anstatt diesen Konstruktor aufzurufen, besteht die häufigste Methode zum Instanziieren eines Task Objekts und Starten einer Aufgabe darin, die statische TaskFactory.StartNew(Action<Object>, Object) Methode aufzurufen. Der einzige Vorteil dieses Konstruktors besteht darin, dass die Objektinstanziierung vom Vorgangsaufruf getrennt werden kann.

Weitere Informationen

StartNew(Action<Object>, Object)

Gilt für:

Task(Action, CancellationToken, TaskCreationOptions)

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen.

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)

Parameter

action: Action

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.

cancellationToken: CancellationToken

Das CancellationToken, das die neue Aufgabe berücksichtigt.

creationOptions: TaskCreationOptions

Die TaskCreationOptions, die verwendet werden, um das Verhalten der Aufgabe zu ändern.

Ausnahmen

ObjectDisposedException

Die CancellationTokenSource, die cancellationToken erstellt hat, wurde bereits freigegeben.

ArgumentNullException

Das action-Argument ist null.

ArgumentOutOfRangeException

Das creationOptions-Argument gibt einen ungültigen Wert für TaskCreationOptions an.

Hinweise

Anstatt diesen Konstruktor aufzurufen, besteht die häufigste Methode zum Instanziieren eines Task Objekts und Starten einer Aufgabe darin, die statische TaskFactory.StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler) Methode aufzurufen. Der einzige Vorteil dieses Konstruktors besteht darin, dass die Objektinstanziierung vom Vorgangsaufruf getrennt werden kann.

Weitere Informationen finden Sie unter Aufgabenparallelität (Aufgabenparallele Bibliothek) und Aufgabenabbruch.

Gilt für:

Task(Action<Object>, Object, CancellationToken)

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Initialisiert eine neue Task mit der angegebenen Aktion, dem angegebenen Zustand und CancellationToken.

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)

Parameter

action: Action<Object>

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.

state: Object

Ein Objekt, das Daten darstellt, die von der Aktion verwendet werden sollen.

cancellationToken: CancellationToken

Das CancellationToken, das die neue Aufgabe berücksichtigt.

Ausnahmen

ObjectDisposedException

Die CancellationTokenSource, die cancellationToken erstellt hat, wurde bereits freigegeben.

ArgumentNullException

Das action-Argument ist null.

Hinweise

Anstatt diesen Konstruktor aufzurufen, besteht die häufigste Methode zum Instanziieren eines Task Objekts und Starten einer Aufgabe darin, die statische TaskFactory.StartNew(Action<Object>, Object, CancellationToken) Methode aufzurufen. Der einzige Vorteil dieses Konstruktors besteht darin, dass die Objektinstanziierung vom Vorgangsaufruf getrennt werden kann.

Gilt für:

Task(Action<Object>, Object, TaskCreationOptions)

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.

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)

Parameter

action: Action<Object>

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.

state: Object

Ein Objekt, das Daten darstellt, die von der Aktion verwendet werden sollen.

creationOptions: TaskCreationOptions

Die TaskCreationOptions, die verwendet werden, um das Verhalten der Aufgabe zu ändern.

Ausnahmen

ArgumentNullException

Das action-Argument ist null.

ArgumentOutOfRangeException

Das creationOptions-Argument gibt einen ungültigen Wert für TaskCreationOptions an.

Hinweise

Anstatt diesen Konstruktor aufzurufen, besteht die häufigste Methode zum Instanziieren eines Task Objekts und Starten einer Aufgabe darin, die statische TaskFactory.StartNew(Action<Object>, Object, TaskCreationOptions) Methode aufzurufen. Der einzige Vorteil dieses Konstruktors besteht darin, dass die Objektinstanziierung vom Vorgangsaufruf getrennt werden kann.

Gilt für:

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.

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)

Parameter

action: Action<Object>

Der Delegat, der den in der Aufgabe auszuführenden Code darstellt.

state: Object

Ein Objekt, das Daten darstellt, die von der Aktion verwendet werden sollen.

cancellationToken: CancellationToken

Das CancellationToken, das die neue Aufgabe berücksichtigt.

creationOptions: TaskCreationOptions

Die TaskCreationOptions, die verwendet werden, um das Verhalten der Aufgabe zu ändern.

Ausnahmen

ObjectDisposedException

Die CancellationTokenSource, die cancellationToken erstellt hat, wurde bereits freigegeben.

ArgumentNullException

Das action-Argument ist null.

ArgumentOutOfRangeException

Das creationOptions-Argument gibt einen ungültigen Wert für TaskCreationOptions an.

Hinweise

Anstatt diesen Konstruktor aufzurufen, besteht die häufigste Methode zum Instanziieren eines Task Objekts und Starten einer Aufgabe darin, die statische TaskFactory.StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler) Methode aufzurufen. Der einzige Vorteil dieses Konstruktors besteht darin, dass die Objektinstanziierung vom Vorgangsaufruf getrennt werden kann.

Gilt für:

Teilen über

Task Konstruktoren

Definition

Überlädt

Task(Action)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Task(Action, CancellationToken)

Parameter

Ausnahmen

Beispiele

Hinweise

Gilt für:

Task(Action, TaskCreationOptions)

Parameter

Ausnahmen

Hinweise

Gilt für:

Task(Action<Object>, Object)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Task(Action, CancellationToken, TaskCreationOptions)

Parameter

Ausnahmen

Hinweise

Gilt für:

Task(Action<Object>, Object, CancellationToken)

Parameter

Ausnahmen

Hinweise

Gilt für:

Task(Action<Object>, Object, TaskCreationOptions)

Parameter

Ausnahmen

Hinweise

Gilt für:

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

Parameter

Ausnahmen

Hinweise

Gilt für:

Zusätzliche Ressourcen