Task Task Task Task Constructors

Definizione

Overload

Task(Action) Task(Action) Task(Action)

Inizializza un nuovo oggetto Task con l'azione specificata.Initializes a new Task with the specified action.

Task(Action, CancellationToken) Task(Action, CancellationToken) Task(Action, CancellationToken)

Inizializza un nuovo oggetto Task con l'azione specificata e CancellationToken.Initializes a new Task with the specified action and CancellationToken.

Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions)

Inizializza un nuovo oggetto Task con l'azione e le opzioni di creazione specificate.Initializes a new Task with the specified action and creation options.

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

Inizializza un nuovo oggetto Task con l'azione e lo stato specificati.Initializes a new Task with the specified action and state.

Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions)

Inizializza un nuovo oggetto Task con l'azione e le opzioni di creazione specificate.Initializes a new Task with the specified action and creation options.

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

Inizializza un nuovo oggetto Task con l'azione, lo stato e le opzioni specificati.Initializes a new Task with the specified action, state, and options.

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

Inizializza un nuovo oggetto Task con l'azione, lo stato e le opzioni specificati.Initializes a new Task with the specified action, state, and options.

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

Inizializza un nuovo oggetto Task con l'azione, lo stato e le opzioni specificati.Initializes a new Task with the specified action, state, and options.

Task(Action) Task(Action) Task(Action)

Inizializza un nuovo oggetto Task con l'azione specificata.Initializes a new Task with the specified action.

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

Parametri

action
Action Action Action Action

Delegato che rappresenta il codice da eseguire nell'attività.The delegate that represents the code to execute in the task.

Eccezioni

Il valore dell'argomento action è null.The action argument is null.

Esempi

Nell'esempio seguente viene usato Task(Action) il costruttore per creare attività che recuperano i nomi file nelle directory specificate.The following example uses the Task(Action) constructor to create tasks that retrieve the filenames in specified directories. Tutte le attività scrivono i nomi di file in ConcurrentBag<T> un singolo oggetto.All tasks write the file names to a single ConcurrentBag<T> object. Nell'esempio viene quindi chiamato WaitAll(Task[]) il metodo per garantire che tutte le attività siano state completate, quindi viene visualizzato un conteggio del numero totale di nomi di ConcurrentBag<T> file scritti nell'oggetto.The example then calls the WaitAll(Task[]) method to ensure that all tasks have completed, and then displays a count of the total number of file names written to the ConcurrentBag<T> object.

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

public class Example
{
   public static async Task Main()
   {
      var list = new ConcurrentBag<string>();
      string[] dirNames = { ".", ".." };
      List<Task> tasks = new List<Task>();
      foreach (var dirName in dirNames) {
         Task t = new Task( () => { foreach(var path in Directory.GetFiles(dirName))
                                    list.Add(path); }  );
         tasks.Add(t);
         t.Start();
      }
      await Task.WhenAll(tasks.ToArray());
      foreach (Task t in tasks)
         Console.WriteLine("Task {0} Status: {1}", t.Id, t.Status);
         
      Console.WriteLine("Number of files read: {0}", list.Count);
   }
}
// The example displays output like the following:
//       Task 1 Status: RanToCompletion
//       Task 2 Status: RanToCompletion
//       Number of files read: 23
Imports System.Collections.Concurrent
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim list As New ConcurrentBag(Of String)()
      Dim dirNames() As String = { ".", ".." }
      Dim tasks As New List(Of Task)()
      For Each dirName In dirNames 
         Dim t As New Task( Sub()
                               For Each path In Directory.GetFiles(dirName)
                                  list.Add(path)
                               Next
                            End Sub  )
         tasks.Add(t)
         t.Start()
      Next
      Task.WaitAll(tasks.ToArray())
      For Each t In tasks
         Console.WriteLine("Task {0} Status: {1}", t.Id, t.Status)
      Next   
      Console.WriteLine("Number of files read: {0}", list.Count)
   End Sub
End Module
' The example displays output like the following:
'       Task 1 Status: RanToCompletion
'       Task 2 Status: RanToCompletion
'       Number of files read: 23

L'esempio seguente è identico, ad eccezione del fatto Run(Action) che ha usato il metodo per creare un'istanza ed eseguire l'attività in un'unica operazione.The following example is identical, except that it used the Run(Action) method to instantiate and run the task in a single operation. Il metodo restituisce l' Task oggetto che rappresenta l'attività.The method returns the Task object that represents the task.

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

