Task Costruttori

Riferimento

Definizione

Spazio dei nomi:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Inizializza un nuovo oggetto Task.

Overload

Task(Action)	Inizializza un nuovo oggetto Task con l'azione specificata.
Task(Action, CancellationToken)	Inizializza un nuovo oggetto Task con l'azione specificata e CancellationToken.
Task(Action, TaskCreationOptions)	Inizializza un nuovo oggetto Task con l'azione e le opzioni di creazione specificate.
Task(Action<Object>, Object)	Inizializza un nuovo oggetto Task con l'azione e lo stato specificati.
Task(Action, CancellationToken, TaskCreationOptions)	Inizializza un nuovo oggetto Task con l'azione e le opzioni di creazione specificate.
Task(Action<Object>, Object, CancellationToken)	Inizializza un nuovo Task oggetto con l'azione, lo stato e CancellationToken.
Task(Action<Object>, Object, TaskCreationOptions)	Inizializza un nuovo oggetto Task con l'azione, lo stato e le opzioni specificati.
Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)	Inizializza un nuovo oggetto Task con l'azione, lo stato e le opzioni specificati.

Task(Action)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Inizializza un nuovo oggetto Task con l'azione specificata.

public:
 Task(Action ^ action);

public Task (Action action);

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

Public Sub New (action As Action)

Parametri

action: Action

Delegato che rappresenta il codice da eseguire nell'attività.

Eccezioni

ArgumentNullException

Il valore dell'argomento action è null.

Esempio

Nell'esempio seguente viene usato il Task(Action) costruttore per creare attività che recuperano i file nelle directory specificate. Tutte le attività scrivono i nomi dei file in un singolo ConcurrentBag<T> oggetto. Nell'esempio viene quindi chiamato il WaitAll(Task[]) metodo per assicurarsi che tutte le attività siano state completate e quindi visualizzi un conteggio del numero totale di nomi di file scritti nell'oggetto ConcurrentBag<T> .

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

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

open System.Collections.Concurrent
open System.IO
open System.Threading.Tasks

let main =
    task {
        let list = ConcurrentBag<string>()
        let dirNames = [ "."; ".." ]
        let tasks = ResizeArray()

        for dirName in dirNames do
            let t =
                new Task(fun () ->
                    for path in Directory.GetFiles dirName do
                        list.Add path)

            tasks.Add t
            t.Start()

        do! tasks.ToArray() |> Task.WhenAll

        for t in tasks do
            printfn $"Task {t.Id} Status: {t.Status}"

        printfn $"Number of files read: {list.Count}"
    }

// The example displays output like the following:
//       Task 1 Status: RanToCompletion
//       Task 2 Status: RanToCompletion
//       Number of files read: 23

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

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

L'esempio seguente è identico, ad eccezione del fatto che ha usato il Run(Action) metodo per creare un'istanza ed eseguire l'attività in una singola operazione. Il metodo restituisce l'oggetto che rappresenta l'attività 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

open System.Collections.Concurrent
open System.IO
open System.Threading.Tasks

let list = ConcurrentBag<string>()
let dirNames = [ "."; ".." ]
let tasks = ResizeArray()

for dirName in dirNames do
    let t =
        Task.Run(fun () ->
            for path in Directory.GetFiles dirName do
                list.Add path)

    tasks.Add t

tasks.ToArray() |> Task.WaitAll

for t in tasks do
    printfn $"Task {t.Id} Status: {t.Status}"

printfn $"Number of files read: {list.Count}"

// The example displays output like the following:
//       Task 1 Status: RanToCompletion
//       Task 2 Status: RanToCompletion
//       Number of files read: 23

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

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

Commenti

Questo costruttore deve essere usato solo negli scenari avanzati in cui è necessario che la creazione e l'avvio dell'attività siano separati.

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di un oggetto e avviare un'attività Task consiste nel chiamare il metodo o TaskFactory.StartNew(Action) staticoTask.Run(Action).

Se un'attività senza alcuna azione è necessaria solo per il consumer di un'API per avere qualcosa da attendere, deve essere usato un oggetto TaskCompletionSource<TResult> .

