TaskFactory.StartNew Metódus

Definíció

Névtér:: System.Threading.Tasks

Szerelvények:: mscorlib.dll, System.Threading.Tasks.dll

Szerelvények:: netstandard.dll, System.Runtime.dll

Szerelvény:: System.Threading.Tasks.dll

Szerelvény:: System.Runtime.dll

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Létrehoz és elindít egy feladatot.

Túlterhelések

Name	Description
StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Létrehoz és elindít egy feladatot a megadott műveletmeghatalmazáshoz, állapothoz, lemondási jogkivonathoz, létrehozási beállításokhoz és feladatütemezőhöz.
StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)	Létrehoz és elindít egy feladatot a megadott műveletmeghatalmazáshoz, lemondási jogkivonathoz, létrehozási beállításokhoz és állapothoz.
StartNew(Action<Object>, Object, TaskCreationOptions)	Létrehoz és elindít egy feladatot a megadott műveletmeghatalmazási, állapot- és létrehozási beállításokhoz.
StartNew(Action<Object>, Object, CancellationToken)	Létrehoz és elindít egy feladatot a megadott műveletmeghatalmazási, állapot- és lemondási jogkivonathoz.
StartNew(Action, CancellationToken)	Létrehoz és elindít egy feladatot a megadott műveletmeghatalmazási és lemondási jogkivonathoz.
StartNew(Action, TaskCreationOptions)	Létrehoz és elindít egy feladatot a megadott műveletmeghatalmazási és létrehozási beállításokhoz.
StartNew(Action)	Létrehoz és elindít egy feladatot a megadott műveletmeghatalmazáshoz.
StartNew(Action<Object>, Object)	Létrehoz és elindít egy feladatot a megadott műveleti delegálthoz és állapothoz.
StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)	Létrehoz és elindít egy típusú `TResult` feladatot a megadott függvénydelegálthoz, a lemondási jogkivonathoz, a létrehozási beállításokhoz és a feladatütemezőhöz.
StartNew<TResult>(Func<TResult>)	Létrehoz és elindít egy feladattípust `TResult` a megadott függvénymeghatalmazáshoz.
StartNew<TResult>(Func<Object,TResult>, Object)	Létrehoz és elindít egy feladattípust `TResult` a megadott függvénymeghatalmazáshoz és állapothoz.
StartNew<TResult>(Func<TResult>, CancellationToken)	Létrehoz és elindít egy feladattípust `TResult` a megadott függvénymeghatalmazási és lemondási jogkivonathoz.
StartNew<TResult>(Func<TResult>, TaskCreationOptions)	Létrehoz és elindít egy típusfeladatot `TResult` a megadott függvénymeghatalmazási és létrehozási beállításokhoz.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken)	Létrehoz és elindít egy feladattípust `TResult` a megadott függvénymeghatalmazási, állapot- és lemondási jogkivonathoz.
StartNew<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	Létrehoz és elindít egy típusú `TResult` feladatot a megadott függvénydelegálási, állapot- és létrehozási beállításokhoz.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Létrehoz és elindít egy típusú `TResult` feladatot a megadott függvénymeghatalmazáshoz, állapothoz, lemondási jogkivonathoz, létrehozási beállításokhoz és feladatütemezőhöz.

Megjegyzések

A .NET Framework 4.5-től kezdve a Task.Run metódus a számítási feladatok indításának ajánlott módja. StartNew A metódust csak akkor használja, ha részletes vezérlésre van szüksége egy hosszú ideig futó, számításhoz kötött tevékenységhez. Ide tartoznak azok a forgatókönyvek, amelyekben a következőket szeretné szabályozni:

