TaskFactory.StartNew Methode

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.

Erstellt und startet eine Aufgabe.

Überlädt

StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten, Zustand, das Abbruchtoken, die Erstellungsoptionen und den Taskplaner erstellt und gestartet.
StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)	Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten, das Abbruchtoken, die Erstellungsoptionen und den Zustand erstellt und gestartet.
StartNew(Action<Object>, Object, TaskCreationOptions)	Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten, Zustand und die Erstellungsoptionen erstellt und gestartet.
StartNew(Action<Object>, Object, CancellationToken)	Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten, Zustand und das Abbruchtoken erstellt und gestartet.
StartNew(Action, CancellationToken)	Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten und das Abbruchtoken erstellt und gestartet.
StartNew(Action, TaskCreationOptions)	Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten und die Erstellungsoptionen erstellt und gestartet.
StartNew(Action)	Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten erstellt und gestartet.
StartNew(Action<Object>, Object)	Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten und Zustand erstellt und gestartet.
StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)	Hiermit wird eine Aufgabe vom Typ `TResult` für den angegebenen Funktionsdelegaten, das Abbruchtoken, die Erstellungsoptionen und den Taskplaner erstellt und gestartet.
StartNew<TResult>(Func<TResult>)	Hiermit wird eine Aufgabe vom Typ `TResult` für den angegebenen Funktionsdelegaten erstellt und gestartet.
StartNew<TResult>(Func<Object,TResult>, Object)	Hiermit wird eine Aufgabe vom Typ `TResult` für den angegebenen Funktionsdelegaten und Zustand erstellt und gestartet.
StartNew<TResult>(Func<TResult>, CancellationToken)	Hiermit wird eine Aufgabe vom Typ `TResult` für den angegebenen Funktionsdelegaten und das Abbruchtoken erstellt und gestartet.
StartNew<TResult>(Func<TResult>, TaskCreationOptions)	Hiermit wird eine Aufgabe vom Typ `TResult` für den angegebenen Funktionsdelegaten und die Erstellungsoptionen erstellt und gestartet.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken)	Hiermit wird eine Aufgabe vom Typ `TResult` für den angegebenen Funktionsdelegaten, Zustand und das Abbruchtoken erstellt und gestartet.
StartNew<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	Hiermit wird eine Aufgabe vom Typ `TResult` für den angegebenen Funktionsdelegaten, Zustand und die Erstellungsoptionen erstellt und gestartet.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Hiermit wird eine Aufgabe vom Typ `TResult` für den angegebenen Funktionsdelegaten, Zustand, das Abbruchtoken, die Erstellungsoptionen und den Taskplaner erstellt und gestartet.

Hinweise

Ab dem .NET Framework 4.5 ist die Task.Run Methode die empfohlene Möglichkeit zum Starten einer berechnungsgebundenen Aufgabe. Verwenden Sie die StartNew Methode nur, wenn Sie eine fein körnige Kontrolle für eine lang ausgeführte, berechnete Aufgabe benötigen. Dies umfasst Szenarien, in denen Sie folgendes steuern möchten:

Aufgabenerstellungsoptionen. Standardmäßig erstellte Aufgaben werden mit der Task.Run TaskCreationOptions.DenyChildAttach Option erstellt. Um dieses Verhalten außer Kraft zu setzen oder andere TaskCreationOptions Optionen bereitzustellen, rufen Sie eine Überladung auf StartNew .
Parameterübergabe. Die Überladungen der Task.Run Methode ermöglichen es Ihnen nicht, einen Parameter an den Aufgabenstellvertretung zu übergeben. Überladungen der StartNew Methode tun.
Taskplaner Die Überladungen der Task.Run Methode verwenden den Standardaufgabenplaner. Um den Aufgabenplaner zu steuern, rufen Sie eine StartNew Überladung mit einem scheduler Parameter auf. Weitere Informationen finden Sie unter TaskScheduler.

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

Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten, Zustand, das Abbruchtoken, die Erstellungsoptionen und den Taskplaner erstellt und gestartet.

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

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

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

member this.StartNew : Action<obj> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task

Parameter

action: Action<Object>

Der Aktionsdelegat, der asynchron ausgeführt werden soll.

state: Object

Ein Objekt, das vom action-Delegaten zu verwendende Daten enthält.

cancellationToken: CancellationToken

Das Abbruchtoken, das der neuen Aufgabe zugewiesen wird.

creationOptions: TaskCreationOptions

Einer der Enumerationswerte, der das Verhalten der erstellten Aufgabe steuert.

scheduler: TaskScheduler

Der Aufgabenplaner, der verwendet wird, um die erstellte Fortsetzungsaufgabe zu planen.

Gibt zurück

Task

Die begonnene Aufgabe.

Ausnahmen

ObjectDisposedException

Das angegebene CancellationToken wurde bereits verworfen.

ArgumentNullException

action ist null.

- oder -

scheduler ist null.

ArgumentOutOfRangeException

Das creationOptions-Argument gibt einen ungültigen TaskCreationOptions-Wert an. Weitere Informationen finden Sie in den Hinweisen zu FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions).

Hinweise

Das Aufrufen von StartNew entspricht dem Erstellen eines Vorgangs mit einem seiner Konstruktoren und wird dann Start aufgerufen, um die Ausführung zu planen.

Ab dem .NET Framework 4.5 können Sie die Run Methode mit einem Action Objekt als schnelle Möglichkeit zum Aufrufen StartNew mit Standardparametern verwenden. Weitere Informationen und Codebeispiele finden Sie unter Task.Run vs Task.Factory.StartNew im Parallel Programming with .NET Blog.

Siehe auch

Gilt für

StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)

Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten, das Abbruchtoken, die Erstellungsoptionen und den Zustand erstellt und gestartet.

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

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