public class Example
{
   public static void Main()
   {
      var list = new ConcurrentBag<string>();
      string[] dirNames = { ".", ".." };
      List<Task> tasks = new List<Task>();
      foreach (var dirName in dirNames) {
         Task t = Task.Run( () => { foreach(var path in Directory.GetFiles(dirName)) 
                                       list.Add(path); }  );
         tasks.Add(t);
      }
      Task.WaitAll(tasks.ToArray());
      foreach (Task t in tasks)
         Console.WriteLine("Task {0} Status: {1}", t.Id, t.Status);
         
      Console.WriteLine("Number of files read: {0}", list.Count);
   }
}
// The example displays output like the following:
//       Task 1 Status: RanToCompletion
//       Task 2 Status: RanToCompletion
//       Number of files read: 23
Imports System.Collections.Concurrent
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim list As New ConcurrentBag(Of String)()
      Dim dirNames() As String = { ".", ".." }
      Dim tasks As New List(Of Task)()
      For Each dirName In dirNames 
         Dim t As Task = Task.Run( Sub()
                                      For Each path In Directory.GetFiles(dirName) 
                                         list.Add(path)
                                      Next
                                   End Sub  )
         tasks.Add(t)
      Next
      Task.WaitAll(tasks.ToArray())
      For Each t In tasks
         Console.WriteLine("Task {0} Status: {1}", t.Id, t.Status)
      Next   
      Console.WriteLine("Number of files read: {0}", list.Count)
   End Sub
End Module
' The example displays output like the following:
'       Task 1 Status: RanToCompletion
'       Task 2 Status: RanToCompletion
'       Number of files read: 23

Commenti

Questo costruttore deve essere utilizzato solo in scenari avanzati in cui è necessario che la creazione e l'avvio dell'attività siano separate.This constructor should only be used in advanced scenarios where it is required that the creation and starting of the task is separated.

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di Task un oggetto e avviare un'attività consiste nel chiamare il Task.Run(Action) metodo TaskFactory.StartNew(Action) statico o.Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static Task.Run(Action) or TaskFactory.StartNew(Action) method.

Se un'attività senza azione è necessaria solo per l'utente di un'API per avere qualcosa da attendere, è necessario TaskCompletionSource<TResult> usare un.If a task with no action is needed just for the consumer of an API to have something to await, a TaskCompletionSource<TResult> should be used.

Vedi anche

Task(Action, CancellationToken) Task(Action, CancellationToken) Task(Action, CancellationToken)

Inizializza un nuovo oggetto Task con l'azione specificata e CancellationToken.Initializes a new Task with the specified action and CancellationToken.

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

Parametri

action
Action Action Action Action

Delegato che rappresenta il codice da eseguire nell'attività.The delegate that represents the code to execute in the task.

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Oggetto CancellationToken che verrà considerato dalla nuova attività.The CancellationToken that the new task will observe.

Eccezioni

L'istanza CancellationToken fornita è già stata eliminata.The provided CancellationToken has already been disposed.

L'argomento action è Null.The action argument is null.

Esempi

Nell'esempio seguente viene chiamato Task(Action, CancellationToken) il costruttore per creare un'attività che consente di scorrere i file nella directory C:\Windows\System32The following example calls the Task(Action, CancellationToken) constructor to create a task that iterates the files in the C:\Windows\System32 directory. L'espressione lambda chiama il Parallel.ForEach metodo per aggiungere informazioni su ogni file a un List<T> oggetto.The lambda expression calls the Parallel.ForEach method to add information about each file to a List<T> object. Ogni attività annidata disconnessa richiamata Parallel.ForEach dal ciclo controlla lo stato del token di annullamento e, se viene richiesto l'annullamento, CancellationToken.ThrowIfCancellationRequested chiama il metodo.Each detached nested task invoked by the Parallel.ForEach loop checks the state of the cancellation token and, if cancellation is requested, calls the CancellationToken.ThrowIfCancellationRequested method. Il CancellationToken.ThrowIfCancellationRequested metodo genera un' OperationCanceledException eccezione che viene gestita in un catch blocco quando il thread chiamante chiama il Task.Wait metodo.The CancellationToken.ThrowIfCancellationRequested method throws an OperationCanceledException exception that is handled in a catch block when the calling thread calls the Task.Wait method. Il Start metodo viene quindi chiamato per avviare l'attività.The Start method is then called to start the task.

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