Feladatlétrehozás beállításai. A metódus által Task.Run alapértelmezés szerint létrehozott feladatok a TaskCreationOptions.DenyChildAttach beállítással jönnek létre. A viselkedés felülbírálásához vagy más TaskCreationOptions lehetőségek megadásához hívja meg a túlterhelést StartNew .
Paraméter átadása. A metódus túlterhelései Task.Run nem teszik lehetővé, hogy paramétert adjon át a feladatmegbízottnak. A metódus túlterhelése StartNew igen.
A feladatütemező. A metódus túlterhelései az Task.Run alapértelmezett feladatütemezőt használják. A feladatütemező szabályozásához hívjon túlterhelést StartNew egy scheduler paraméterrel. További információért lásd TaskScheduler.

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

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy feladatot a megadott műveletmeghatalmazáshoz, állapothoz, lemondási jogkivonathoz, létrehozási beállításokhoz és feladatütemezőhöz.

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

Paraméterek

action: Action<Object>

Az aszinkron végrehajtáshoz szükséges műveletmeghatalmazás.

state: Object

A meghatalmazott által action használandó adatokat tartalmazó objektum.

cancellationToken: CancellationToken

Az új tevékenységhez hozzárendelendő lemondási jogkivonat.

creationOptions: TaskCreationOptions

A létrehozott tevékenység viselkedését vezérlő enumerálási értékek egyike.

scheduler: TaskScheduler

A létrehozott tevékenység ütemezéséhez használt feladatütemező.

Válaszok

Task

Az elindított tevékenység.

Kivételek

ObjectDisposedException

A megadottak CancellationToken már el lettek dobva.

ArgumentNullException

action az null.

-vagy-

scheduler az null.

ArgumentOutOfRangeException

creationOptions az argumentum érvénytelen TaskCreationOptions értéket ad meg. További információkért lásd a következőhöz kapcsolódó megjegyzéseket: FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)

Megjegyzések

A StartNew hívása funkcionálisan egyenértékű azzal, ha egy feladatot az egyik konstruktorával hoz létre, majd meghívja Start a végrehajtás ütemezéséhez.

A .NET Framework 4.5-től kezdve a Run metódust egy Action objektummal is gyorsan meghívhatja az alapértelmezett paraméterekkel rendelkező StartNew. További információkért és kódpéldákért lásd Task.Run vs Task.Factory.StartNew a Párhuzamos programozás és .NET blogban.

Lásd még

A következőre érvényes:

StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy feladatot a megadott műveletmeghatalmazáshoz, lemondási jogkivonathoz, létrehozási beállításokhoz és állapothoz.

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

Paraméterek

action: Action

Az aszinkron végrehajtáshoz szükséges műveletmeghatalmazás.

cancellationToken: CancellationToken

Az új tevékenységhez hozzárendelendő lemondási jogkivonat.

creationOptions: TaskCreationOptions

A létrehozott tevékenység viselkedését vezérlő enumerálási értékek egyike.

scheduler: TaskScheduler

A létrehozott tevékenység ütemezéséhez használt feladatütemező.

Válaszok

Task

Az elindított tevékenység.

Kivételek

ObjectDisposedException

A megadottak CancellationToken már el lettek dobva.

ArgumentNullException

action az null.

-vagy-

scheduler az null.

ArgumentOutOfRangeException

creationOptions érvénytelen TaskCreationOptions értéket ad meg. További információkért lásd a következőhöz kapcsolódó megjegyzéseket: FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)

Megjegyzések

A StartNew hívása funkcionálisan egyenértékű azzal, ha egy feladatot az egyik konstruktorával hoz létre, majd meghívja Start a végrehajtás ütemezéséhez.

Lásd még

A következőre érvényes:

StartNew(Action<Object>, Object, TaskCreationOptions)

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy feladatot a megadott műveletmeghatalmazási, állapot- és létrehozási beállításokhoz.

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

Paraméterek

action: Action<Object>

Az aszinkron végrehajtáshoz szükséges műveletmeghatalmazás.

state: Object

A meghatalmazott által action használandó adatokat tartalmazó objektum.

creationOptions: TaskCreationOptions

A létrehozott tevékenység viselkedését vezérlő enumerálási értékek egyike.

Válaszok

Task

Az elindított tevékenység.

Kivételek

ArgumentNullException

action az null.

ArgumentOutOfRangeException

creationOptions érvénytelen TaskCreationOptions értéket ad meg.

Megjegyzések