member this.StartNew : Action * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function StartNew (action As Action, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task

Parameter

action: Action

Der Aktionsdelegat, der asynchron ausgeführt werden soll.

cancellationToken: CancellationToken

Das Abbruchtoken, das der neuen Aufgabe zugewiesen wird.

creationOptions: TaskCreationOptions

Einer der Enumerationswerte, der das Verhalten der erstellten Aufgabe steuert.

scheduler: TaskScheduler

Der Aufgabenplaner, der verwendet wird, um die erstellte Fortsetzungsaufgabe zu planen.

Gibt zurück

Task

Die begonnene Aufgabe.

Ausnahmen

ObjectDisposedException

Das angegebene CancellationToken wurde bereits verworfen.

ArgumentNullException

action ist null.

- oder - scheduler ist null.

ArgumentOutOfRangeException

creationOptions gibt einen ungültigen TaskCreationOptions-Wert an. Weitere Informationen finden Sie in den Hinweisen zu FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions).

Hinweise

Das Aufrufen von StartNew entspricht dem Erstellen eines Vorgangs mit einem seiner Konstruktoren und wird dann Start aufgerufen, um die Ausführung zu planen.

Siehe auch

Gilt für

StartNew(Action<Object>, Object, TaskCreationOptions)

Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten, Zustand und die Erstellungsoptionen erstellt und gestartet.

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

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

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

member this.StartNew : Action<obj> * obj * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object, creationOptions As TaskCreationOptions) As Task

Parameter

action: Action<Object>

Der Aktionsdelegat, der asynchron ausgeführt werden soll.

state: Object

Ein Objekt, das vom action-Delegaten zu verwendende Daten enthält.

creationOptions: TaskCreationOptions

Einer der Enumerationswerte, der das Verhalten der erstellten Aufgabe steuert.

Gibt zurück

Task

Die begonnene Aufgabe.

Ausnahmen

ArgumentNullException

action ist null.

ArgumentOutOfRangeException

creationOptions gibt einen ungültigen TaskCreationOptions-Wert an.

Hinweise

Das Aufrufen von StartNew entspricht dem Erstellen eines Vorgangs mit einem seiner Konstruktoren und wird dann Start aufgerufen, um die Ausführung zu planen.

Siehe auch

Gilt für

StartNew(Action<Object>, Object, CancellationToken)

Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten, Zustand und das Abbruchtoken erstellt und gestartet.

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

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

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

member this.StartNew : Action<obj> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object, cancellationToken As CancellationToken) As Task

Parameter

action: Action<Object>

Der Aktionsdelegat, der asynchron ausgeführt werden soll.

state: Object

Ein Objekt, das vom action-Delegaten zu verwendende Daten enthält.

cancellationToken: CancellationToken

Das Abbruchtoken, das der neuen Aufgabe zugewiesen wird.

Gibt zurück

Task

Die begonnene Aufgabe.

Ausnahmen

ObjectDisposedException

Das angegebene CancellationToken wurde bereits verworfen.

ArgumentNullException

action ist null.

Beispiele

Im folgenden Beispiel wird ein Array von 6-Buchstaben-Wörtern definiert. Jedes Wort wird dann an einen Action<T> Stellvertretung übergeben, der das Wort durchsucht und das ursprüngliche Wort und seine scramblierte Version anzeigt.

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

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

      foreach (var word6 in words6)
         tasks.Add(Task.Factory.StartNew( (word) => { Char[] chars = word.ToString().ToCharArray();
                                                      double[] order = new double[chars.Length];
                                                      token.ThrowIfCancellationRequested();
                                                      bool wasZero = false;
                                                      lock (lockObj) {
                                                         for (int ctr = 0; ctr < order.Length; ctr++) {
                                                             order[ctr] = rnd.NextDouble();
                                                             if (order[ctr] == 0) {
                                                                if (! wasZero) {
                                                                   wasZero = true;
                                                                }
                                                                else {
                                                                   cts.Cancel();
                                                                }
                                                             }
                                                         }
                                                      }
                                                      token.ThrowIfCancellationRequested();
                                                      Array.Sort(order, chars);
                                                      Console.WriteLine("{0} --> {1}", word,
                                                                        new String(chars));
                                                    }, word6, token));

      try {
         Task.WaitAll(tasks.ToArray());
      }
      catch (AggregateException e) {
         foreach (var ie in e.InnerExceptions) {
            if (ie is OperationCanceledException) {
               Console.WriteLine("The word scrambling operation has been cancelled.");
               break;
            }
            else {
               Console.WriteLine(ie.GetType().Name + ": " + ie.Message);
            }
         }
      }
      finally {
         cts.Dispose();
      }
   }
}
// The example displays output like the following:
//    regain --> irnaeg
//    ordain --> rioadn
//    reason --> soearn
//    rained --> rinade
//    rioter --> itrore
//    senior --> norise
//    rental --> atnerl
//    editor --> oteird

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

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

      For Each word6 in words6
         tasks.Add(Task.Factory.StartNew( Sub(word)
                                              Dim chars() As Char = word.ToString().ToCharArray()
                                              Dim order(chars.Length - 1) As Double
                                              Dim wasZero As Boolean = False
                                              SyncLock lockObj
                                                 For ctr As Integer = 0 To order.Length - 1
                                                    order(ctr) = rnd.NextDouble()
                                                    If order(ctr) = 0 Then
                                                       If Not wasZero Then
                                                          wasZero = True
                                                       Else
                                                          cts.Cancel()
                                                       End If
                                                    End If
                                                 Next
                                              End SyncLock
                                              token.ThrowIfCancellationRequested()
                                              Array.Sort(order, chars)
                                              Console.WriteLine("{0} --> {1}", word,
                                                                new String(chars))
                                          End Sub, word6))
      Next
      Try
         Task.WaitAll(tasks.ToArray())
      Catch e As AggregateException
         For Each ie In e.InnerExceptions
            If TypeOf ie Is OperationCanceledException
               Console.WriteLine("The word scrambling operation has been cancelled.")
               Exit For
            Else
               Console.WriteLine(ie.GetType().Name + ": " + ie.Message)
            End If
         Next
      Finally
         cts.Dispose()
      End Try
   End Sub
