TaskFactory.StartNew Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Threading.Tasks

Zestaw:: System.Threading.Tasks.dll

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Tworzy i uruchamia zadanie.

Przeciążenia

StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Tworzy i uruchamia zadanie dla określonego delegata akcji, stanu, tokenu anulowania, opcji tworzenia i harmonogramu zadań.
StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)	Tworzy i uruchamia zadanie dla określonego delegata akcji, tokenu anulowania, opcji tworzenia i stanu.
StartNew(Action<Object>, Object, TaskCreationOptions)	Tworzy i uruchamia zadanie dla określonego delegata akcji, stanu i opcji tworzenia.
StartNew(Action<Object>, Object, CancellationToken)	Tworzy i uruchamia zadanie dla określonego delegata akcji, stanu i tokenu anulowania.
StartNew(Action, CancellationToken)	Tworzy i uruchamia zadanie dla określonego delegata akcji i tokenu anulowania.
StartNew(Action, TaskCreationOptions)	Tworzy i uruchamia zadanie dla określonego delegata akcji i opcji tworzenia.
StartNew(Action)	Tworzy i uruchamia zadanie dla określonego delegata akcji.
StartNew(Action<Object>, Object)	Tworzy i uruchamia zadanie dla określonego delegata i stanu akcji.
StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)	Tworzy i uruchamia zadanie typu `TResult` dla określonego delegata funkcji, token anulowania, opcje tworzenia i harmonogram zadań.
StartNew<TResult>(Func<TResult>)	Tworzy i uruchamia zadanie typu `TResult` dla określonego delegata funkcji.
StartNew<TResult>(Func<Object,TResult>, Object)	Tworzy i uruchamia zadanie typu `TResult` dla określonego delegata i stanu funkcji.
StartNew<TResult>(Func<TResult>, CancellationToken)	Tworzy i uruchamia zadanie typu `TResult` dla określonego delegata funkcji i token anulowania.
StartNew<TResult>(Func<TResult>, TaskCreationOptions)	Tworzy i uruchamia zadanie typu `TResult` dla określonego delegata funkcji i opcji tworzenia.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken)	Tworzy i uruchamia zadanie typu `TResult` dla określonego delegata funkcji, stanu i tokenu anulowania.
StartNew<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	Tworzy i uruchamia zadanie typu `TResult` dla określonego delegata funkcji, stanu i opcji tworzenia.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Tworzy i uruchamia zadanie typu `TResult` dla określonego delegata funkcji, stanu, tokenu anulowania, opcji tworzenia i harmonogramu zadań.

Uwagi

Począwszy od .NET Framework 4.5, Task.Run metoda jest zalecanym sposobem uruchamiania zadania powiązanego z obliczeniami. StartNew Użyj metody tylko wtedy, gdy wymagana jest szczegółowa kontrolka dla długotrwałego zadania powiązanego z obliczeniami. Obejmuje to scenariusze, w których chcesz kontrolować następujące elementy:

Opcje tworzenia zadań. Zadania utworzone przez metodę Task.Run są domyślnie tworzone z opcją TaskCreationOptions.DenyChildAttach . Aby zastąpić to zachowanie lub udostępnić inne TaskCreationOptions opcje, wywołaj przeciążenie StartNew .
Przekazywanie parametrów. Przeciążenia Task.Run metody nie umożliwiają przekazania parametru do delegata zadania. Przeciążenia StartNew metody .
Harmonogram zadań. Przeciążenia Task.Run metody używają domyślnego harmonogramu zadań. Aby kontrolować harmonogram zadań, wywołaj StartNew przeciążenie za pomocą parametru scheduler . Aby uzyskać więcej informacji, zobacz TaskScheduler.

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

Tworzy i uruchamia zadanie dla określonego delegata akcji, stanu, tokenu anulowania, opcji tworzenia i harmonogramu zadań.

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

Parametry

action: Action<Object>

Delegat akcji do wykonania asynchronicznie.