A StartNew hívása funkcionálisan egyenértékű azzal, ha egy feladatot az egyik konstruktorával hoz létre, majd meghívja Start a végrehajtás ütemezéséhez.

Lásd még

A következőre érvényes:

StartNew(Action<Object>, Object, CancellationToken)

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy feladatot a megadott műveletmeghatalmazási, állapot- és lemondási jogkivonathoz.

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

Paraméterek

action: Action<Object>

Az aszinkron végrehajtáshoz szükséges műveletmeghatalmazás.

state: Object

A meghatalmazott által action használandó adatokat tartalmazó objektum.

cancellationToken: CancellationToken

Az új tevékenységhez hozzárendelendő lemondási jogkivonat.

Válaszok

Task

Az elindított tevékenység.

Kivételek

ObjectDisposedException

A megadottak CancellationToken már el lettek dobva.

ArgumentNullException

action az null.

Példák

Az alábbi példa egy hatbetűs szavakból álló tömböt határoz meg. Ezután a program minden szót átad egy Action<T> meghatalmazottnak, amely ráfésüli a szót, és megjeleníti az eredeti szót és annak kódolt verzióját.

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

Vegye figyelembe, hogy a példa egyetlen véletlenszerű számgenerátort inicializál, amelyet zárolás véd. A zárolás szükségességéről az osztály témakörében a "The System.Random class and thread safety" (A System.Random osztály és a Random szálbiztonság) című témakörben olvashat. A véletlenszerű számgenerátor sérülésének lehetőségének kezeléséhez egy lemondási jogkivonatot ad át a feladatnak. Ha két véletlenszerű szám nullával egyenlő, a metódus feltételezi, hogy a véletlenszerű számgenerátor sérült, és beállítja a lemondási jogkivonatot. A szó hat karakterét tartalmazó tömb rendezése chars előtt a metódus meghívja a CancellationToken.ThrowIfCancellationRequested metódust, hogy dobja a OperationCanceledException jogkivonatot, ha a jogkivonat megszakadt.

Megjegyzések

A StartNew hívása funkcionálisan egyenértékű azzal, ha egy feladatot az egyik konstruktorával hoz létre, majd meghívja Start a végrehajtás ütemezéséhez.

Lásd még

A következőre érvényes:

StartNew(Action, CancellationToken)

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy feladatot a megadott műveletmeghatalmazási és lemondási jogkivonathoz.

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

Paraméterek

action: Action

Az aszinkron végrehajtáshoz szükséges műveletmeghatalmazás.

cancellationToken: CancellationToken

Az új tevékenységhez hozzárendelendő lemondási jogkivonat.

Válaszok

Task

Az elindított tevékenység.

Kivételek

ObjectDisposedException

A megadottak CancellationToken már el lettek dobva.

ArgumentNullException

action az null.

Példák

Az alábbi példa meghívja a StartNew(Action, CancellationToken) metódust egy olyan feladat létrehozásához, amely a C:\Windows\System32 könyvtárban lévő fájlokat iterálja. A lambda kifejezés meghívja a Parallel.ForEach metódust, hogy az egyes fájlokkal kapcsolatos információkat adjon hozzá egy List<T> objektumhoz. A hurok által Parallel.ForEach meghívott minden leválasztott beágyazott feladat ellenőrzi a lemondási jogkivonat állapotát, és ha lemondást kér, meghívja a metódust CancellationToken.ThrowIfCancellationRequested . A CancellationToken.ThrowIfCancellationRequested metódus kivételt OperationCanceledException jelez, amelyet egy catch blokk kezel, amikor a hívó szál meghívja a metódust Task.Wait .

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

Megjegyzések

A hívás StartNew funkcionálisan egyenértékű azzal, ha egy feladatot az egyik konstruktorával hoz létre, majd meghívja Start a végrehajtás ütemezéséhez.