End Module
' The example displays output like the following:
'       regain --> irnaeg
'       ordain --> rioadn
'       reason --> soearn
'       rained --> rinade
'       rioter --> itrore
'       senior --> norise
'       rental --> atnerl
'       editor --> oteird

Beachten Sie, dass das Beispiel einen einzelnen Zufallszahlen-Generator initialisiert, der durch eine Sperre geschützt ist. Weitere Informationen zu einer Sperrung finden Sie unter "The System.Random class and thread safety" im Random Kursthema. Um die Möglichkeit der Korruption des Zufallszahlen-Generators zu behandeln, wird ein Abbruchtoken an die Aufgabe übergeben. Wenn zwei Zufallszahlen gleich Null sind, wird davon ausgegangen, dass der Zufallszahlengenerator beschädigt ist und das Abbruchtoken festlegt. Bevor Sie das chars Array sortieren, das die sechs Zeichen in einem Wort enthält, ruft die Methode die CancellationToken.ThrowIfCancellationRequested Methode auf, um ein OperationCanceledException Token zu auslösen, wenn das Token abgebrochen wurde.

Hinweise

Das Aufrufen von StartNew entspricht dem Erstellen eines Vorgangs mit einem seiner Konstruktoren und wird dann Start aufgerufen, um die Ausführung zu planen.

Siehe auch

Gilt für

StartNew(Action, CancellationToken)

Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten und das Abbruchtoken erstellt und gestartet.

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

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

member this.StartNew : Action * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Function StartNew (action As Action, cancellationToken As CancellationToken) As Task

Parameter

action: Action

Der Aktionsdelegat, der asynchron ausgeführt werden soll.

cancellationToken: CancellationToken

Das Abbruchtoken, das der neuen Aufgabe zugewiesen wird.

Gibt zurück

Task

Die begonnene Aufgabe.

Ausnahmen

ObjectDisposedException

Das angegebene CancellationToken wurde bereits verworfen.

ArgumentNullException

action ist null.

Beispiele

Im folgenden Beispiel wird die Methode aufgerufen, um eine Aufgabe zu erstellen, die die StartNew(Action, CancellationToken) Dateien im Verzeichnis "C:\Windows\System32" durchläuft. Der Lambdaausdruck ruft die Parallel.ForEach Methode auf, um Informationen zu jeder Datei zu einem List<T> Objekt hinzuzufügen. Jede durch die Parallel.ForEach Schleife aufgerufene getrennte geschachtelte Aufgabe überprüft den Zustand des Abbruchtokens und ruft CancellationToken.ThrowIfCancellationRequested die Methode auf, wenn eine 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.

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