public class Example
{
   public static async Task Main()
   {
      var tokenSource = new CancellationTokenSource();
      var token = tokenSource.Token;
      var files = new List<Tuple<string, string, long, DateTime>>();
      
      var t = new Task(() => { string dir = "C:\\Windows\\System32\\";
                               object obj = new Object();
                               if (Directory.Exists(dir)) {
                                  Parallel.ForEach(Directory.GetFiles(dir),
                                  f => {
                                          if (token.IsCancellationRequested)
                                             token.ThrowIfCancellationRequested();
                                          var fi = new FileInfo(f);
                                          lock(obj) {
                                             files.Add(Tuple.Create(fi.Name, fi.DirectoryName, fi.Length, fi.LastWriteTimeUtc));          
                                          }
                                     });
                                }
                              } , token);
      t.Start();
      tokenSource.Cancel();
      try {
         await t; 
         Console.WriteLine("Retrieved information for {0} files.", files.Count);
      }
      catch (AggregateException e) {
         Console.WriteLine("Exception messages:");
         foreach (var ie in e.InnerExceptions)
            Console.WriteLine("   {0}: {1}", ie.GetType().Name, ie.Message);

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

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

Commenti

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di Task un oggetto e avviare un'attività consiste nel chiamare i Task.Run(Action, CancellationToken) metodi TaskFactory.StartNew(Action, CancellationToken) e statici.Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static Task.Run(Action, CancellationToken) and TaskFactory.StartNew(Action, CancellationToken) methods. L'unico vantaggio offerto da questo costruttore è che consente di separare la creazione di istanze degli oggetti dalla chiamata dell'attività.The only advantage offered by this constructor is that it allows object instantiation to be separated from task invocation.

Per altre informazioni, vedere parallelismo delle attività (Task Parallel Library) e annullamento nei thread gestiti.For more information, see Task Parallelism (Task Parallel Library) and Cancellation in Managed Threads.

Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions)

Inizializza un nuovo oggetto Task con l'azione e le opzioni di creazione specificate.Initializes a new Task with the specified action and creation options.

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

Parametri

action
Action Action Action Action

Delegato che rappresenta il codice da eseguire nell'attività.The delegate that represents the code to execute in the task.

creationOptions
TaskCreationOptions TaskCreationOptions TaskCreationOptions TaskCreationOptions

Oggetto TaskCreationOptions utilizzato per personalizzare il comportamento dell'attività.The TaskCreationOptions used to customize the task's behavior.

Eccezioni

L'argomento action è Null.The action argument is null.

L'argomento creationOptions specifica un valore non valido per TaskCreationOptions.The creationOptions argument specifies an invalid value for TaskCreationOptions.

Commenti

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di Task un oggetto e avviare un'attività consiste nel chiamare il TaskFactory.StartNew(Action, TaskCreationOptions) metodo statico.Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static TaskFactory.StartNew(Action, TaskCreationOptions) method. L'unico vantaggio offerto da questo costruttore è che consente di separare la creazione di istanze degli oggetti dalla chiamata dell'attività.The only advantage offered by this constructor is that it allows object instantiation to be separated from task invocation.

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

Inizializza un nuovo oggetto Task con l'azione e lo stato specificati.Initializes a new Task with the specified action and state.

public:
 Task(Action<System::Object ^> ^ action, System::Object ^ state);
public Task (Action<object> action, object state);
new System.Threading.Tasks.Task : Action<obj> * obj -> System.Threading.Tasks.Task
Public Sub New (action As Action(Of Object), state As Object)

Parametri

action
Action<Object>

Delegato che rappresenta il codice da eseguire nell'attività.The delegate that represents the code to execute in the task.

state
Object Object Object Object

Oggetto che rappresenta i dati che devono essere utilizzati dall'azione.An object representing data to be used by the action.

Eccezioni

L'argomento action è Null.The action argument is null.

Esempi

Nell'esempio seguente viene definita una matrice di parole di 6 lettere.The following example defines an array of 6-letter words. Ogni parola viene quindi passata come argomento al Task(Action<Object>, Object) costruttore, i cui Action<T> delegati comprimono i caratteri della parola, quindi Visualizza la parola originale e la relativa versione codificata.Each word is then passed as an argument to the Task(Action<Object>, Object) constructor, whose Action<T> delegate scrambles the characters in the word, then displays the original word and its scrambled version.

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

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

      foreach (var word6 in words6) {
         Task t = new Task( (word) => { Char[] chars = word.ToString().ToCharArray();
                                        double[] order = new double[chars.Length];
                                        lock (lockObj) {
                                           for (int ctr = 0; ctr < order.Length; ctr++)
                                              order[ctr] = rnd.NextDouble();
                                           }
                                        Array.Sort(order, chars);
                                        Console.WriteLine("{0} --> {1}", word,
                                                          new String(chars));
                                      }, word6);
         t.Start();
         tasks.Add(t);
      }
      await Task.WhenAll(tasks.ToArray());
   }
}
// The example displays output like the following:
//    regain --> irnaeg
//    ordain --> rioadn
//    reason --> soearn
//    rained --> rinade
//    rioter --> itrore
//    senior --> norise
//    rental --> atnerl
//    editor --> oteird
Imports System.Collections.Generic
Imports System.Threading.Tasks

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

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