A .NET Framework 4.5-től kezdve a Task.Run(Action, CancellationToken) metódussal gyorsan meghívhatja StartNew(Action, CancellationToken) alapértelmezett paraméterekkel. Vegye figyelembe azonban, hogy a két módszer viselkedése között különbség van: Task.Run(Action, CancellationToken) alapértelmezés szerint nem engedélyezi a gyermekfeladatok indítását az TaskCreationOptions.AttachedToParent aktuális Task példányhoz csatolási lehetőséggel, míg StartNew(Action, CancellationToken) az igen. További információkért és kódpéldákért lásd Task.Run vs Task.Factory.StartNew a Párhuzamos programozás és .NET blogban.

Lásd még

A következőre érvényes:

StartNew(Action, TaskCreationOptions)

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy feladatot a megadott műveletmeghatalmazási és létrehozási beállításokhoz.

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

Paraméterek

action: Action

Az aszinkron végrehajtáshoz szükséges műveletmeghatalmazás.

creationOptions: TaskCreationOptions

A létrehozott tevékenység viselkedését vezérlő enumerálási értékek egyike.

Válaszok

Task

Az elindított tevékenység.

Kivételek

ArgumentNullException

action az null.

ArgumentOutOfRangeException

creationOptions érvénytelen TaskCreationOptions értéket ad meg.

Megjegyzések

A StartNew hívása funkcionálisan egyenértékű azzal, ha egy feladatot az egyik konstruktorával hoz létre, majd meghívja Start a végrehajtás ütemezéséhez.

Lásd még

A következőre érvényes:

StartNew(Action)

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy feladatot a megadott műveletmeghatalmazáshoz.

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

Paraméterek

action: Action

Az aszinkron végrehajtáshoz szükséges műveletmeghatalmazás.

Válaszok

Task

Az elindított tevékenység.

Kivételek

ArgumentNullException

Az action argumentum a következő null: .

Példák

Az alábbi példa egy StartNew(Action) véletlenszerű számot generáló meghatalmazott ismételt meghívására Action , Unicode kódpontként való értelmezésére, UTF16 kódolású kódegységté alakítására és az eredményül kapott karakterre vagy karakterekre vonatkozó információk megjelenítésére szolgál.

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)

Megjegyzések

A hívás StartNew funkcionálisan egyenértékű azzal, ha egy feladatot az egyik konstruktorával hoz létre, majd meghívja a Task.Start metódust, hogy ütemezze a feladatot a végrehajtáshoz.

A .NET Framework 4.5-től kezdve a Task.Run(Action) metódussal gyorsan meghívhatja StartNew(Action) alapértelmezett paraméterekkel. Vegye figyelembe azonban, hogy a két módszer viselkedése között különbség van: Task.Run(Action) alapértelmezés szerint nem engedélyezi a gyermekfeladatok indítását az TaskCreationOptions.AttachedToParent aktuális Task példányhoz csatolási lehetőséggel, míg StartNew(Action) az igen. További információkért és kódpéldákért lásd Task.Run vs Task.Factory.StartNew a Párhuzamos programozás és .NET blogban.

Lásd még

A következőre érvényes:

StartNew(Action<Object>, Object)

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy feladatot a megadott műveleti delegálthoz és állapothoz.

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

Paraméterek

action: Action<Object>

Az aszinkron végrehajtáshoz szükséges műveletmeghatalmazás.

state: Object

A meghatalmazott által action használandó adatokat tartalmazó objektum.

Válaszok

Task

Az elindított tevékenység.

Kivételek

ArgumentNullException

Az action argumentum a következő null: .

Példák

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

Megjegyzések

A hívás StartNew funkcionálisan egyenértékű azzal, ha egy Task konstruktort használ, majd meghívja a metódust a Start végrehajtás ütemezéséhez.

Lásd még

A következőre érvényes:

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

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy típusú TResult feladatot a megadott függvénydelegálthoz, a lemondási jogkivonathoz, a létrehozási beállításokhoz és a feladatütemezőhöz.

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)

Típusparaméterek

TResult

A feladaton keresztül elérhető eredmény típusa.

Paraméterek

function: Func<TResult>

Egy függvénydelegált, amely a jövőbeni eredményt adja vissza, hogy elérhető legyen a feladaton keresztül.

cancellationToken: CancellationToken