public class Example
{
   public static void Main()
   {
      var tokenSource = new CancellationTokenSource();
      var token = tokenSource.Token;
      var files = new List<Tuple<string, string, long, DateTime>>();

      var t = Task.Factory.StartNew( () => { string dir = "C:\\Windows\\System32\\";
                                object obj = new Object();
                                if (Directory.Exists(dir)) {
                                   Parallel.ForEach(Directory.GetFiles(dir),
                                   f => {
                                           if (token.IsCancellationRequested)
                                              token.ThrowIfCancellationRequested();
                                           var fi = new FileInfo(f);
                                           lock(obj) {
                                              files.Add(Tuple.Create(fi.Name, fi.DirectoryName, fi.Length, fi.LastWriteTimeUtc));          
                                           }
                                      });
                                 }
                              }
                        , token);
      tokenSource.Cancel();
      try {
         t.Wait(); 
         Console.WriteLine("Retrieved information for {0} files.", files.Count);
      }
      catch (AggregateException e) {
         Console.WriteLine("Exception messages:");
         foreach (var ie in e.InnerExceptions)
            Console.WriteLine("   {0}: {1}", ie.GetType().Name, ie.Message);

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

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

Module Example
   Public Sub Main()
      Dim tokenSource As New CancellationTokenSource()
      Dim token As CancellationToken = tokenSource.Token
      Dim files As New List(Of Tuple(Of String, String, Long, Date))()

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

Hinweise

Das Aufrufen StartNew entspricht dem Erstellen eines Vorgangs mit einem seiner Konstruktoren und wird dann Start aufgerufen, um die Ausführung zu planen.

Ab dem .NET Framework 4.5 können Sie die Task.Run(Action, CancellationToken) Methode als schnelle Möglichkeit zum Aufrufen StartNew(Action, CancellationToken) von Standardparametern verwenden. Beachten Sie jedoch, dass es einen Unterschied zwischen dem Verhalten zwischen den beiden Methoden gibt: Task.Run(Action, CancellationToken) Standardmäßig können untergeordnete Aufgaben nicht mit der Option zum Anfügen an die TaskCreationOptions.AttachedToParent aktuelle Task Instanz gestartet werden, während StartNew(Action, CancellationToken) dies der Fall ist. Weitere Informationen und Codebeispiele finden Sie unter Task.Run vs Task.Factory.StartNew im Parallel Programming with .NET Blog.

Siehe auch

Gilt für

StartNew(Action, TaskCreationOptions)

Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten und die Erstellungsoptionen erstellt und gestartet.

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

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

member this.StartNew : Action * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Function StartNew (action As Action, creationOptions As TaskCreationOptions) As Task

Parameter

action: Action

Der Aktionsdelegat, der asynchron ausgeführt werden soll.

creationOptions: TaskCreationOptions

Einer der Enumerationswerte, der das Verhalten der erstellten Aufgabe steuert.

Gibt zurück

Task

Die begonnene Aufgabe.

Ausnahmen

ArgumentNullException

action ist null.

ArgumentOutOfRangeException

creationOptions gibt einen ungültigen TaskCreationOptions-Wert an.

Hinweise

Das Aufrufen von StartNew entspricht dem Erstellen eines Vorgangs mit einem seiner Konstruktoren und wird dann Start aufgerufen, um die Ausführung zu planen.

Siehe auch

Gilt für

StartNew(Action)

Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten erstellt und gestartet.

public:
 System::Threading::Tasks::Task ^ StartNew(Action ^ action);

public System.Threading.Tasks.Task StartNew (Action action);

member this.StartNew : Action -> System.Threading.Tasks.Task

Public Function StartNew (action As Action) As Task

Parameter

action: Action

Der Aktionsdelegat, der asynchron ausgeführt werden soll.

Gibt zurück

Task

Die begonnene Aufgabe.

Ausnahmen

ArgumentNullException

Das action-Argument lautet null.

Beispiele

Im folgenden Beispiel wird die StartNew(Action) Methode verwendet, um wiederholt eine Action Stellvertretung aufzurufen, die eine Zufallszahl generiert, sie als Unicode-Codepunkt interpretiert, in eine UTF16-codierte Codeeinheit konvertiert und Informationen zu dem resultierenden Zeichen oder Zeichen anzeigt.

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

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      List<Task> tasks  = new List<Task>();
      // Execute the task 10 times.
      for (int ctr = 1; ctr <= 9; ctr++) {
         tasks.Add(Task.Factory.StartNew( () => {
                                            int utf32 = 0;
                                            lock(rnd) {
                                               // Get UTF32 value.
                                               utf32 = rnd.Next(0, 0xE01F0);
                                            }
                                            // Convert it to a UTF16-encoded character.
                                            string utf16 = Char.ConvertFromUtf32(utf32);
                                            // Display information about the character.
                                            Console.WriteLine("0x{0:X8} --> '{1,2}' ({2})", 
                                                              utf32, utf16, ShowHex(utf16));
                                         }));                           
      }
      Task.WaitAll(tasks.ToArray()); 
   }

   private static string ShowHex(string value)
   {
      string hexString = null;
      // Handle only non-control characters.
      if (! Char.IsControl(value, 0)) {
         foreach (var ch in value)
            hexString += $"0x{(ushort)ch:X} ";
      }   
      return hexString.Trim();
   }
}
// The example displays the following output:
//       0x00097103 --> '򗄃' (0x55836 0x56579)
//       0x000A98A1 --> '򩢡' (0x55910 0x56481)
//       0x00050002 --> '񐀂' (0x55552 0x56322)
//       0x0000FEF1 --> 'ﻱ' (0x65265)
//       0x0008BC0A --> '򋰊' (0x55791 0x56330)
//       0x000860EA --> '򆃪' (0x55768 0x56554)
//       0x0009AC5A --> '򚱚' (0x55851 0x56410)
//       0x00053320 --> '񓌠' (0x55564 0x57120)
//       0x000874EF --> '򇓯' (0x55773 0x56559)

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

Public Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim tasks As New List(Of Task)
      ' Execute the task 10 times.
      For ctr As Integer = 1 To 9
         tasks.Add(Task.Factory.StartNew(Sub()
                                            Dim utf32 As Integer
                                            SyncLock(rnd)
                                               ' Get UTF32 value.
                                               utf32 = rnd.Next(0, &hE01F0)
                                            End SyncLock
                                            ' Convert it to a UTF16-encoded character.
                                            Dim utf16 As String = Char.ConvertFromUtf32(utf32)
                                            ' Display information about the character.
                                            Console.WriteLine("0x{0:X8} --> '{1,2}' ({2})", 
                                                              utf32, utf16, ShowHex(utf16))
                                         End Sub))                           
      Next
      Task.WaitAll(tasks.ToArray()) 
   End Sub
   
   Private Function ShowHex(value As String) As String
      Dim hexString As String = Nothing
      ' Handle only non-control characters.
      If Not Char.IsControl(value, 0) Then
         For Each ch In value
            hexString += String.Format("0x{0} ", Convert.ToUInt16(ch))
         Next
      End If   
      Return hexString.Trim()
   End Function
End Module
' The example displays output similar to the following:
'       0x00097103 --> '򗄃' (0x55836 0x56579)
'       0x000A98A1 --> '򩢡' (0x55910 0x56481)
'       0x00050002 --> '񐀂' (0x55552 0x56322)
'       0x0000FEF1 --> 'ﻱ' (0x65265)
'       0x0008BC0A --> '򋰊' (0x55791 0x56330)
'       0x000860EA --> '򆃪' (0x55768 0x56554)
'       0x0009AC5A --> '򚱚' (0x55851 0x56410)
'       0x00053320 --> '񓌠' (0x55564 0x57120)
'       0x000874EF --> '򇓯' (0x55773 0x56559)

Hinweise

Das Aufrufen StartNew entspricht dem Erstellen einer Aufgabe mithilfe eines seiner Konstruktoren, und ruft dann die Methode auf, um die Task.Start Aufgabe für die Ausführung zu planen.

Ab dem .NET Framework 4.5 können Sie die Task.Run(Action) Methode als schnelle Möglichkeit zum Aufrufen StartNew(Action) von Standardparametern verwenden. Beachten Sie jedoch, dass es einen Unterschied zwischen dem Verhalten zwischen den beiden Methoden gibt: Task.Run(Action) Standardmäßig können untergeordnete Aufgaben nicht mit der Option zum Anfügen an die TaskCreationOptions.AttachedToParent aktuelle Task Instanz gestartet werden, während StartNew(Action) dies der Fall ist. Weitere Informationen und Codebeispiele finden Sie unter Task.Run vs Task.Factory.StartNew im Parallel Programming with .NET Blog.

Siehe auch

Gilt für

StartNew(Action<Object>, Object)

Hiermit wird eine Aufgabe für den angegebenen Aktionsdelegaten und Zustand erstellt und gestartet.

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

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

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

member this.StartNew : Action<obj> * obj -> System.Threading.Tasks.Task

Public Function StartNew (action As Action(Of Object), state As Object) As Task

Parameter

action: Action<Object>

Der Aktionsdelegat, der asynchron ausgeführt werden soll.

state: Object

Ein Objekt, das vom action-Delegaten zu verwendende Daten enthält.

Gibt zurück

Task

Die begonnene Aufgabe.

Ausnahmen

ArgumentNullException

Das action-Argument lautet null.

Beispiele

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

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