state: Object

Obiekt zawierający dane, które mają być używane przez delegata action .

cancellationToken: CancellationToken

Token anulowania, który zostanie przypisany do nowego zadania.

creationOptions: TaskCreationOptions

Jedna z wartości wyliczenia, która kontroluje zachowanie utworzonego zadania.

scheduler: TaskScheduler

Harmonogram zadań używany do planowania utworzonego zadania.

Zwraca

Task

Rozpoczęte zadanie.

Wyjątki

ObjectDisposedException

Dostarczone CancellationToken zostało już usunięte.

ArgumentNullException

action to null.

-lub-

scheduler to null.

ArgumentOutOfRangeException

creationOptions argument określa nieprawidłową TaskCreationOptions wartość. Aby uzyskać więcej informacji, zobacz uwagi dotyczące FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)

Uwagi

Wywoływanie polecenia StartNew jest funkcjonalnie równoważne tworzeniu zadania przy użyciu jednego z jego konstruktorów, a następnie wywoływanie w Start celu zaplanowania wykonania.

Począwszy od .NET Framework 4.5, można użyć Run metody z obiektem Action jako szybki sposób wywołania StartNew z parametrami domyślnymi. Aby uzyskać więcej informacji i przykładów kodu, zobacz Task.Run vs Task.Factory.StartNew w blogu Programowanie równoległe z platformą .NET.

Zobacz też

Dotyczy

StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)

Tworzy i uruchamia zadanie dla określonego delegata akcji, tokenu anulowania, opcji tworzenia i stanu.

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

Parametry

action: Action

Delegat akcji do wykonania asynchronicznie.

cancellationToken: CancellationToken

Token anulowania, który zostanie przypisany do nowego zadania.

creationOptions: TaskCreationOptions

Jedna z wartości wyliczenia, która kontroluje zachowanie utworzonego zadania.

scheduler: TaskScheduler

Harmonogram zadań używany do planowania utworzonego zadania.

Zwraca

Task

Rozpoczęte zadanie.

Wyjątki

ObjectDisposedException

Dostarczone CancellationToken zostało już usunięte.

ArgumentNullException

action to null.

-lub- scheduler to null.

ArgumentOutOfRangeException

creationOptions określa nieprawidłową wartość TaskCreationOptions. Aby uzyskać więcej informacji, zobacz uwagi dotyczące FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)

Uwagi

Wywoływanie polecenia StartNew jest funkcjonalnie równoważne tworzeniu zadania przy użyciu jednego z jego konstruktorów, a następnie wywoływanie w Start celu zaplanowania wykonania.

Zobacz też

Dotyczy

StartNew(Action<Object>, Object, TaskCreationOptions)

Tworzy i uruchamia zadanie dla określonego delegata akcji, stanu i opcji tworzenia.

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

Parametry

action: Action<Object>

Delegat akcji do wykonania asynchronicznie.

state: Object

Obiekt zawierający dane, które mają być używane przez delegata action .

creationOptions: TaskCreationOptions

Jedna z wartości wyliczenia, która kontroluje zachowanie utworzonego zadania.

Zwraca

Task

Rozpoczęte zadanie.

Wyjątki

ArgumentNullException

action to null.

ArgumentOutOfRangeException

creationOptions określa nieprawidłową TaskCreationOptions wartość.

Uwagi

Wywoływanie polecenia StartNew jest funkcjonalnie równoważne tworzeniu zadania przy użyciu jednego z jego konstruktorów, a następnie wywoływanie w Start celu zaplanowania wykonania.

Zobacz też

Dotyczy

StartNew(Action<Object>, Object, CancellationToken)

Tworzy i uruchamia zadanie dla określonego delegata akcji, stanu i tokenu anulowania.

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

Parametry

action: Action<Object>

Delegat akcji do wykonania asynchronicznie.

state: Object

Obiekt zawierający dane, które mają być używane przez delegata action .

cancellationToken: CancellationToken