Az új tevékenységhez hozzárendelendő lemondási jogkivonat.

creationOptions: TaskCreationOptions

A létrehozott tevékenység viselkedését vezérlő enumerálási értékek egyike.

scheduler: TaskScheduler

A létrehozott tevékenység ütemezéséhez használt feladatütemező.

Válaszok

Task<TResult>

Az elindított tevékenység.

Kivételek

ObjectDisposedException

A megadottak CancellationToken már el lettek dobva.

ArgumentNullException

function az null.

-vagy-

scheduler az null.

ArgumentOutOfRangeException

Megjegyzések

A StartNew hívása funkcionálisan egyenértékű azzal, ha egy Task<TResult> konstruktort használ, majd meghívja Start a végrehajtás ütemezéséhez.

A .NET Framework 4.5-től kezdve a Run metódust egy Action objektummal is gyorsan meghívhatja az alapértelmezett paraméterekkel rendelkező StartNew. További információkért és kódpéldákért tekintse meg a Task.Run vs. Task.Factory.StartNew bejegyzést a párhuzamos programozásban .NET blogban.

Lásd még

A következőre érvényes:

StartNew<TResult>(Func<TResult>)

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy feladattípust TResult a megadott függvénymeghatalmazáshoz.

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)

Típusparaméterek

TResult

A feladaton keresztül elérhető eredmény típusa.

Paraméterek

function: Func<TResult>

Egy függvénydelegált, amely a jövőbeni eredményt adja vissza, hogy elérhető legyen a feladaton keresztül.

Válaszok

Task<TResult>

Az elindított tevékenység.

Kivételek

ArgumentNullException

Az function argumentum a következő null: .

Példák

Az alábbi példa egy egyszerű összeadási alkalmazás, amely két véletlenszerű számot hoz létre, és kéri a felhasználót, hogy adja meg az összeget. Ezután jelzi, hogy helyes-e a válasz, vagy ha a felhasználó válasza nem érvényes szám, megkéri a felhasználót, hogy adjon meg újra egy érvényes számot. A StartNew rendszer azokat az Task<TResult> objektumokat hozza létre, amelyek a hozzáadni kívánt véletlenszerű számokat adnak vissza.

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

Megjegyzések

A hívás StartNew funkcionálisan egyenértékű azzal, ha egy Task<TResult> konstruktort használ, majd meghívja Start a végrehajtás ütemezéséhez.

A .NET Framework 4.5-től kezdve a Task.Run<TResult>(Func<TResult>) metódust hívhatja meg gyorsan az alapértelmezett paraméterekkel rendelkező StartNew meghívásához. Vegye figyelembe azonban, hogy a két módszer viselkedése között különbség van: Task.Run<TResult>(Func<TResult>) alapértelmezés szerint nem engedélyezi a gyermekfeladatok indítását az TaskCreationOptions.AttachedToParent aktuális Task<TResult> példányhoz csatolási lehetőséggel, míg StartNew<TResult>(Func<TResult>) az igen. További információkért és kódpéldákért tekintse meg a Task.Run vs. Task.Factory.StartNew bejegyzést a párhuzamos programozásban .NET blogban.

Lásd még

A következőre érvényes:

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

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy feladattípust TResult a megadott függvénymeghatalmazáshoz és állapothoz.

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)

Típusparaméterek

TResult

A feladaton keresztül elérhető eredmény típusa.

Paraméterek

function: Func<Object,TResult>

Egy függvénydelegált, amely a jövőbeni eredményt adja vissza, hogy elérhető legyen a feladaton keresztül.

state: Object

A meghatalmazott által function használandó adatokat tartalmazó objektum.

Válaszok

Task<TResult>

Az elindított tevékenység.

Kivételek

ArgumentNullException

function az null.

Megjegyzések

A StartNew hívása funkcionálisan egyenértékű azzal, ha egy Task<TResult> konstruktort használ, majd meghívja Start a végrehajtás ütemezéséhez.