      foreach (var word6 in words6)
         tasks.Add(Task.Factory.StartNew( (word) => { Char[] chars = word.ToString().ToCharArray();
                                                      double[] order = new double[chars.Length];
                                                      lock (lockObj) {
                                                         for (int ctr = 0; ctr < order.Length; ctr++)
                                                             order[ctr] = rnd.NextDouble();
                                                      }
                                                      Array.Sort(order, chars);
                                                      Console.WriteLine("{0} --> {1}", word,
                                                                        new String(chars));
                                                    }, word6));

      Task.WaitAll(tasks.ToArray());
   }
}
// The example displays output like the following:
//    regain --> irnaeg
//    ordain --> rioadn
//    reason --> soearn
//    rained --> rinade
//    rioter --> itrore
//    senior --> norise
//    rental --> atnerl
//    editor --> oteird

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

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

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

Hinweise

Das Aufrufen StartNew entspricht dem Erstellen einer verwendung eines Task seiner Konstruktoren und ruft dann die Start Methode auf, um die Ausführung zu planen.

Siehe auch

Gilt für

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

Hiermit wird eine Aufgabe vom Typ TResult für den angegebenen Funktionsdelegaten, das Abbruchtoken, die Erstellungsoptionen und den Taskplaner erstellt und gestartet.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<TResult> ^ function, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<TResult> function, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.StartNew : Func<'Result> * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of TResult), cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task(Of TResult)

Typparameter

TResult

Der Typ des Ergebnisses, das über den Vorgang verfügbar ist.

Parameter

function: Func<TResult>

Ein Funktionsdelegat, der das zukünftige Ergebnis zurückgibt, das mithilfe der Aufgabe verfügbar sein wird.

cancellationToken: CancellationToken

Das Abbruchtoken, das der neuen Aufgabe zugewiesen wird.

creationOptions: TaskCreationOptions

Einer der Enumerationswerte, der das Verhalten der erstellten Aufgabe steuert.

scheduler: TaskScheduler

Der Aufgabenplaner, der verwendet wird, um die erstellte Fortsetzungsaufgabe zu planen.

Gibt zurück

Task<TResult>

Die begonnene Aufgabe.

Ausnahmen

ObjectDisposedException

Das angegebene CancellationToken wurde bereits verworfen.

ArgumentNullException

function ist null.

- oder - scheduler ist null.

ArgumentOutOfRangeException

Hinweise

Das Aufrufen von "StartNew" entspricht funktionell dem Erstellen einer Task<TResult> der Konstruktoren und dem Aufruf Start , um sie für die Ausführung zu planen.

Ab dem .NET Framework 4.5 können Sie die Run Methode mit einem Action Objekt als schnelle Möglichkeit zum Aufrufen StartNew mit Standardparametern verwenden. Weitere Informationen und Codebeispiele finden Sie im Eintrag Task.Run vs. Task.Factory.StartNew im Parallel Programming with .NET Blog.

Siehe auch

Gilt für

StartNew<TResult>(Func<TResult>)

Hiermit wird eine Aufgabe vom Typ TResult für den angegebenen Funktionsdelegaten erstellt und gestartet.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<TResult> ^ function);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<TResult> function);

member this.StartNew : Func<'Result> -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of TResult)) As Task(Of TResult)

Typparameter

TResult

Der Typ des Ergebnisses, das über die Aufgabe verfügbar ist.

Parameter

function: Func<TResult>

Ein Funktionsdelegat, der das zukünftige Ergebnis zurückgibt, das mithilfe der Aufgabe verfügbar sein wird.

Gibt zurück

Task<TResult>

Die begonnene Aufgabe.

Ausnahmen

ArgumentNullException

Das function-Argument lautet null.

Beispiele

Im folgenden Beispiel handelt es sich um eine einfache Ergänzungs-App, die zwei Zufallszahlen generiert und den Benutzer aufgefordert, seine Summe einzugeben. Anschließend wird angegeben, ob die Antwort richtig ist oder wenn die Antwort des Benutzers keine gültige Zahl ist, fordert der Benutzer auf, eine gültige Zahl erneut einzugeben. Dies StartNew wird verwendet, um die Objekte zu erstellen, die die Task<TResult> Zufallszahlen zurückgeben, die hinzugefügt werden sollen.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      Task<int>[] tasks = new Task<int>[2];
      Object obj = new Object();
      
      while (true) {
         for (int ctr = 0; ctr <= 1; ctr++)
            tasks[ctr] = Task.Factory.StartNew(() => { int i = 0;
                                                       lock(obj) {
                                                          i = rnd.Next(101);
                                                       }
                                                       return i; });

         Task.WaitAll(tasks);
         int n1 = tasks[0].Result;
         int n2 = tasks[1].Result;
         int result = n1 + n2;
         bool validInput = false;
         while (! validInput) {
            ShowMessage(n1, n2);
            string userInput = Console.ReadLine();
            // Process user input.
            if (userInput.Trim().ToUpper() == "X") return;
            int answer;
            validInput = Int32.TryParse(userInput, out answer);
            if (! validInput)
               Console.WriteLine("Invalid input. Try again, but enter only numbers. ");
            else if (answer == result)
               Console.WriteLine("Correct!");
            else
               Console.WriteLine("Incorrect. The correct answer is {0}.", result);
         }
      }
   }

   private static void ShowMessage(int n1, int n2)
   {
      Console.WriteLine("\nEnter 'x' to exit...");
      Console.Write("{0} + {1} = ", n1, n2);
   }
}
// The example displays the following output:
//       Enter 'x' to exit...
//       15 + 11 = 26
//       Correct!
//
//       Enter 'x' to exit...
//       75 + 33 = adc
//       Invalid input. Try again, but enter only numbers.
//
//       Enter 'x' to exit...
//       75 + 33 = 108
//       Correct!
//
//       Enter 'x' to exit...
//       67 + 55 = 133
//       Incorrect. The correct answer is 122.
//
//       Enter 'x' to exit...
//       92 + 51 = 133
//       Incorrect. The correct answer is 143.
//
//       Enter 'x' to exit...
//       81 + 65 = x

   
Imports System.Threading.Tasks