Token anulowania, który zostanie przypisany do nowego zadania.

Zwraca

Task

Rozpoczęte zadanie.

Wyjątki

ObjectDisposedException

Dostarczone CancellationToken zostało już usunięte.

ArgumentNullException

action to null.

Przykłady

W poniższym przykładzie zdefiniowano tablicę 6-literowych wyrazów. Każde słowo jest następnie przekazywane do delegata Action<T> , który scrambles słowo i wyświetla oryginalne słowo i jego wersję scrambled.

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

Należy pamiętać, że przykład inicjuje pojedynczy generator liczb losowych, który jest chroniony przez blokadę. Aby uzyskać informacje na temat potrzeby blokady, zobacz temat "System.Random class and thread safety" (Bezpieczeństwo klasy System.Random i wątku) w Random temacie klasy. Aby obsłużyć możliwość uszkodzenia generatora liczb losowych, token anulowania jest przekazywany do zadania. Jeśli dwie losowe liczby równe zero, metoda zakłada, że generator liczb losowych jest uszkodzony i ustawia token anulowania. Przed sortowaniem chars tablicy zawierającej sześć znaków w słowie metoda wywołuje CancellationToken.ThrowIfCancellationRequested metodę , aby zgłosić OperationCanceledException , czy token został anulowany.

Uwagi

Wywoływanie polecenia StartNew jest funkcjonalnie równoważne tworzeniu zadania przy użyciu jednego z jego konstruktorów, a następnie wywoływanie w Start celu zaplanowania wykonania.

Zobacz też

Dotyczy

StartNew(Action, CancellationToken)

Tworzy i uruchamia zadanie dla określonego delegata akcji i tokenu anulowania.

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

Parametry

action: Action

Delegat akcji do wykonania asynchronicznie.

cancellationToken: CancellationToken

Token anulowania, który zostanie przypisany do nowego zadania.

Zwraca

Task

Rozpoczęte zadanie.

Wyjątki

ObjectDisposedException

Dostarczone CancellationToken zostało już usunięte.

ArgumentNullException

action to null.

Przykłady

Poniższy przykład wywołuje metodę StartNew(Action, CancellationToken) , aby utworzyć zadanie iterujące pliki w katalogu C:\Windows\System32. Wyrażenie lambda wywołuje metodę Parallel.ForEach , aby dodać informacje o każdym pliku do List<T> obiektu. Każde odłączone zagnieżdżone zadanie wywoływane przez Parallel.ForEach pętlę sprawdza stan tokenu anulowania, a jeśli zażądano anulowania, wywołuje metodę CancellationToken.ThrowIfCancellationRequested . Metoda CancellationToken.ThrowIfCancellationRequested zgłasza OperationCanceledException wyjątek obsługiwany w bloku, catch gdy wątek wywołujący wywołuje metodę 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

Uwagi

Wywołanie StartNew jest funkcjonalnie równoważne tworzeniu zadania przy użyciu jednego z jego konstruktorów, a następnie wywoływanie w Start celu zaplanowania jego wykonania.

Począwszy od .NET Framework 4.5, możesz użyć Task.Run(Action, CancellationToken) metody jako szybkiego sposobu wywołania StartNew(Action, CancellationToken) z parametrami domyślnymi. Należy jednak pamiętać, że istnieje różnica w zachowaniu między dwiema metodami dotyczącymi : Task.Run(Action, CancellationToken) domyślnie nie zezwala na uruchamianie podrzędnych zadań podrzędnych TaskCreationOptions.AttachedToParent z opcją dołączania do bieżącego Task wystąpienia.StartNew(Action, CancellationToken) Aby uzyskać więcej informacji i przykładów kodu, zobacz Task.Run vs Task.Factory.StartNew w blogu Programowanie równoległe z platformą .NET.

Zobacz też

Dotyczy

StartNew(Action, TaskCreationOptions)

Tworzy i uruchamia zadanie dla określonego delegata akcji i opcji tworzenia.

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