A .NET Framework 4.5-től kezdve a Run metódust egy Action objektummal is gyorsan meghívhatja az alapértelmezett paraméterekkel rendelkező StartNew. További információkért és kódpéldákért tekintse meg a Task.Run vs. Task.Factory.StartNew bejegyzést a párhuzamos programozásban .NET blogban.

Lásd még

A következőre érvényes:

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

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy feladattípust TResult a megadott függvénymeghatalmazási és lemondási jogkivonathoz.

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)

Típusparaméterek

TResult

A feladaton keresztül elérhető eredmény típusa.

Paraméterek

function: Func<TResult>

Egy függvénydelegált, amely a jövőbeni eredményt adja vissza, hogy elérhető legyen a feladaton keresztül.

cancellationToken: CancellationToken

Az új tevékenységhez hozzárendelendő lemondási jogkivonat.

Válaszok

Task<TResult>

Az elindított tevékenység.

Kivételek

ObjectDisposedException

A megadottak CancellationToken már el lettek dobva.

ArgumentNullException

function az null.

Példák

Az alábbi példa két feladatot használ az F100 = F100-1 + F100-2 végződésű Fibonacci-sorozat kiszámításához F1= 1, F2 = 1 és F1 = 0, F2= 1 magértékkel. A műveletek végrehajtásakor a rendszer az idő körülbelül felére állítja be a lemondási jogkivonatot. A példa kimenete az eredményt mutatja, ha a két tevékenység sikeresen befejeződött, és ha a jogkivonat megszakadt.

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.

Megjegyzések

A hívás StartNew funkcionálisan egyenértékű azzal, ha egy Task<TResult> konstruktort használ, majd meghívja Start a végrehajtás ütemezéséhez.

A .NET Framework 4.5-től kezdve a Task.Run<TResult>(Func<TResult>, CancellationToken) metódussal gyorsan meghívhatja StartNew<TResult>(Func<TResult>, CancellationToken) alapértelmezett paraméterekkel. Vegye figyelembe azonban, hogy a két módszer viselkedése között különbség van: Task.Run<TResult>(Func<TResult>, CancellationToken) alapértelmezés szerint nem engedélyezi a gyermekfeladatok indítását az TaskCreationOptions.AttachedToParent aktuális Task<TResult> példányhoz csatolási lehetőséggel, míg StartNew<TResult>(Func<TResult>, CancellationToken) az igen. További információkért és kódpéldákért tekintse meg a Task.Run vs. Task.Factory.StartNew bejegyzést a párhuzamos programozásban .NET blogban.

Lásd még

A következőre érvényes:

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

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy típusfeladatot TResult a megadott függvénymeghatalmazási és létrehozási beállításokhoz.

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)

Típusparaméterek

TResult

A feladaton keresztül elérhető eredmény típusa.

Paraméterek

function: Func<TResult>

Egy függvénydelegált, amely a jövőbeni eredményt adja vissza, hogy elérhető legyen a feladaton keresztül.

creationOptions: TaskCreationOptions

A létrehozott tevékenység viselkedését vezérlő enumerálási értékek egyike.

Válaszok

Task<TResult>

Az elindított tevékenység.

Kivételek

ArgumentNullException

function az null.

ArgumentOutOfRangeException

Megjegyzések

A StartNew hívása funkcionálisan egyenértékű azzal, ha egy Task<TResult> konstruktort használ, majd meghívja Start a végrehajtás ütemezéséhez.

A .NET Framework 4.5-től kezdve a Run metódust egy Action objektummal is gyorsan meghívhatja az alapértelmezett paraméterekkel rendelkező StartNew. További információkért és kódpéldákért tekintse meg a Task.Run vs. Task.Factory.StartNew bejegyzést a párhuzamos programozásban .NET blogban.

Lásd még

A következőre érvényes:

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

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy feladattípust TResult a megadott függvénymeghatalmazási, állapot- és lemondási jogkivonathoz.

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)

Típusparaméterek

TResult

A feladaton keresztül elérhető eredmény típusa.

Paraméterek

function: Func<Object,TResult>

Egy függvénydelegált, amely a jövőbeni eredményt adja vissza, hogy elérhető legyen a feladaton keresztül.