Module AdditionTester
   Public Sub Main()
      Dim rnd As New Random()
      Dim tasks(1) As Task(Of Integer)
      Dim obj As New Object()
      
      Do While True
         For ctr As Integer = 0 To 1
            tasks(ctr) = Task.Factory.StartNew(Function()
                                                  Dim i As Integer
                                                  SyncLock(obj)
                                                     i = rnd.Next(101)
                                                  End SyncLock
                                                  Return i
                                               End Function)
         Next
         Task.WaitAll(tasks)
         Dim n1 As Integer = tasks(0).Result
         Dim n2 As Integer = tasks(1).Result
         Dim result As Integer = n1 + n2
         Dim validInput As Boolean = False
         Do While Not validInput
            ShowMessage(n1, n2)
            Dim userInput As String = Console.ReadLine()
            ' Process user input.
            If userInput.Trim().ToUpper = "X" Then Exit Sub
            Dim answer As Integer
            validInput = Int32.TryParse(userInput, answer)
            If Not validInput Then
               Console.WriteLine("Invalid input. Try again, but enter only numbers. ")
            Else If answer = result Then
               Console.WriteLine("Correct!")
            Else
               Console.WriteLine("Incorrect. The correct answer is {0}.", result)
            End If
         Loop
      Loop
   End Sub
   
   Private Sub ShowMessage(n1 As Integer, n2 As Integer)
      Console.WriteLine()
      Console.WriteLine("Enter 'x' to exit...")
      Console.Write("{0} + {1} = ", n1, n2)
   End Sub
End Module
' The example displays output like the following:
'       Enter 'x' to exit...
'       15 + 11 = 26
'       Correct!
'
'       Enter 'x' to exit...
'       75 + 33 = adc
'       Invalid input. Try again, but enter only numbers.
'
'       Enter 'x' to exit...
'       75 + 33 = 108
'       Correct!
'
'       Enter 'x' to exit...
'       67 + 55 = 133
'       Incorrect. The correct answer is 122.
'
'       Enter 'x' to exit...
'       92 + 51 = 133
'       Incorrect. The correct answer is 143.
'
'       Enter 'x' to exit...
'       81 + 65 = x

Hinweise

Das Aufrufen StartNew entspricht dem Erstellen einer Verwendung eines Task<TResult> seiner Konstruktoren und wird dann Start aufgerufen, um die Ausführung zu planen.

Ab dem .NET Framework 4.5 können Sie die Task.Run<TResult>(Func<TResult>) Methode als schnelle Möglichkeit aufrufen, mit Standardparametern aufzurufenStartNew. Beachten Sie jedoch, dass es einen Unterschied zwischen dem Verhalten zwischen den beiden Methoden gibt: Task.Run<TResult>(Func<TResult>) Standardmäßig können untergeordnete Aufgaben nicht mit der Option zum Anfügen an die TaskCreationOptions.AttachedToParent aktuelle Task<TResult> Instanz gestartet werden, während StartNew<TResult>(Func<TResult>) dies der Fall ist. Weitere Informationen und Codebeispiele finden Sie im Eintrag Task.Run vs. Task.Factory.StartNew im Parallel Programming with .NET Blog.

Siehe auch

Gilt für

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

Hiermit wird eine Aufgabe vom Typ TResult für den angegebenen Funktionsdelegaten und Zustand erstellt und gestartet.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<System::Object ^, TResult> ^ function, System::Object ^ state);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object,TResult> function, object state);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object?,TResult> function, object? state);

member this.StartNew : Func<obj, 'Result> * obj -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object) As Task(Of TResult)

Typparameter

TResult

Der Typ des Ergebnisses, das über die Aufgabe verfügbar ist.

Parameter

function: Func<Object,TResult>

Ein Funktionsdelegat, der das zukünftige Ergebnis zurückgibt, das mithilfe der Aufgabe verfügbar sein wird.

state: Object

Ein Objekt, das vom function-Delegaten zu verwendende Daten enthält.

Gibt zurück

Task<TResult>

Die begonnene Aufgabe.

Ausnahmen

ArgumentNullException

function ist null.

Hinweise

Das Aufrufen von StartNew entspricht dem Erstellen einer verwendung eines Task<TResult> seiner Konstruktoren und wird dann Start aufgerufen, um die Ausführung zu planen.

Ab dem .NET Framework 4.5 können Sie die Run Methode mit einem Action Objekt als schnelle Möglichkeit zum Aufrufen StartNew mit Standardparametern verwenden. Weitere Informationen und Codebeispiele finden Sie im Eintrag Task.Run vs. Task.Factory.StartNew im Parallel Programming with .NET Blog.

Siehe auch

Gilt für

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

Hiermit wird eine Aufgabe vom Typ TResult für den angegebenen Funktionsdelegaten und das Abbruchtoken erstellt und gestartet.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<TResult> ^ function, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<TResult> function, System.Threading.CancellationToken cancellationToken);

member this.StartNew : Func<'Result> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of TResult), cancellationToken As CancellationToken) As Task(Of TResult)

Typparameter

TResult

Der Typ des Ergebnisses, das über die Aufgabe verfügbar ist.

Parameter

function: Func<TResult>

Ein Funktionsdelegat, der das zukünftige Ergebnis zurückgibt, das mithilfe der Aufgabe verfügbar sein wird.

cancellationToken: CancellationToken

Das Abbruchtoken, das der neuen Aufgabe zugewiesen wird.

Gibt zurück

Task<TResult>

Die begonnene Aufgabe.

Ausnahmen

ObjectDisposedException

Das angegebene CancellationToken wurde bereits verworfen.

ArgumentNullException

function ist null.

Beispiele