Parametry

action: Action

Delegat akcji do wykonania asynchronicznie.

creationOptions: TaskCreationOptions

Jedna z wartości wyliczenia, która kontroluje zachowanie utworzonego zadania.

Zwraca

Task

Rozpoczęte zadanie.

Wyjątki

ArgumentNullException

action to null.

ArgumentOutOfRangeException

creationOptions określa nieprawidłową TaskCreationOptions wartość.

Uwagi

Wywoływanie polecenia StartNew jest funkcjonalnie równoważne tworzeniu zadania przy użyciu jednego z jego konstruktorów, a następnie wywoływanie w Start celu zaplanowania wykonania.

Zobacz też

Dotyczy

StartNew(Action)

Tworzy i uruchamia zadanie dla określonego delegata akcji.

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

Parametry

action: Action

Delegat akcji do wykonania asynchronicznie.

Zwraca

Task

Rozpoczęte zadanie.

Wyjątki

ArgumentNullException

Argumentem action jest null.

Przykłady

W poniższym przykładzie użyto StartNew(Action) metody do wielokrotnego wywołania Action delegata, który generuje liczbę losową, interpretuje go jako punkt kodu Unicode, konwertuje go na jednostkę kodu zakodowaną w formacie UTF16 i wyświetla informacje o wynikowym znaku lub znakach.

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)

Uwagi

Wywołanie StartNew jest funkcjonalnie równoważne utworzeniu zadania przy użyciu jednego z jego konstruktorów, a następnie wywołanie Task.Start metody w celu zaplanowania zadania do wykonania.

Począwszy od .NET Framework 4.5, możesz użyć Task.Run(Action) metody jako szybkiego sposobu wywołania StartNew(Action) z parametrami domyślnymi. Należy jednak pamiętać, że istnieje różnica w zachowaniu między dwiema metodami dotyczącymi : Task.Run(Action) domyślnie nie zezwala na uruchamianie podrzędnych zadań podrzędnych TaskCreationOptions.AttachedToParent z opcją dołączania do bieżącego Task wystąpienia.StartNew(Action) Aby uzyskać więcej informacji i przykładów kodu, zobacz Task.Run vs Task.Factory.StartNew w blogu Programowanie równoległe z platformą .NET.

Zobacz też

Dotyczy

StartNew(Action<Object>, Object)

Tworzy i uruchamia zadanie dla określonego delegata i stanu akcji.

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

Parametry

action: Action<Object>

Delegat akcji do wykonania asynchronicznie.

state: Object

Obiekt zawierający dane, które mają być używane przez delegata action .

Zwraca

Task

Rozpoczęte zadanie.

Wyjątki

ArgumentNullException

Argumentem action jest null.

Przykłady

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

Uwagi

Wywołanie StartNew jest funkcjonalnie równoważne tworzeniu Task przy użyciu jednego z jego konstruktorów, a następnie wywoływanie Start metody w celu zaplanowania jej wykonania.

Zobacz też

Dotyczy

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

Tworzy i uruchamia zadanie typu TResult dla określonego delegata funkcji, token anulowania, opcje tworzenia i harmonogram zadań.

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)

Parametry typu

TResult

Typ wyniku dostępnego za pośrednictwem zadania.

Parametry

function: Func<TResult>

Delegat funkcji, który zwraca przyszły wynik, aby był dostępny za pomocą zadania.

cancellationToken: CancellationToken

Token anulowania, który zostanie przypisany do nowego zadania.

creationOptions: TaskCreationOptions

Jedna z wartości wyliczenia, która kontroluje zachowanie utworzonego zadania.

scheduler: TaskScheduler

Harmonogram zadań używany do planowania utworzonego zadania.

Zwraca

Task<TResult>

Rozpoczęte zadanie.

Wyjątki

ObjectDisposedException

Dostarczone CancellationToken zostało już usunięte.

ArgumentNullException

function to null.

-lub- scheduler to null.

ArgumentOutOfRangeException