state: Object

A meghatalmazott által function használandó adatokat tartalmazó objektum.

cancellationToken: CancellationToken

Az új tevékenységhez hozzárendelendő lemondási jogkivonat.

Válaszok

Task<TResult>

Az elindított tevékenység.

Kivételek

ObjectDisposedException

A megadottak CancellationToken már el lettek dobva.

ArgumentNullException

function az null.

Megjegyzések

A StartNew hívása funkcionálisan egyenértékű azzal, ha egy Task<TResult> konstruktort használ, majd meghívja Start a végrehajtás ütemezéséhez.

A .NET Framework 4.5-től kezdve a Run metódust egy Action objektummal is gyorsan meghívhatja az alapértelmezett paraméterekkel rendelkező StartNew. További információkért és kódpéldákért tekintse meg a Task.Run vs. Task.Factory.StartNew bejegyzést a párhuzamos programozásban .NET blogban.

Lásd még

A következőre érvényes:

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

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy típusú TResult feladatot a megadott függvénydelegálási, állapot- és létrehozási beállításokhoz.

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)

Típusparaméterek

TResult

A feladaton keresztül elérhető eredmény típusa.

Paraméterek

function: Func<Object,TResult>

Egy függvénydelegált, amely a jövőbeni eredményt adja vissza, hogy elérhető legyen a feladaton keresztül.

state: Object

A meghatalmazott által function használandó adatokat tartalmazó objektum.

creationOptions: TaskCreationOptions

A létrehozott tevékenység viselkedését vezérlő enumerálási értékek egyike.

Válaszok

Task<TResult>

Az elindított tevékenység.

Kivételek

ArgumentNullException

function az null.

ArgumentOutOfRangeException

Megjegyzések

A StartNew hívása funkcionálisan egyenértékű azzal, ha egy Task<TResult> konstruktort használ, majd meghívja Start a végrehajtás ütemezéséhez.

A .NET Framework 4.5-től kezdve a Run metódust egy Action objektummal is gyorsan meghívhatja az alapértelmezett paraméterekkel rendelkező StartNew. További információkért és kódpéldákért tekintse meg a Task.Run vs. Task.Factory.StartNew bejegyzést a párhuzamos programozásban .NET blogban.

Lásd még

A következőre érvényes:

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

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Forrás:: TaskFactory.cs

Létrehoz és elindít egy típusú TResult feladatot a megadott függvénymeghatalmazáshoz, állapothoz, lemondási jogkivonathoz, létrehozási beállításokhoz és feladatütemezőhöz.

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)

Típusparaméterek

TResult

A feladaton keresztül elérhető eredmény típusa.

Paraméterek

function: Func<Object,TResult>

Egy függvénydelegált, amely a jövőbeni eredményt adja vissza, hogy elérhető legyen a feladaton keresztül.

state: Object

A meghatalmazott által function használandó adatokat tartalmazó objektum.

cancellationToken: CancellationToken

Az új tevékenységhez hozzárendelendő lemondási jogkivonat.

creationOptions: TaskCreationOptions

A létrehozott tevékenység viselkedését vezérlő enumerálási értékek egyike.

scheduler: TaskScheduler

A létrehozott tevékenység ütemezéséhez használt feladatütemező.

Válaszok

Task<TResult>

Az elindított tevékenység.

Kivételek

ObjectDisposedException

A megadottak CancellationToken már el lettek dobva.

ArgumentNullException

function az null.

-vagy-

scheduler az null.

ArgumentOutOfRangeException

Megjegyzések

A StartNew hívása funkcionálisan egyenértékű azzal, ha egy Task<TResult> konstruktort használ, majd meghívja Start a végrehajtás ütemezéséhez.

A .NET Framework 4.5-től kezdve a Run metódust egy Action objektummal is gyorsan meghívhatja az alapértelmezett paraméterekkel rendelkező StartNew. További információkért és kódpéldákért tekintse meg a Task.Run vs. Task.Factory.StartNew bejegyzést a párhuzamos programozásban .NET blogban.

Lásd még

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?