Vedi anche

Run(Action)

Si applica a

Task(Action, CancellationToken)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Inizializza un nuovo oggetto Task con l'azione specificata e CancellationToken.

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

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

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

Public Sub New (action As Action, cancellationToken As CancellationToken)

Parametri

action: Action

Delegato che rappresenta il codice da eseguire nell'attività.

cancellationToken: CancellationToken

Oggetto CancellationToken che verrà considerato dalla nuova attività.

Eccezioni

ObjectDisposedException

Provider CancellationToken già eliminato.

ArgumentNullException

L'argomento action è Null.

Esempio

Nell'esempio seguente viene chiamato il Task(Action, CancellationToken) costruttore per creare un'attività che esegue l'iterazione dei file nella directory C:\Windows\System32. L'espressione lambda chiama il Parallel.ForEach metodo per aggiungere informazioni su ogni file a un List<T> oggetto. Ogni attività annidata scollegata richiamata dal Parallel.ForEach ciclo controlla lo stato del token di annullamento e, se viene richiesto l'annullamento, chiama il CancellationToken.ThrowIfCancellationRequested metodo. Il CancellationToken.ThrowIfCancellationRequested metodo genera un'eccezione OperationCanceledException gestita in un catch blocco quando il thread chiamante chiama il Task.Wait metodo . Il Start metodo viene quindi chiamato per avviare l'attività.

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

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

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

open System
open System.IO
open System.Threading
open System.Threading.Tasks

let main =
    task {
        use tokenSource = new CancellationTokenSource()
        let token = tokenSource.Token
        let files = ResizeArray()

        let t =
            new Task(
                (fun () ->
                    let dir = @"C:\Windows\System32\"
                    let obj = obj ()

                    if Directory.Exists dir then
                        Parallel.ForEach(
                            Directory.GetFiles dir,
                            fun f ->
                                if token.IsCancellationRequested then
                                    token.ThrowIfCancellationRequested()

                                let fi = FileInfo f
                                lock obj (fun () -> files.Add(fi.Name, fi.DirectoryName, fi.Length, fi.LastWriteTimeUtc))
                        )
                        |> ignore),
                token
            )

        t.Start()
        tokenSource.Cancel()

        try
            do! t
            printfn $"Retrieved information for {files.Count} files."

        with :? AggregateException as e ->
            printfn "Exception messages:"

            for ie in e.InnerExceptions do
                printfn $"   {ie.GetType().Name}: {ie.Message}"

            printfn $"Task status: {t.Status}"
    }

main.Wait()

// The example displays the following output:
//       Exception messages:
//          TaskCanceledException: A task was canceled.
//
//       Task status: Canceled

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

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

Commenti

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di un oggetto e avviare un'attività Task consiste nel chiamare i metodi e TaskFactory.StartNew(Action, CancellationToken) staticiTask.Run(Action, CancellationToken). L'unico vantaggio offerto da questo costruttore è che consente di separare l'istanza dell'oggetto dalla chiamata all'attività.

Per altre informazioni, vedere Task Parallelism (Task Parallel Library) e Annullamento nei thread gestiti.

Si applica a

Task(Action, TaskCreationOptions)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Inizializza un nuovo oggetto Task con l'azione e le opzioni di creazione specificate.

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

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

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

Public Sub New (action As Action, creationOptions As TaskCreationOptions)

Parametri

action: Action

Delegato che rappresenta il codice da eseguire nell'attività.

creationOptions: TaskCreationOptions

Oggetto TaskCreationOptions usato per personalizzare il comportamento dell'attività.

Eccezioni

ArgumentNullException

L'argomento action è Null.

ArgumentOutOfRangeException

L'argomento creationOptions specifica un valore non valido per TaskCreationOptions.

Commenti

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di un oggetto e avviare un'attività Task consiste nel chiamare il metodo statico TaskFactory.StartNew(Action, TaskCreationOptions) . L'unico vantaggio offerto da questo costruttore è che consente di separare l'istanza dell'oggetto dalla chiamata all'attività.