creationOptions określa nieprawidłową TaskCreationOptions wartość. Aby uzyskać więcej informacji, zobacz uwagi dotyczące FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)

Uwagi

Wywołanie startNowy jest funkcjonalnie równoważne tworzeniu Task<TResult> przy użyciu jednego z jego konstruktorów, a następnie wywoływanie w Start celu zaplanowania jego wykonania.

Począwszy od .NET Framework 4.5, można użyć Run metody z obiektem Action jako szybki sposób wywołania StartNew z parametrami domyślnymi. Aby uzyskać więcej informacji i przykładów kodu, zobacz wpis Task.Run vs. Task.Factory.StartNew w blogu Programowanie równoległe za pomocą platformy .NET.

Zobacz też

Dotyczy

StartNew<TResult>(Func<TResult>)

Tworzy i uruchamia zadanie typu TResult dla określonego delegata funkcji.

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)

Parametry typu

TResult

Typ wyniku dostępnego za pośrednictwem zadania.

Parametry

function: Func<TResult>

Delegat funkcji, który zwraca przyszły wynik, aby był dostępny za pomocą zadania.

Zwraca

Task<TResult>

Rozpoczęte zadanie.

Wyjątki

ArgumentNullException

Argumentem function jest null.

Przykłady

Poniższy przykład to prosta aplikacja dodawania, która generuje dwie liczby losowe i monituje użytkownika o wprowadzenie sumy. Następnie wskazuje, czy odpowiedź jest poprawna, czy też, jeśli odpowiedź użytkownika nie jest prawidłową liczbą, monituje użytkownika o ponowne wprowadzenie prawidłowej liczby. Służy StartNew do tworzenia Task<TResult> obiektów, które zwracają liczby losowe do dodania.

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

Uwagi

Wywołanie StartNew jest funkcjonalnie równoważne tworzeniu Task<TResult> przy użyciu jednego z jego konstruktorów, a następnie wywoływanie Start w celu zaplanowania jego wykonania.

Począwszy od .NET Framework 4.5, możesz wywołać metodę jako szybki sposób wywołania Task.Run<TResult>(Func<TResult>) StartNew przy użyciu parametrów domyślnych. Należy jednak pamiętać, że istnieje różnica w zachowaniu między dwiema metodami dotyczącymi : Task.Run<TResult>(Func<TResult>) domyślnie nie zezwala na uruchamianie podrzędnych zadań podrzędnych TaskCreationOptions.AttachedToParent z opcją dołączania do bieżącego Task<TResult> wystąpienia.StartNew<TResult>(Func<TResult>) Aby uzyskać więcej informacji i przykładów kodu, zobacz wpis Task.Run vs. Task.Factory.StartNew w blogu Programowanie równoległe za pomocą platformy .NET.

Zobacz też

Dotyczy

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

Tworzy i uruchamia zadanie typu TResult dla określonego delegata i stanu funkcji.

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)

Parametry typu

TResult

Typ wyniku dostępnego za pośrednictwem zadania.

Parametry

function: Func<Object,TResult>

Delegat funkcji, który zwraca przyszły wynik, aby był dostępny za pomocą zadania.

state: Object

Obiekt zawierający dane, które mają być używane przez delegata function .

Zwraca

Task<TResult>

Rozpoczęte zadanie.

Wyjątki

ArgumentNullException

function to null.

Uwagi

Wywołanie startNowy jest funkcjonalnie równoważne tworzeniu Task<TResult> przy użyciu jednego z jego konstruktorów, a następnie wywoływanie w Start celu zaplanowania jego wykonania.

Począwszy od .NET Framework 4.5, można użyć Run metody z obiektem Action jako szybki sposób wywołania StartNew z parametrami domyślnymi. Aby uzyskać więcej informacji i przykładów kodu, zobacz wpis Task.Run vs. Task.Factory.StartNew w blogu Programowanie równoległe za pomocą platformy .NET.

Zobacz też

Dotyczy

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

