Task Constructores

Referencia

Definición

Espacio de nombres:: System.Threading.Tasks

Ensamblado:: System.Threading.Tasks.dll

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Inicializa un nuevo objeto Task.

Sobrecargas

Task(Action)	Inicializa una nueva instancia de Task con la acción especificada.
Task(Action, CancellationToken)	Inicializa una nueva instancia de Task con la acción especificada y CancellationToken.
Task(Action, TaskCreationOptions)	Inicializa un nuevo objeto Task con la acción y las opciones de creación especificadas.
Task(Action<Object>, Object)	Inicializa una nueva instancia de Task con la acción y el estado especificados.
Task(Action, CancellationToken, TaskCreationOptions)	Inicializa un nuevo objeto Task con la acción y las opciones de creación especificadas.
Task(Action<Object>, Object, CancellationToken)	Inicializa un nuevo Task objeto con la acción, el estado y CancellationTokenespecificados.
Task(Action<Object>, Object, TaskCreationOptions)	Inicializa un nuevo objeto Task con la acción, el estado y las opciones especificados.
Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)	Inicializa un nuevo objeto Task con la acción, el estado y las opciones especificados.

Task(Action)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializa una nueva instancia de Task con la acción especificada.

public:
 Task(Action ^ action);

public Task (Action action);

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

Public Sub New (action As Action)

Parámetros

action: Action

Delegado que representa el código que se va a ejecutar en la tarea.

Excepciones

ArgumentNullException

El argumento action es null.

Ejemplos

En el ejemplo siguiente se usa el Task(Action) constructor para crear tareas que recuperan los nombres de archivo en directorios especificados. Todas las tareas escriben los nombres de archivo en un solo ConcurrentBag<T> objeto. A continuación, el ejemplo llama al WaitAll(Task[]) método para asegurarse de que todas las tareas se han completado y, a continuación, muestra un recuento del número total de nombres de archivo escritos en el ConcurrentBag<T> objeto.

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

El ejemplo siguiente es idéntico, salvo que usó el Run(Action) método para crear instancias y ejecutar la tarea en una sola operación. El método devuelve el Task objeto que representa la tarea.

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

Comentarios

Este constructor solo se debe usar en escenarios avanzados en los que es necesario separar la creación y el inicio de la tarea.

En lugar de llamar a este constructor, la forma más común de crear una instancia de un Task objeto e iniciar una tarea es llamando al método o TaskFactory.StartNew(Action) estáticoTask.Run(Action).

Si solo se necesita una tarea sin ninguna acción para que el consumidor de una API tenga algo que esperar, se debe usar .TaskCompletionSource<TResult>

Consulte también

Run(Action)

Se aplica a

Task(Action, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializa una nueva instancia de Task con la acción especificada y 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)

Parámetros

action: Action

Delegado que representa el código que se va a ejecutar en la tarea.

cancellationToken: CancellationToken

El CancellationToken que observará la nueva tarea.

Excepciones

ObjectDisposedException

Ya se eliminó el CancellationToken proporcionado.

ArgumentNullException

El argumento action es null.

Ejemplos

En el ejemplo siguiente se llama al Task(Action, CancellationToken) constructor para crear una tarea que itera los archivos en el directorio C:\Windows\System32. La expresión lambda llama al Parallel.ForEach método para agregar información sobre cada archivo a un List<T> objeto . Cada tarea anidada desasociada invocada por el Parallel.ForEach bucle comprueba el estado del token de cancelación y, si se solicita la cancelación, llama al CancellationToken.ThrowIfCancellationRequested método . El CancellationToken.ThrowIfCancellationRequested método produce una OperationCanceledException excepción que se controla en un catch bloque cuando el subproceso que realiza la llamada llama al Task.Wait método . A Start continuación, se llama al método para iniciar la tarea.

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

Comentarios

En lugar de llamar a este constructor, la forma más común de crear una instancia de un Task objeto e iniciar una tarea es llamando a los métodos y TaskFactory.StartNew(Action, CancellationToken) estáticosTask.Run(Action, CancellationToken). La única ventaja que ofrece este constructor es que permite separar la creación de instancias de objetos de la invocación de tareas.

Para obtener más información, vea Paralelismo de tareas (biblioteca paralela de tareas) y cancelación en subprocesos administrados.

Se aplica a

Task(Action, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializa un nuevo objeto Task con la acción y las opciones de creación especificadas.

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)

Parámetros

action: Action

Delegado que representa el código que se va a ejecutar en la tarea.

creationOptions: TaskCreationOptions

El objeto TaskCreationOptions que se usa para personalizar el comportamiento de la tarea.

Excepciones

ArgumentNullException

El argumento action es null.

ArgumentOutOfRangeException

El argumento creationOptions especifica un valor no válido para TaskCreationOptions.

Comentarios

En lugar de llamar a este constructor, la forma más común de crear una instancia de un Task objeto e iniciar una tarea es llamando al método estático TaskFactory.StartNew(Action, TaskCreationOptions) . La única ventaja que ofrece este constructor es que permite separar la creación de instancias de objetos de la invocación de tareas.

Se aplica a

Task(Action<Object>, Object)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializa una nueva instancia de Task con la acción y el estado especificados.

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)

Parámetros

action: Action<Object>

Delegado que representa el código que se va a ejecutar en la tarea.

state: Object

Objeto que representa los datos que la acción va a usar.

Excepciones

ArgumentNullException

El argumento action es null.

Ejemplos