Si applica a

Task(Action<Object>, Object)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Inizializza un nuovo oggetto Task con l'azione e lo stato specificati.

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

public Task (Action<object> action, object state);

public Task (Action<object?> action, object? state);

new System.Threading.Tasks.Task : Action<obj> * obj -> System.Threading.Tasks.Task

Public Sub New (action As Action(Of Object), state As Object)

Parametri

action: Action<Object>

Delegato che rappresenta il codice da eseguire nell'attività.

state: Object

Oggetto che rappresenta i dati che devono essere utilizzati dall'azione.

Eccezioni

ArgumentNullException

L'argomento action è Null.

Esempio

Nell'esempio seguente viene definita una matrice di parole di 6 lettere. Ogni parola viene quindi passata come argomento al Task(Action<Object>, Object) costruttore, il cui Action<T> delegato scramblesa i caratteri nella parola, quindi visualizza la parola originale e la relativa versione di scrambled.

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

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

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

open System
open System.Threading.Tasks

let main =
    task {
        let tasks = ResizeArray()
        let rnd = Random()
        let lockObj = obj ()

        let words6 =
            [ "reason"
              "editor"
              "rioter"
              "rental"
              "senior"
              "regain"
              "ordain"
              "rained" ]

        for word6 in words6 do
            let t =
                new Task(
                    (fun word ->
                        let chars = (string word).ToCharArray()
                        let order = Array.zeroCreate<double> chars.Length

                        lock lockObj (fun () ->
                            for i = 0 to order.Length - 1 do
                                order[i] <- rnd.NextDouble())

                        Array.Sort(order, chars)
                        printfn $"{word} --> {new String(chars)}"),
                    word6
                )

            t.Start()
            tasks.Add t

        do! tasks.ToArray() |> Task.WhenAll
    }

main.Wait()

// The example displays output like the following:
//    regain --> irnaeg
//    ordain --> rioadn
//    reason --> soearn
//    rained --> rinade
//    rioter --> itrore
//    senior --> norise
//    rental --> atnerl
//    editor --> oteird

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

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

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

Commenti

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di un oggetto e avviare un'attività Task consiste nel chiamare il metodo statico TaskFactory.StartNew(Action<Object>, Object) . L'unico vantaggio offerto da questo costruttore è che consente di separare l'istanza dell'oggetto dalla chiamata all'attività.

Vedi anche

StartNew(Action<Object>, Object)

Si applica a

Task(Action, CancellationToken, TaskCreationOptions)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Inizializza un nuovo oggetto Task con l'azione e le opzioni di creazione specificate.

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

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

new System.Threading.Tasks.Task : Action * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Sub New (action As Action, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions)

Parametri

action: Action

Delegato che rappresenta il codice da eseguire nell'attività.

cancellationToken: CancellationToken

Oggetto CancellationToken che verrà considerato dalla nuova attività.

creationOptions: TaskCreationOptions

Oggetto TaskCreationOptions usato per personalizzare il comportamento dell'attività.

Eccezioni

ObjectDisposedException

L'oggetto CancellationTokenSource che ha creato cancellationToken è già stato eliminato.

ArgumentNullException

L'argomento action è Null.

ArgumentOutOfRangeException

L'argomento creationOptions specifica un valore non valido per TaskCreationOptions.

Commenti

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di un oggetto e avviare un'attività Task consiste nel chiamare il metodo statico TaskFactory.StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler) . L'unico vantaggio offerto da questo costruttore è che consente di separare l'istanza dell'oggetto dalla chiamata all'attività.

Per altre informazioni, vedere Task Parallelism (Task Parallel Library) e Annullamento attività.

Si applica a

Task(Action<Object>, Object, CancellationToken)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Inizializza un nuovo Task oggetto con l'azione, lo stato e CancellationToken.

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

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

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

new System.Threading.Tasks.Task : Action<obj> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Sub New (action As Action(Of Object), state As Object, cancellationToken As CancellationToken)

Parametri

action: Action<Object>

Delegato che rappresenta il codice da eseguire nell'attività.