Im folgenden Beispiel werden zwei Aufgaben verwendet, um die Fibonacci-Sequenz zu berechnen, die in F100 = F100-1 + F100-2 mit Ausgangswerten F1= 1, F2 = 1 und F1 = 0, F2= 1 endet. Ungefähr die Hälfte der Zeit wird ein Abbruchtoken als ausgeführte Vorgänge festgelegt. Die Ausgabe aus dem Beispiel zeigt das Ergebnis, wenn die beiden Vorgänge erfolgreich abgeschlossen wurden und das Token abgebrochen wird.

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

public class Example
{
   public static void Main()
   {
      var rnd = new Random();
      var tasks = new List<Task<BigInteger[]>>();
      var source = new CancellationTokenSource();
      var token = source.Token;
      for (int ctr = 0; ctr <= 1; ctr++) {
         int start = ctr;
         tasks.Add(Task.Run( () => { BigInteger[] sequence = new BigInteger[100];
                                     sequence[0] = start;
                                     sequence[1] = 1;
                                     for (int index = 2; index <= sequence.GetUpperBound(0); index++) {
                                        token.ThrowIfCancellationRequested();
                                        sequence[index] = sequence[index - 1] + sequence[index - 2];
                                     }
                                     return sequence;
                                   }, token));
      }
      if (rnd.Next(0, 2) == 1)
         source.Cancel();
      try {
         Task.WaitAll(tasks.ToArray());
         foreach (var t in tasks)
            Console.WriteLine("{0}, {1}...{2:N0}", t.Result[0], t.Result[1],
                              t.Result[99]);
      }
      catch (AggregateException e) {
         foreach (var ex in e.InnerExceptions)
            Console.WriteLine("{0}: {1}", ex.GetType().Name, ex.Message);
      }
   }
}
// The example displays either the following output:
//    0, 1...218,922,995,834,555,169,026
//    1, 1...354,224,848,179,261,915,075
// or the following output:
//    TaskCanceledException: A task was canceled.
//    TaskCanceledException: A task was canceled.

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

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim tasks As New List(Of Task(Of BigInteger()))
      Dim source As New CancellationTokenSource
      Dim token As CancellationToken = source.Token
      For ctr As Integer = 0 To 1
         Dim start As Integer = ctr
         tasks.Add(Task.Run(Function()
                               Dim sequence(99) As BigInteger
                               sequence(0) = start
                               sequence(1) = 1
                               For index As Integer = 2 To sequence.GetUpperBound(0)
                                  token.ThrowIfCancellationRequested()
                                  sequence(index) = sequence(index - 1) + sequence(index - 2)
                               Next
                               Return sequence
                            End Function, token))
      Next
      If rnd.Next(0, 2) = 1 Then source.Cancel
      Try
         Task.WaitAll(tasks.ToArray())
         For Each t In tasks
            Console.WriteLine("{0}, {1}...{2:N0}", t.Result(0), t.Result(1),
                              t.Result(99))
         Next
      Catch e As AggregateException
         For Each ex In e.InnerExceptions
            Console.WriteLine("{0}: {1}", ex.GetType().Name, ex.Message)
         Next
      End Try
   End Sub
End Module
' The example displays either the following output:
'    0, 1...218,922,995,834,555,169,026
'    1, 1...354,224,848,179,261,915,075
' or the following output:
'    TaskCanceledException: A task was canceled.
'    TaskCanceledException: A task was canceled.

Hinweise

Das Aufrufen StartNew entspricht dem Erstellen einer Verwendung eines Task<TResult> seiner Konstruktoren und wird dann Start aufgerufen, um die Ausführung zu planen.

Ab dem .NET Framework 4.5 können Sie die Task.Run<TResult>(Func<TResult>, CancellationToken) Methode als schnelle Möglichkeit zum Aufrufen StartNew<TResult>(Func<TResult>, CancellationToken) von Standardparametern verwenden. Beachten Sie jedoch, dass es einen Unterschied zwischen dem Verhalten zwischen den beiden Methoden gibt: Task.Run<TResult>(Func<TResult>, CancellationToken) Standardmäßig können untergeordnete Aufgaben nicht mit der Option zum Anfügen an die TaskCreationOptions.AttachedToParent aktuelle Task<TResult> Instanz gestartet werden, während StartNew<TResult>(Func<TResult>, CancellationToken) dies der Fall ist. Weitere Informationen und Codebeispiele finden Sie im Eintrag Task.Run vs. Task.Factory.StartNew im Parallel Programming with .NET Blog.

Siehe auch

Gilt für

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

Hiermit wird eine Aufgabe vom Typ TResult für den angegebenen Funktionsdelegaten und die Erstellungsoptionen erstellt und gestartet.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<TResult> ^ function, System::Threading::Tasks::TaskCreationOptions creationOptions);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<TResult> function, System.Threading.Tasks.TaskCreationOptions creationOptions);

member this.StartNew : Func<'Result> * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of TResult), creationOptions As TaskCreationOptions) As Task(Of TResult)

Typparameter

TResult

Der Typ des Ergebnisses, das über den Vorgang verfügbar ist.

Parameter

function: Func<TResult>

Ein Funktionsdelegat, der das zukünftige Ergebnis zurückgibt, das mithilfe der Aufgabe verfügbar sein wird.

creationOptions: TaskCreationOptions

Einer der Enumerationswerte, der das Verhalten der erstellten Aufgabe steuert.

Gibt zurück

Task<TResult>

Die begonnene Aufgabe.

Ausnahmen

ArgumentNullException

function ist null.

ArgumentOutOfRangeException

Hinweise

Das Aufrufen von "StartNew" entspricht funktionell dem Erstellen einer Task<TResult> der Konstruktoren und dem Aufruf Start , um sie für die Ausführung zu planen.

Ab dem .NET Framework 4.5 können Sie die Run Methode mit einem Action Objekt als schnelle Möglichkeit zum Aufrufen StartNew mit Standardparametern verwenden. Weitere Informationen und Codebeispiele finden Sie im Eintrag Task.Run vs. Task.Factory.StartNew im Parallel Programming with .NET Blog.