Tworzy i uruchamia zadanie typu TResult dla określonego delegata funkcji i token anulowania.

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)

Parametry typu

TResult

Typ wyniku dostępnego za pośrednictwem zadania.

Parametry

function: Func<TResult>

Delegat funkcji, który zwraca przyszły wynik, aby był dostępny za pomocą zadania.

cancellationToken: CancellationToken

Token anulowania, który zostanie przypisany do nowego zadania.

Zwraca

Task<TResult>

Rozpoczęte zadanie.

Wyjątki

ObjectDisposedException

Dostarczone CancellationToken zostało już usunięte.

ArgumentNullException

function to null.

Przykłady

Poniższy przykład używa dwóch zadań do obliczenia sekwencji Fibonacciego kończącej się na F100 = F100-1 + F100-2 z wartościami nasion F1= 1, F2 = 1 i F1 = 0, F2 = 1. Około połowy czasu token anulowania jest ustawiany podczas wykonywania operacji. Dane wyjściowe z przykładu pokazują wynik, jeśli dwa zadania zakończą się pomyślnie i czy token zostanie anulowany.

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.

Uwagi

Wywołanie StartNew jest funkcjonalnie równoważne tworzeniu Task<TResult> przy użyciu jednego z jego konstruktorów, a następnie wywoływanie Start w celu zaplanowania jego wykonania.

Począwszy od .NET Framework 4.5, możesz użyć Task.Run<TResult>(Func<TResult>, CancellationToken) metody jako szybkiego sposobu wywołania StartNew<TResult>(Func<TResult>, CancellationToken) z parametrami domyślnymi. Należy jednak pamiętać, że istnieje różnica w zachowaniu między dwiema metodami dotyczącymi : Task.Run<TResult>(Func<TResult>, CancellationToken) domyślnie nie zezwala na uruchamianie podrzędnych zadań podrzędnych TaskCreationOptions.AttachedToParent z opcją dołączania do bieżącego Task<TResult> wystąpienia.StartNew<TResult>(Func<TResult>, CancellationToken) Aby uzyskać więcej informacji i przykładów kodu, zobacz wpis Task.Run vs. Task.Factory.StartNew w blogu Programowanie równoległe za pomocą platformy .NET.

Zobacz też

Dotyczy

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

Tworzy i uruchamia zadanie typu TResult dla określonego delegata funkcji i opcji tworzenia.

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)

Parametry typu

TResult

Typ wyniku dostępnego za pośrednictwem zadania.

Parametry

function: Func<TResult>

Delegat funkcji, który zwraca przyszły wynik, aby był dostępny za pomocą zadania.

creationOptions: TaskCreationOptions

Jedna z wartości wyliczenia, która kontroluje zachowanie utworzonego zadania.

Zwraca

Task<TResult>

Rozpoczęte zadanie.

Wyjątki

ArgumentNullException

function to null.

ArgumentOutOfRangeException

Uwagi

Wywołanie startNowy jest funkcjonalnie równoważne tworzeniu Task<TResult> przy użyciu jednego z jego konstruktorów, a następnie wywoływanie w Start celu zaplanowania jego wykonania.

Począwszy od .NET Framework 4.5, można użyć Run metody z obiektem Action jako szybki sposób wywołania StartNew z parametrami domyślnymi. Aby uzyskać więcej informacji i przykładów kodu, zobacz wpis Task.Run vs. Task.Factory.StartNew w blogu Programowanie równoległe za pomocą platformy .NET.

Zobacz też

Dotyczy

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

Tworzy i uruchamia zadanie typu TResult dla określonego delegata funkcji, stanu i tokenu anulowania.

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)

Parametry typu

TResult

Typ wyniku dostępnego za pośrednictwem zadania.

Parametry

function: Func<Object,TResult>

Delegat funkcji, który zwraca przyszły wynik, aby był dostępny za pomocą zadania.

state: Object

Obiekt zawierający dane, które mają być używane przez delegata function .