state: Object

Oggetto che rappresenta i dati che devono essere utilizzati dall'azione.

cancellationToken: CancellationToken

Oggetto CancellationToken che verrà considerato dalla nuova attività.

Eccezioni

ObjectDisposedException

L'oggetto CancellationTokenSource che ha creato cancellationToken è già stato eliminato.

ArgumentNullException

L'argomento action è Null.

Commenti

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di un oggetto e avviare un'attività Task consiste nel chiamare il metodo statico TaskFactory.StartNew(Action<Object>, Object, CancellationToken) . L'unico vantaggio offerto da questo costruttore è che consente di separare l'istanza dell'oggetto dalla chiamata all'attività.

Si applica a

Task(Action<Object>, Object, TaskCreationOptions)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Inizializza un nuovo oggetto Task con l'azione, lo stato e le opzioni specificati.

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

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

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

new System.Threading.Tasks.Task : Action<obj> * obj * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Sub New (action As Action(Of Object), state As Object, creationOptions As TaskCreationOptions)

Parametri

action: Action<Object>

Delegato che rappresenta il codice da eseguire nell'attività.

state: Object

Oggetto che rappresenta i dati che devono essere usati dall'azione.

creationOptions: TaskCreationOptions

Oggetto TaskCreationOptions usato per personalizzare il comportamento dell'attività.

Eccezioni

ArgumentNullException

L'argomento action è Null.

ArgumentOutOfRangeException

L'argomento creationOptions specifica un valore non valido per TaskCreationOptions.

Commenti

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di un oggetto e avviare un'attività Task consiste nel chiamare il metodo statico TaskFactory.StartNew(Action<Object>, Object, TaskCreationOptions) . L'unico vantaggio offerto da questo costruttore è che consente di separare l'istanza dell'oggetto dalla chiamata all'attività.

Si applica a

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Inizializza un nuovo oggetto Task con l'azione, lo stato e le opzioni specificati.

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

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

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

new System.Threading.Tasks.Task : Action<obj> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskCreationOptions -> System.Threading.Tasks.Task

Public Sub New (action As Action(Of Object), state As Object, cancellationToken As CancellationToken, creationOptions As TaskCreationOptions)

Parametri

action: Action<Object>

Delegato che rappresenta il codice da eseguire nell'attività.

state: Object

Oggetto che rappresenta i dati che devono essere utilizzati dall'azione.

cancellationToken: CancellationToken

Oggetto CancellationToken che verrà considerato dalla nuova attività.

creationOptions: TaskCreationOptions

Oggetto TaskCreationOptions usato per personalizzare il comportamento dell'attività.

Eccezioni

ObjectDisposedException

L'oggetto CancellationTokenSource che ha creato cancellationToken è già stato eliminato.

ArgumentNullException

L'argomento action è Null.

ArgumentOutOfRangeException

L'argomento creationOptions specifica un valore non valido per TaskCreationOptions.

Commenti

Anziché chiamare questo costruttore, il modo più comune per creare un'istanza di un oggetto e avviare un'attività Task consiste nel chiamare il metodo statico TaskFactory.StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler) . L'unico vantaggio offerto da questo costruttore è che consente di separare l'istanza dell'oggetto dalla chiamata all'attività.

Si applica a

Condividi tramite

Task Costruttori

Definizione

Overload

Task(Action)

Parametri

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

Task(Action, CancellationToken)

Parametri

Eccezioni

Esempio

Commenti

Si applica a

Task(Action, TaskCreationOptions)

Parametri

Eccezioni

Commenti

Si applica a

Task(Action<Object>, Object)

Parametri

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

Task(Action, CancellationToken, TaskCreationOptions)

Parametri

Eccezioni

Commenti

Si applica a

Task(Action<Object>, Object, CancellationToken)

Parametri

Eccezioni

Commenti

Si applica a

Task(Action<Object>, Object, TaskCreationOptions)

Parametri

Eccezioni

Commenti

Si applica a

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

Parametri

Eccezioni

Commenti

Si applica a

Risorse aggiuntive