Siehe auch

Gilt für

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

Hiermit wird eine Aufgabe vom Typ TResult für den angegebenen Funktionsdelegaten, Zustand und das Abbruchtoken erstellt und gestartet.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<System::Object ^, TResult> ^ function, System::Object ^ state, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object,TResult> function, object state, System.Threading.CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object?,TResult> function, object? state, System.Threading.CancellationToken cancellationToken);

member this.StartNew : Func<obj, 'Result> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object, cancellationToken As CancellationToken) As Task(Of TResult)

Typparameter

TResult

Der Typ des Ergebnisses, das über den Vorgang verfügbar ist.

Parameter

function: Func<Object,TResult>

Ein Funktionsdelegat, der das zukünftige Ergebnis zurückgibt, das mithilfe der Aufgabe verfügbar sein wird.

state: Object

Ein Objekt, das vom function-Delegaten zu verwendende Daten enthält.

cancellationToken: CancellationToken

Das Abbruchtoken, das der neuen Aufgabe zugewiesen wird.

Gibt zurück

Task<TResult>

Die begonnene Aufgabe.

Ausnahmen

ObjectDisposedException

Das angegebene CancellationToken wurde bereits verworfen.

ArgumentNullException

function ist null.

Hinweise

Das Aufrufen von "StartNew" entspricht funktionell dem Erstellen einer Task<TResult> der Konstruktoren und dem Aufruf Start , um sie für die Ausführung zu planen.

Ab dem .NET Framework 4.5 können Sie die Run Methode mit einem Action Objekt als schnelle Möglichkeit zum Aufrufen StartNew mit Standardparametern verwenden. Weitere Informationen und Codebeispiele finden Sie im Eintrag Task.Run vs. Task.Factory.StartNew im Parallel Programming with .NET Blog.

Siehe auch

Gilt für

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

Hiermit wird eine Aufgabe vom Typ TResult für den angegebenen Funktionsdelegaten, Zustand und die Erstellungsoptionen erstellt und gestartet.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<System::Object ^, TResult> ^ function, System::Object ^ state, System::Threading::Tasks::TaskCreationOptions creationOptions);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object,TResult> function, object state, System.Threading.Tasks.TaskCreationOptions creationOptions);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object?,TResult> function, object? state, System.Threading.Tasks.TaskCreationOptions creationOptions);

member this.StartNew : Func<obj, 'Result> * obj * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object, creationOptions As TaskCreationOptions) As Task(Of TResult)

Typparameter

TResult

Der Typ des Ergebnisses, das über den Vorgang verfügbar ist.

Parameter

function: Func<Object,TResult>

Ein Funktionsdelegat, der das zukünftige Ergebnis zurückgibt, das mithilfe der Aufgabe verfügbar sein wird.

state: Object

Ein Objekt, das vom function-Delegaten zu verwendende Daten enthält.

creationOptions: TaskCreationOptions

Einer der Enumerationswerte, der das Verhalten der erstellten Aufgabe steuert.

Gibt zurück

Task<TResult>

Die begonnene Aufgabe.

Ausnahmen

ArgumentNullException

function ist null.

ArgumentOutOfRangeException

Hinweise

Das Aufrufen von "StartNew" entspricht funktionell dem Erstellen einer Task<TResult> der Konstruktoren und dem Aufruf Start , um sie für die Ausführung zu planen.

Ab dem .NET Framework 4.5 können Sie die Run Methode mit einem Action Objekt als schnelle Möglichkeit zum Aufrufen StartNew mit Standardparametern verwenden. Weitere Informationen und Codebeispiele finden Sie im Eintrag Task.Run vs. Task.Factory.StartNew im Parallel Programming with .NET Blog.

Siehe auch

Gilt für

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

Hiermit wird eine Aufgabe vom Typ TResult für den angegebenen Funktionsdelegaten, Zustand, das Abbruchtoken, die Erstellungsoptionen und den Taskplaner erstellt und gestartet.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ StartNew(Func<System::Object ^, TResult> ^ function, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object,TResult> function, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler);

public System.Threading.Tasks.Task<TResult> StartNew<TResult> (Func<object?,TResult> function, object? state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.StartNew : Func<obj, 'Result> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function StartNew(Of TResult) (function As Func(Of Object, TResult), state As Object, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions, scheduler As TaskScheduler) As Task(Of TResult)

Typparameter

TResult

Der Typ des Ergebnisses, das über den Vorgang verfügbar ist.

Parameter

function: Func<Object,TResult>

Ein Funktionsdelegat, der das zukünftige Ergebnis zurückgibt, das mithilfe der Aufgabe verfügbar sein wird.

state: Object

Ein Objekt, das vom function-Delegaten zu verwendende Daten enthält.

cancellationToken: CancellationToken

Das Abbruchtoken, das der neuen Aufgabe zugewiesen wird.

creationOptions: TaskCreationOptions

Einer der Enumerationswerte, der das Verhalten der erstellten Aufgabe steuert.

scheduler: TaskScheduler

Der Aufgabenplaner, der verwendet wird, um die erstellte Fortsetzungsaufgabe zu planen.

Gibt zurück

Task<TResult>

Die begonnene Aufgabe.

Ausnahmen

ObjectDisposedException

Das angegebene CancellationToken wurde bereits verworfen.

ArgumentNullException

function ist null.

- oder - scheduler ist null.

ArgumentOutOfRangeException

Hinweise

Das Aufrufen von "StartNew" entspricht funktionell dem Erstellen einer Task<TResult> der Konstruktoren und dem Aufruf Start , um sie für die Ausführung zu planen.

Ab dem .NET Framework 4.5 können Sie die Run Methode mit einem Action Objekt als schnelle Möglichkeit zum Aufrufen StartNew mit Standardparametern verwenden. Weitere Informationen und Codebeispiele finden Sie im Eintrag Task.Run vs. Task.Factory.StartNew im Parallel Programming with .NET Blog.

Siehe auch

Gilt für