Commenti

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di Task un oggetto e avviare un'attività consiste nel chiamare il TaskFactory.StartNew(Action<Object>, Object) metodo statico.Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static TaskFactory.StartNew(Action<Object>, Object) method. L'unico vantaggio offerto da questo costruttore è che consente di separare la creazione di istanze degli oggetti dalla chiamata dell'attività.The only advantage offered by this constructor is that it allows object instantiation to be separated from task invocation.

Vedi anche

Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions)

Inizializza un nuovo oggetto Task con l'azione e le opzioni di creazione specificate.Initializes a new Task with the specified action and creation options.

public:
 Task(Action ^ action, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions);
public Task (Action action, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions);
new System.Threading.Tasks.Task : Action * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Parametri

action
Action Action Action Action

Delegato che rappresenta il codice da eseguire nell'attività.The delegate that represents the code to execute in the task.

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Oggetto CancellationToken che verrà considerato dalla nuova attività.The CancellationToken that the new task will observe.

creationOptions
TaskCreationOptions TaskCreationOptions TaskCreationOptions TaskCreationOptions

Oggetto TaskCreationOptions utilizzato per personalizzare il comportamento dell'attività.The TaskCreationOptions used to customize the task's behavior.

Eccezioni

L'oggetto CancellationTokenSource che ha creato cancellationToken è già stato eliminato.The CancellationTokenSource that created cancellationToken has already been disposed.

L'argomento action è Null.The action argument is null.

L'argomento creationOptions specifica un valore non valido per TaskCreationOptions.The creationOptions argument specifies an invalid value for TaskCreationOptions.

Commenti

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di Task un oggetto e avviare un'attività consiste nel chiamare il TaskFactory.StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler) metodo statico.Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static TaskFactory.StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler) method. L'unico vantaggio offerto da questo costruttore è che consente di separare la creazione di istanze degli oggetti dalla chiamata dell'attività.The only advantage offered by this constructor is that it allows object instantiation to be separated from task invocation.

Per ulteriori informazioni, vedere Task parallelism (Task Parallel Library) e annullamento delle attività.For more information, see Task Parallelism (Task Parallel Library) and Task Cancellation.

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

Inizializza un nuovo oggetto Task con l'azione, lo stato e le opzioni specificati.Initializes a new Task with the specified action, state, and options.

public:
 Task(Action<System::Object ^> ^ action, System::Object ^ state, System::Threading::CancellationToken cancellationToken);
public Task (Action<object> action, object state, System.Threading.CancellationToken cancellationToken);
new System.Threading.Tasks.Task : Action<obj> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Parametri

action
Action<Object>

Delegato che rappresenta il codice da eseguire nell'attività.The delegate that represents the code to execute in the task.

state
Object Object Object Object

Oggetto che rappresenta i dati che devono essere utilizzati dall'azione.An object representing data to be used by the action.

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Oggetto CancellationToken che verrà considerato dalla nuova attività.The CancellationToken that the new task will observe.