cancellationToken: CancellationToken

Token anulowania, który zostanie przypisany do nowego zadania.

Zwraca

Task<TResult>

Rozpoczęte zadanie.

Wyjątki

ObjectDisposedException

Dostarczone CancellationToken zostało już usunięte.

ArgumentNullException

function to null.

Uwagi

Wywołanie startNowy jest funkcjonalnie równoważne tworzeniu Task<TResult> przy użyciu jednego z jego konstruktorów, a następnie wywoływanie w Start celu zaplanowania jego wykonania.

Począwszy od .NET Framework 4.5, można użyć Run metody z obiektem Action jako szybki sposób wywołania StartNew z parametrami domyślnymi. Aby uzyskać więcej informacji i przykładów kodu, zobacz wpis Task.Run vs. Task.Factory.StartNew w blogu Programowanie równoległe za pomocą platformy .NET.

Zobacz też

Dotyczy

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

Tworzy i uruchamia zadanie typu TResult dla określonego delegata funkcji, stanu i opcji tworzenia.

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)

Parametry typu

TResult

Typ wyniku dostępnego za pośrednictwem zadania.

Parametry

function: Func<Object,TResult>

Delegat funkcji, który zwraca przyszły wynik, aby był dostępny za pomocą zadania.

state: Object

Obiekt zawierający dane, które mają być używane przez delegata function .

creationOptions: TaskCreationOptions

Jedna z wartości wyliczenia, która kontroluje zachowanie utworzonego zadania.

Zwraca

Task<TResult>

Rozpoczęte zadanie.

Wyjątki

ArgumentNullException

function to null.

ArgumentOutOfRangeException

Uwagi

Wywołanie startNowy jest funkcjonalnie równoważne tworzeniu Task<TResult> przy użyciu jednego z jego konstruktorów, a następnie wywoływanie w Start celu zaplanowania jego wykonania.

Począwszy od .NET Framework 4.5, można użyć Run metody z obiektem Action jako szybki sposób wywołania StartNew z parametrami domyślnymi. Aby uzyskać więcej informacji i przykładów kodu, zobacz wpis Task.Run vs. Task.Factory.StartNew w blogu Programowanie równoległe za pomocą platformy .NET.

Zobacz też

Dotyczy

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

Tworzy i uruchamia zadanie typu TResult dla określonego delegata funkcji, stanu, tokenu anulowania, opcji tworzenia i harmonogramu zadań.

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)

Parametry typu

TResult

Typ wyniku dostępnego za pośrednictwem zadania.

Parametry

function: Func<Object,TResult>

Delegat funkcji, który zwraca przyszły wynik, aby był dostępny za pomocą zadania.

state: Object

Obiekt zawierający dane, które mają być używane przez delegata function .

cancellationToken: CancellationToken

Token anulowania, który zostanie przypisany do nowego zadania.

creationOptions: TaskCreationOptions

Jedna z wartości wyliczenia, która kontroluje zachowanie utworzonego zadania.

scheduler: TaskScheduler

Harmonogram zadań używany do planowania utworzonego zadania.

Zwraca

Task<TResult>

Rozpoczęte zadanie.

Wyjątki

ObjectDisposedException

Dostarczone CancellationToken zostało już usunięte.

ArgumentNullException

function to null.

-lub- scheduler to null.

ArgumentOutOfRangeException

Uwagi

Wywołanie startNowy jest funkcjonalnie równoważne tworzeniu Task<TResult> przy użyciu jednego z jego konstruktorów, a następnie wywoływanie w Start celu zaplanowania jego wykonania.

Począwszy od .NET Framework 4.5, można użyć Run metody z obiektem Action jako szybki sposób wywołania StartNew z parametrami domyślnymi. Aby uzyskać więcej informacji i przykładów kodu, zobacz wpis Task.Run vs. Task.Factory.StartNew w blogu Programowanie równoległe za pomocą platformy .NET.

Zobacz też

Dotyczy