En el ejemplo siguiente se define una matriz de palabras de 6 letras. A continuación, cada palabra se pasa como argumento al Task(Action<Object>, Object) constructor, cuyo Action<T> delegado codifica los caracteres de la palabra y, a continuación, muestra la palabra original y su versión codificada.

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

Comentarios

En lugar de llamar a este constructor, la forma más común de crear una instancia de un Task objeto e iniciar una tarea es llamando al método estático TaskFactory.StartNew(Action<Object>, Object) . La única ventaja que ofrece este constructor es que permite separar la creación de instancias de objetos de la invocación de tareas.

Consulte también

StartNew(Action<Object>, Object)

Se aplica a

Task(Action, CancellationToken, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializa un nuevo objeto Task con la acción y las opciones de creación especificadas.

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)

Parámetros

action: Action

Delegado que representa el código que se va a ejecutar en la tarea.

cancellationToken: CancellationToken

El CancellationToken que observará la nueva tarea.

creationOptions: TaskCreationOptions

El objeto TaskCreationOptions que se usa para personalizar el comportamiento de la tarea.

Excepciones

ObjectDisposedException

El CancellationTokenSource que creó cancellationToken ya se ha eliminado.

ArgumentNullException

El argumento action es null.

ArgumentOutOfRangeException

El argumento creationOptions especifica un valor no válido para TaskCreationOptions.

Comentarios

En lugar de llamar a este constructor, la forma más común de crear una instancia de un Task objeto e iniciar una tarea es llamando al método estático TaskFactory.StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler) . La única ventaja que ofrece este constructor es que permite separar la creación de instancias de objetos de la invocación de tareas.

Para obtener más información, vea Paralelismo de tareas (Biblioteca de tareas paralelas) y Cancelación de tareas.

Se aplica a

Task(Action<Object>, Object, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializa un nuevo Task objeto con la acción, el estado y CancellationTokenespecificados.

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)

Parámetros

action: Action<Object>

Delegado que representa el código que se va a ejecutar en la tarea.

state: Object

Objeto que representa los datos que la acción va a usar.

cancellationToken: CancellationToken

CancellationToken que la nueva tarea observará.

Excepciones

ObjectDisposedException

El CancellationTokenSource que creó cancellationToken ya se ha eliminado.

ArgumentNullException

El argumento action es null.

Comentarios

En lugar de llamar a este constructor, la forma más común de crear una instancia de un Task objeto e iniciar una tarea es llamando al método estático TaskFactory.StartNew(Action<Object>, Object, CancellationToken) . La única ventaja que ofrece este constructor es que permite separar la creación de instancias de objetos de la invocación de tareas.

Se aplica a

Task(Action<Object>, Object, TaskCreationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializa un nuevo objeto Task con la acción, el estado y las opciones especificados.

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)

Parámetros

action: Action<Object>

Delegado que representa el código que se va a ejecutar en la tarea.

state: Object

Objeto que representa los datos que la acción va a usar.

creationOptions: TaskCreationOptions

El objeto TaskCreationOptions que se usa para personalizar el comportamiento de la tarea.

Excepciones

ArgumentNullException

El argumento action es null.

ArgumentOutOfRangeException

El argumento creationOptions especifica un valor no válido para TaskCreationOptions.

Comentarios

En lugar de llamar a este constructor, la forma más común de crear una instancia de un Task objeto e iniciar una tarea es llamando al método estático TaskFactory.StartNew(Action<Object>, Object, TaskCreationOptions) . La única ventaja que ofrece este constructor es que permite separar la creación de instancias de objetos de la invocación de tareas.

Se aplica a

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Inicializa un nuevo objeto Task con la acción, el estado y las opciones especificados.

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)

Parámetros

action: Action<Object>

Delegado que representa el código que se va a ejecutar en la tarea.

state: Object

Objeto que representa los datos que la acción va a usar.

cancellationToken: CancellationToken

CancellationToken que la nueva tarea observará.

creationOptions: TaskCreationOptions

El objeto TaskCreationOptions que se usa para personalizar el comportamiento de la tarea.

Excepciones

ObjectDisposedException

El CancellationTokenSource que creó cancellationToken ya se ha eliminado.

ArgumentNullException

El argumento action es null.

ArgumentOutOfRangeException

El argumento creationOptions especifica un valor no válido para TaskCreationOptions.

Comentarios

En lugar de llamar a este constructor, la forma más común de crear una instancia de un Task objeto e iniciar una tarea es llamando al método estático TaskFactory.StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler) . La única ventaja que ofrece este constructor es que permite separar la creación de instancias de objetos de la invocación de tareas.

Se aplica a

Compartir a través de

Task Constructores

Definición

Sobrecargas

Task(Action)

Parámetros

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Task(Action, CancellationToken)

Parámetros

Excepciones

Ejemplos

Comentarios

Se aplica a

Task(Action, TaskCreationOptions)

Parámetros

Excepciones

Comentarios

Se aplica a

Task(Action<Object>, Object)

Parámetros

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Task(Action, CancellationToken, TaskCreationOptions)

Parámetros

Excepciones

Comentarios

Se aplica a

Task(Action<Object>, Object, CancellationToken)

Parámetros

Excepciones

Comentarios

Se aplica a

Task(Action<Object>, Object, TaskCreationOptions)

Parámetros

Excepciones

Comentarios

Se aplica a

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

Parámetros

Excepciones

Comentarios

Se aplica a

Recursos adicionales