Eccezioni

L'oggetto CancellationTokenSource che ha creato cancellationToken è già stato eliminato.The CancellationTokenSource that created cancellationToken has already been disposed.

L'argomento action è Null.The action argument is null.

Commenti

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di Task un oggetto e avviare un'attività consiste nel chiamare il TaskFactory.StartNew(Action<Object>, Object, CancellationToken) metodo statico.Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static TaskFactory.StartNew(Action<Object>, Object, CancellationToken) method. L'unico vantaggio offerto da questo costruttore è che consente di separare la creazione di istanze degli oggetti dalla chiamata dell'attività.The only advantage offered by this constructor is that it allows object instantiation to be separated from task invocation.

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

Inizializza un nuovo oggetto Task con l'azione, lo stato e le opzioni specificati.Initializes a new Task with the specified action, state, and options.

public:
 Task(Action<System::Object ^> ^ action, System::Object ^ state, System::Threading::Tasks::TaskCreationOptions creationOptions);
public Task (Action<object> action, object state, System.Threading.Tasks.TaskCreationOptions creationOptions);
new System.Threading.Tasks.Task : Action<obj> * obj * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task
Public Sub New (action As Action(Of Object), state As Object, creationOptions As TaskCreationOptions)

Parametri

action
Action<Object>

Delegato che rappresenta il codice da eseguire nell'attività.The delegate that represents the code to execute in the task.

state
Object Object Object Object

Oggetto che rappresenta i dati che devono essere utilizzati dall'azione.An object representing data to be used by the action.

creationOptions
TaskCreationOptions TaskCreationOptions TaskCreationOptions TaskCreationOptions

Oggetto TaskCreationOptions utilizzato per personalizzare il comportamento dell'attività.The TaskCreationOptions used to customize the task's behavior.

Eccezioni

L'argomento action è Null.The action argument is null.

L'argomento creationOptions specifica un valore non valido per TaskCreationOptions.The creationOptions argument specifies an invalid value for TaskCreationOptions.

Commenti

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di Task un oggetto e avviare un'attività consiste nel chiamare il TaskFactory.StartNew(Action<Object>, Object, TaskCreationOptions) metodo statico.Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static TaskFactory.StartNew(Action<Object>, Object, TaskCreationOptions) method. L'unico vantaggio offerto da questo costruttore è che consente di separare la creazione di istanze degli oggetti dalla chiamata dell'attività.The only advantage offered by this constructor is that it allows object instantiation to be separated from task invocation.

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

Inizializza un nuovo oggetto Task con l'azione, lo stato e le opzioni specificati.Initializes a new Task with the specified action, state, and options.

public:
 Task(Action<System::Object ^> ^ action, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskCreationOptions creationOptions);
public Task (Action<object> action, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions);
new System.Threading.Tasks.Task : Action<obj> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Parametri

action
Action<Object>

Delegato che rappresenta il codice da eseguire nell'attività.The delegate that represents the code to execute in the task.

state
Object Object Object Object

Oggetto che rappresenta i dati che devono essere utilizzati dall'azione.An object representing data to be used by the action.

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Oggetto CancellationToken che verrà considerato dalla nuova attività.The CancellationToken that the new task will observe.

creationOptions
TaskCreationOptions TaskCreationOptions TaskCreationOptions TaskCreationOptions

Oggetto TaskCreationOptions utilizzato per personalizzare il comportamento dell'attività.The TaskCreationOptions used to customize the task's behavior.

Eccezioni

L'oggetto CancellationTokenSource che ha creato cancellationToken è già stato eliminato.The CancellationTokenSource that created cancellationToken has already been disposed.

L'argomento action è Null.The action argument is null.

L'argomento creationOptions specifica un valore non valido per TaskCreationOptions.The creationOptions argument specifies an invalid value for TaskCreationOptions.

Commenti

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di Task un oggetto e avviare un'attività consiste nel chiamare il TaskFactory.StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler) metodo statico.Rather than calling this constructor, the most common way to instantiate a Task object and launch a task is by calling the static TaskFactory.StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler) method. L'unico vantaggio offerto da questo costruttore è che consente di separare la creazione di istanze degli oggetti dalla chiamata dell'attività.The only advantage offered by this constructor is that it allows object instantiation to be separated from task invocation.

Si applica a