Aplicaciones de Windows
Collapse the table of content
Expand the table of content
Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés
Información
El tema que ha solicitado se muestra abajo. Sin embargo, este tema no se encuentra en la biblioteca.

Clase Task

 

Publicado: octubre de 2016

Representa una operación asincrónica.

Para examinar el código fuente de .NET Framework para este tipo, vea la Reference Source.

Espacio de nombres:   System.Threading.Tasks
Ensamblado:  mscorlib (en mscorlib.dll)


[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public class Task : IAsyncResult, IDisposable

NombreDescripción
System_CAPS_pubmethodTask(Action)

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

System_CAPS_pubmethodTask(Action, CancellationToken)

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

System_CAPS_pubmethodTask(Action, CancellationToken, TaskCreationOptions)

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

System_CAPS_pubmethodTask(Action, TaskCreationOptions)

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

System_CAPS_pubmethodTask(Action<Object>, Object)

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

System_CAPS_pubmethodTask(Action<Object>, Object, CancellationToken)

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

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

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

System_CAPS_pubmethodTask(Action<Object>, Object, TaskCreationOptions)

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

NombreDescripción
System_CAPS_pubpropertyAsyncState

Obtiene el objeto de estado que se proporcionó al crearse el objeto Task, o null si no se proporcionó ningún objeto de estado.

System_CAPS_pubpropertySystem_CAPS_staticCompletedTask

Obtiene una tarea que ya ha finalizado correctamente.

System_CAPS_pubpropertyCreationOptions

Obtiene el objeto TaskCreationOptions usado para crear esta tarea.

System_CAPS_pubpropertySystem_CAPS_staticCurrentId

Devuelve el identificador del objeto Task que se está ejecutando actualmente.

System_CAPS_pubpropertyException

Obtiene la excepción AggregateException que causó la finalización prematura del objeto Task. Si Task se completó correctamente o no ha iniciado ninguna excepción, el valor devuelto será null.

System_CAPS_pubpropertySystem_CAPS_staticFactory

Proporciona acceso a patrones de diseño para crear y configurar instancias de Task y Task<TResult>.

System_CAPS_pubpropertyId

Obtiene un identificador para esta instancia de Task.

System_CAPS_pubpropertyIsCanceled

Obtiene un valor que indica si esta instancia de Task ha completado su ejecución debido a una cancelación.

System_CAPS_pubpropertyIsCompleted

Obtiene un valor que indica si se ha completado esta instancia de Task.

System_CAPS_pubpropertyIsFaulted

Obtiene un valor que indica si el objeto Task se ha completado debido a una excepción no controlada.

System_CAPS_pubpropertyStatus

Obtiene el objeto TaskStatus de esta tarea.

NombreDescripción
System_CAPS_pubmethodConfigureAwait(Boolean)

Configura un awaiter utilizado para esperar a este objeto Task.

System_CAPS_pubmethodContinueWith(Action<Task, Object>, Object)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta cuando el elemento Task de destino se completa.

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

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y un token de cancelación y que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa.

System_CAPS_pubmethodContinueWith(Action<Task, Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y un token de cancelación y que se ejecuta cuando el elemento Task de destino se completa. La continuación se ejecuta según un conjunto de condiciones especificadas y usa un programador especificado.

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

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta cuando el elemento Task de destino se completa. La continuación se ejecuta según un conjunto de condiciones especificadas.

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

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta de forma asincrónica cuando el elemento Task de destino se completa. La continuación usa un programador especificado.

System_CAPS_pubmethodContinueWith(Action<Task>)

Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino.

System_CAPS_pubmethodContinueWith(Action<Task>, CancellationToken)

Crea una continuación que recibe un token de cancelación y se ejecuta de forma asincrónica cuando el elemento Task de destino se completa.

System_CAPS_pubmethodContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que se ejecuta cuando se completa la tarea de destino según el elemento TaskContinuationOptions especificado. La continuación recibe un token de cancelación y usa un programador especificado.

System_CAPS_pubmethodContinueWith(Action<Task>, TaskContinuationOptions)

Crea una continuación que se ejecuta cuando se completa la tarea de destino según el elemento TaskContinuationOptions especificado.

System_CAPS_pubmethodContinueWith(Action<Task>, TaskScheduler)

Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino. La continuación usa un programador especificado.

System_CAPS_pubmethodContinueWith<TResult>(Func<Task, TResult>)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task<TResult> de destino se completa y devuelve un valor.

System_CAPS_pubmethodContinueWith<TResult>(Func<Task, TResult>, CancellationToken)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor. La continuación recibe un token de cancelación.

System_CAPS_pubmethodContinueWith<TResult>(Func<Task, TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que se ejecuta según las opciones de continuación especificadas y devuelve un valor. Se pasa un token de cancelación a la continuación y usa un programador especificado.

System_CAPS_pubmethodContinueWith<TResult>(Func<Task, TResult>, TaskContinuationOptions)

Crea una continuación que se ejecuta según las opciones de continuación especificadas y devuelve un valor.

System_CAPS_pubmethodContinueWith<TResult>(Func<Task, TResult>, TaskScheduler)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor. La continuación usa un programador especificado.

System_CAPS_pubmethodContinueWith<TResult>(Func<Task, Object, TResult>, Object)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor.

System_CAPS_pubmethodContinueWith<TResult>(Func<Task, Object, TResult>, Object, CancellationToken)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor. La continuación recibe información de estado proporcionada por el autor de la llamada y un token de cancelación.

System_CAPS_pubmethodContinueWith<TResult>(Func<Task, Object, TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que se ejecuta según las opciones de continuación de la tarea especificadas cuando el elemento Task de destino se completa y devuelve un valor. La continuación recibe información de estado proporcionada por el autor de la llamada y un token de cancelación y usa el programador especificado.

System_CAPS_pubmethodContinueWith<TResult>(Func<Task, Object, TResult>, Object, TaskContinuationOptions)

Crea una continuación que se ejecuta según las opciones de continuación de la tarea especificadas cuando el elemento Task de destino se completa. La continuación recibe información de estado proporcionada por el autor de la llamada.

System_CAPS_pubmethodContinueWith<TResult>(Func<Task, Object, TResult>, Object, TaskScheduler)

Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino. La continuación recibe información de estado proporcionada por el autor de la llamada y usa a un programador especificado.

System_CAPS_pubmethodSystem_CAPS_staticDelay(Int32)

Crea una tarea que se completa después de un retraso.

System_CAPS_pubmethodSystem_CAPS_staticDelay(Int32, CancellationToken)

Crea una tarea cancelable que se completa después de un retraso.

System_CAPS_pubmethodSystem_CAPS_staticDelay(TimeSpan)

Crea una tarea que se completa después de un intervalo de tiempo especificado.

System_CAPS_pubmethodSystem_CAPS_staticDelay(TimeSpan, CancellationToken)

Crea una tarea cancelable que se completa después de un intervalo de tiempo específico.

System_CAPS_pubmethodDispose()

Libera todos los recursos usados por la instancia actual de la clase Task.

System_CAPS_protmethodDispose(Boolean)

Desecha el objeto Task y libera todos sus recursos no administrados.

System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_protmethodFinalize()

Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por el recolector de basura. (Heredado de Object).

System_CAPS_pubmethodSystem_CAPS_staticFromCanceled(CancellationToken)

Crea una Task que se finaliza debido a la cancelación con un token de cancelación especificado.

System_CAPS_pubmethodSystem_CAPS_staticFromCanceled<TResult>(CancellationToken)

Crea una Task<TResult> que se finaliza debido a la cancelación con un token de cancelación especificado.

System_CAPS_pubmethodSystem_CAPS_staticFromException(Exception)

Crea una Task que finalizó con una excepción especificada.

System_CAPS_pubmethodSystem_CAPS_staticFromException<TResult>(Exception)

Crea una Task<TResult> que finalizó con una excepción especificada.

System_CAPS_pubmethodSystem_CAPS_staticFromResult<TResult>(TResult)

Crea un objeto Task<TResult> que se ha completado correctamente con el resultado especificado.

System_CAPS_pubmethodGetAwaiter()

Obtiene un awaiter utilizado para esperar a este objeto Task.

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficial del Object actual.(Heredado de Object).

System_CAPS_pubmethodSystem_CAPS_staticRun(Action)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un objeto Task que representa ese trabajo.

System_CAPS_pubmethodSystem_CAPS_staticRun(Action, CancellationToken)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un objeto Task que representa ese trabajo. Un token de cancelación permite cancelar el trabajo.

System_CAPS_pubmethodSystem_CAPS_staticRun(Func<Task>)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un proxy para la tarea devuelta por function.

System_CAPS_pubmethodSystem_CAPS_staticRun(Func<Task>, CancellationToken)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un proxy para la tarea devuelta por function.

System_CAPS_pubmethodSystem_CAPS_staticRun<TResult>(Func<TResult>)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un objeto Task<TResult> que representa ese trabajo.

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

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un objeto Task(TResult) que representa ese trabajo. Un token de cancelación permite cancelar el trabajo.

System_CAPS_pubmethodSystem_CAPS_staticRun<TResult>(Func<Task<TResult>>)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un proxy para el Task(TResult) devuelto por function.

System_CAPS_pubmethodSystem_CAPS_staticRun<TResult>(Func<Task<TResult>>, CancellationToken)

Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un proxy para el Task(TResult) devuelto por function.

System_CAPS_pubmethodRunSynchronously()

Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler actual.

System_CAPS_pubmethodRunSynchronously(TaskScheduler)

Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler proporcionado.

System_CAPS_pubmethodStart()

Inicia el objeto Task, programando su ejecución en el objeto TaskScheduler actual.

System_CAPS_pubmethodStart(TaskScheduler)

Inicia el objeto Task, programando su ejecución en el objeto TaskScheduler especificado.

System_CAPS_pubmethodToString()

Devuelve una cadena que representa al objeto actual. (Heredado de Object).

System_CAPS_pubmethodWait()

Espera a que se complete la ejecución del objeto Task.

System_CAPS_pubmethodWait(CancellationToken)

Espera a que se complete la ejecución del objeto Task. La espera finalizará si un token de cancelación se cancela antes de que finalice la tarea.

System_CAPS_pubmethodWait(Int32)

Espera a que el objeto Task complete la ejecución dentro de un número especificado de milisegundos.

System_CAPS_pubmethodWait(Int32, CancellationToken)

Espera a que se complete la ejecución del objeto Task. La espera finalizará si transcurre un intervalo de tiempo de espera o un token de cancelación se cancela antes de que finalice la tarea.

System_CAPS_pubmethodWait(TimeSpan)

Espera a que Task complete la ejecución dentro de un intervalo de tiempo especificado.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[])

Espera que se complete la ejecución de todos los objetos Task proporcionados.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], CancellationToken)

Espera que se complete la ejecución de todos los objetos Task proporcionados, a menos que se cancele la espera.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], Int32)

Espera a que todos los objetos proporcionados de Task completen la ejecución dentro de un número especificado de milisegundos.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], Int32, CancellationToken)

Espera a que todos los objetos Task proporcionados completen la ejecución dentro de un número especificado de milisegundos o hasta que se cancele la espera.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], TimeSpan)

Espera a que todos los objetos Task cancelables que se hayan proporcionado completen la ejecución en un intervalo de tiempo especificado.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[])

Espera a que se complete la ejecución de cualquiera de los objetos Task proporcionados.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], CancellationToken)

Espera que se complete la ejecución de cualquiera de los objetos Task proporcionados, a menos que se cancele la espera.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], Int32)

Espera a que cualquiera de los objetos Task que se hayan proporcionado complete su ejecución dentro de un número especificado de milisegundos.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], Int32, CancellationToken)

Espera a que cualquiera de los objetos Task proporcionados complete la ejecución dentro de un número especificado de milisegundos o hasta que se cancele un token de cancelación.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], TimeSpan)

Espera a que se complete la ejecución de cualquier objeto Task proporcionado en un intervalo de tiempo especificado.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll(IEnumerable<Task>)

Crea una tarea que se completará cuando todos los objetos Task de una colección enumerable se hayan completado.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll(Task[])

Crea una tarea que se completará cuando todos los objetos Task de una matriz se hayan completado.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll<TResult>(IEnumerable<Task<TResult>>)

Crea una tarea que se completará cuando todos los objetos Task<TResult> de una colección enumerable se hayan completado.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll<TResult>(Task<TResult>[])

Crea una tarea que se completará cuando todos los objetos Task<TResult> de una matriz se hayan completado.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny(IEnumerable<Task>)

Crea una tarea que finalizará cuando se haya completado cualquiera de las tareas proporcionadas.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny(Task[])

Crea una tarea que finalizará cuando se haya completado cualquiera de las tareas proporcionadas.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny<TResult>(IEnumerable<Task<TResult>>)

Crea una tarea que finalizará cuando se haya completado cualquiera de las tareas proporcionadas.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny<TResult>(Task<TResult>[])

Crea una tarea que finalizará cuando se haya completado cualquiera de las tareas proporcionadas.

System_CAPS_pubmethodSystem_CAPS_staticYield()

Crea una tarea que admite "await" que, de forma asincrónica, devuelve al contexto actual cuando es "awaited".

NombreDescripción
System_CAPS_pubinterfaceSystem_CAPS_privpropertyIAsyncResult.AsyncWaitHandle

Obtiene un identificador WaitHandle que se puede usar para esperar a que se complete la tarea.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIAsyncResult.CompletedSynchronously

Obtiene un valor que indica si la operación se ha completado sincrónicamente.

NombreDescripción
System_CAPS_pubmethodDispatcherOperationWait()

Sobrecargado. Espera indefinidamente subyacente DispatcherOperation para completar.(Definido por TaskExtensions).

System_CAPS_pubmethodDispatcherOperationWait(TimeSpan)

Sobrecargado. Espera a que la cantidad especificada de tiempo subyacente DispatcherOperation para completar.(Definido por TaskExtensions).

System_CAPS_pubmethodIsDispatcherOperationTask()

Devuelve un valor que indica si este Task está asociado con un DispatcherOperation.(Definido por TaskExtensions).

System_CAPS_noteNota

Para ver el código fuente de .NET Framework para este tipo, consulte el Reference Source. Puede examinar el código fuente en línea, descargue la referencia para verla sin conexión y recorrer (incluidas las revisiones y actualizaciones) durante la depuración; see instructions.

La Task clase representa una única operación que no devuelve un valor y que normalmente se ejecuta de forma asincrónica. Task los objetos son uno de los componentes centrales de la modelo asincrónico basado en tareas se presentó por primera vez en .NET Framework 4. Dado que el trabajo realizado por un Task objeto normalmente ejecuta de forma asincrónica en un subproceso ThreadPool en lugar de forma sincrónica en el subproceso principal de la aplicación, puede utilizar el Status propiedad, así como el IsCanceled, IsCompleted, y IsFaulted Propiedades para determinar el estado de una tarea. Normalmente, se utiliza una expresión lambda para especificar el trabajo que debe realizar la tarea.

Para operaciones que devuelven valores, utilice la Task<TResult> clase.

En esta sección:

Crear y ejecutar una tarea
Separar la ejecución y la creación de tareas
Esperando completar las tareas de uno o más
Tareas y la referencia cultural
Para los desarrolladores de depurador

Task pueden crear instancias en una variedad de formas. El enfoque más común, que está disponible a partir de la .NET Framework 4.5, es llamar a estático Run método. El Run método proporciona una manera sencilla de iniciar una tarea con los valores predeterminados y sin necesidad de parámetros adicionales. En el ejemplo siguiente se usa el Run(Action) método para iniciar una tarea que se repite y, a continuación, muestra el número de iteraciones del bucle:

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Run( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
      t.Wait();
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations

Una alternativa y el método más común para iniciar una tarea .NET Framework 4, es estático TaskFactory.StartNew método. El Task.Factory devuelve un TaskFactory objeto. Las sobrecargas de los TaskFactory.StartNew método permite especificar parámetros para pasar a las opciones de creación de la tarea y un programador de tareas. En el ejemplo siguiente se usa el TaskFactory.StartNew método para iniciar una tarea. Es funcionalmente equivalente al código en el ejemplo anterior.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Factory.StartNew( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
      t.Wait();
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations

Para obtener ejemplos más completos, vea Task Parallelism (Task Parallel Library).

La Task clase también proporciona constructores que inicializan la tarea pero que no la programan para su ejecución. Por motivos de rendimiento, el Task.Run o TaskFactory.StartNew método es el mecanismo preferido para crear y programar tareas computacionales, pero para escenarios donde deben estar separados la creación y la programación, puede utilizar los constructores y, a continuación, llame a la Task.Start método para programar la tarea para su ejecución en un momento posterior.

Tareas suele ejecutan de forma asincrónica en un subproceso del grupo, por lo que el subproceso que crea e inicia la tarea continúa la ejecución en cuanto se ha creado una instancia de la tarea. En algunos casos, cuando el subproceso de llamada es el subproceso principal de la aplicación, la aplicación puede finalizar antes que la tarea comienza la ejecución. En otros casos, la lógica de la aplicación puede requerir que el subproceso de llamada continuar ejecución sólo cuando se ha completado la ejecución de una o más tareas. Puede sincronizar la ejecución del subproceso de llamada asincrónica tareas y se inicia llamando a un Wait método para esperar una o más tareas se completen.

Para esperar a que una sola tarea para completar, puede llamar a su Task.Wait método. Una llamada a la Wait método bloquea el subproceso de llamada hasta que ha completado la ejecución de la instancia de clase única.

En el ejemplo siguiente se llama sin parámetros Wait() método incondicionalmente espere hasta que se complete una tarea. La tarea simula el trabajo mediante una llamada a la Thread.Sleep método en modo de suspensión durante dos segundos.

using System;   
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static Random rand = new Random();

    static void Main()
    {
        // Wait on a single task with no timeout specified.
        Task taskA = Task.Run( () => Thread.Sleep(2000));
        Console.WriteLine("taskA Status: {0}", taskA.Status);
        try {
          taskA.Wait();
          Console.WriteLine("taskA Status: {0}", taskA.Status);
       } 
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }   
    }    
}
// The example displays output like the following:
//     taskA Status: WaitingToRun
//     taskA Status: RanToCompletion

También condicionalmente puede esperar que se complete una tarea. El Wait(Int32) y Wait(TimeSpan) métodos bloquean el subproceso de llamada hasta que finaliza la tarea o transcurre un intervalo de tiempo de espera, lo que ocurra primero. Puesto que en el ejemplo siguiente se inicia una tarea que se suspende durante dos segundos, pero define un valor de tiempo de espera de un segundo subproceso que realiza la llamada se bloquea hasta que expire el tiempo de espera y antes de la tarea ha completado su ejecución.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Wait on a single task with a timeout specified.
      Task taskA = Task.Run( () => Thread.Sleep(2000));
      try {
        taskA.Wait(1000);       // Wait for 1 second.
        bool completed = taskA.IsCompleted;
        Console.WriteLine("Task A completed: {0}, Status: {1}",
                         completed, taskA.Status);
        if (! completed)
           Console.WriteLine("Timed out before task A completed.");                 
       }
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }   
   }
}
// The example displays output like the following:
//     Task A completed: False, Status: Running
//     Timed out before task A completed.

También puede proporcionar un token de cancelación al llamar a la Wait(CancellationToken) y Wait(Int32, CancellationToken) métodos. Si el token IsCancellationRequested propiedad es true, cancele la espera; si es true cuando el Wait método finaliza.

En algunos casos, puede esperar para que la primera de una serie de tareas ejecutándose completa, pero no la atención que la tarea es. Para ello, puede llamar a una de las sobrecargas de la Task.WaitAll (método). En el ejemplo siguiente se crea tres tareas, cada uno de los cuales se suspende para determinar un intervalo por un generador de números aleatorios. El WaitAny(Task[]) método espera a que la primera tarea se complete. En el ejemplo a continuación, se muestra información sobre el estado de las tres tareas.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var tasks = new Task[3];
      var rnd = new Random();
      for (int ctr = 0; ctr <= 2; ctr++)
         tasks[ctr] = Task.Run( () => Thread.Sleep(rnd.Next(500, 3000)));

      try {
         int index = Task.WaitAny(tasks);
         Console.WriteLine("Task #{0} completed first.\n", tasks[index].Id);
         Console.WriteLine("Status of all tasks:");
         foreach (var t in tasks)
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
      }
      catch (AggregateException) {
         Console.WriteLine("An exception occurred.");
      }
   }
}
// The example displays output like the following:
//     Task #1 completed first.
//     
//     Status of all tasks:
//        Task #3: Running
//        Task #1: RanToCompletion
//        Task #4: Running

También puede esperar de una serie de tareas que debe realizar mediante una llamada a todos los WaitAll método. El siguiente ejemplo crea diez tareas, espera a que todos los diez en completarse y, a continuación, muestra su estado.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Wait for all tasks to complete.
      Task[] tasks = new Task[10];
      for (int i = 0; i < 10; i++)
      {
          tasks[i] = Task.Run(() => Thread.Sleep(2000));
      }
      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
         Console.WriteLine("One or more exceptions occurred: ");
         foreach (var ex in ae.Flatten().InnerExceptions)
            Console.WriteLine("   {0}", ex.Message);
      }   

      Console.WriteLine("Status of completed tasks:");
      foreach (var t in tasks)
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
   }
}
// The example displays the following output:
//     Status of completed tasks:
//        Task #2: RanToCompletion
//        Task #1: RanToCompletion
//        Task #3: RanToCompletion
//        Task #4: RanToCompletion
//        Task #6: RanToCompletion
//        Task #5: RanToCompletion
//        Task #7: RanToCompletion
//        Task #8: RanToCompletion
//        Task #9: RanToCompletion
//        Task #10: RanToCompletion

Tenga en cuenta que, cuando se espera completar las tareas de uno o más, se propagan las excepciones producidas en las tareas en ejecución en el subproceso que llama el Wait método, como se muestra en el ejemplo siguiente. Inicia 12 tareas, tres de los cuales finalizar con normalidad y tres de que inician una excepción. De las seis tareas restantes, tres se cancelan antes del inicio y tres se cancelarán mientras se ejecutan. Excepciones el WaitAll llamada al método y se controlan un try/catch bloque.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Create a cancellation token and cancel it.
      var source1 = new CancellationTokenSource();
      var token1 = source1.Token;
      source1.Cancel();
      // Create a cancellation token for later cancellation.
      var source2 = new CancellationTokenSource();
      var token2 = source2.Token;

      // Create a series of tasks that will complete, be cancelled, 
      // timeout, or throw an exception.
      Task[] tasks = new Task[12];
      for (int i = 0; i < 12; i++)
      {
          switch (i % 4) 
          {
             // Task should run to completion.
             case 0:
                tasks[i] = Task.Run(() => Thread.Sleep(2000));
                break;
             // Task should be set to canceled state.
             case 1:   
                tasks[i] = Task.Run( () => Thread.Sleep(2000),
                         token1);
                break;         
             case 2:
                // Task should throw an exception.
                tasks[i] = Task.Run( () => { throw new NotSupportedException(); } );
                break;
             case 3:
                // Task should examine cancellation token.
                tasks[i] = Task.Run( () => { Thread.Sleep(2000); 
                                             if (token2.IsCancellationRequested)
                                                token2.ThrowIfCancellationRequested();
                                             Thread.Sleep(500); }, token2);   
                break;
          }
      }
      Thread.Sleep(250);
      source2.Cancel();

      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
          Console.WriteLine("One or more exceptions occurred:");
          foreach (var ex in ae.InnerExceptions)
             Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message);
       }   

      Console.WriteLine("\nStatus of tasks:");
      foreach (var t in tasks) {
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
         if (t.Exception != null) {
            foreach (var ex in t.Exception.InnerExceptions)
               Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                 ex.Message);
         }
      }
   }
}
// The example displays output like the following:
//   One or more exceptions occurred:
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//   
//   Status of tasks:
//      Task #13: RanToCompletion
//      Task #1: Canceled
//      Task #3: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #8: Canceled
//      Task #14: RanToCompletion
//      Task #4: Canceled
//      Task #6: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #7: Canceled
//      Task #15: RanToCompletion
//      Task #9: Canceled
//      Task #11: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #12: Canceled

Para obtener más información sobre el control de excepciones en las operaciones asincrónicas basadas en tareas, consulte Control de excepciones (Task Parallel Library).

A partir de aplicaciones de escritorio que tienen como destino el .NET Framework 4.6, la referencia cultural del subproceso que crea e invoca una tarea se convierte en parte del contexto del subproceso. Es decir, sin tener en cuenta la referencia cultural actual del subproceso en el que se ejecuta la tarea, la referencia cultural actual de la tarea de la referencia cultural del subproceso que realiza la llamada. Para las aplicaciones destinadas a versiones de .NET Framework anteriores a la .NET Framework 4.6, la referencia cultural de la tarea es la referencia cultural del subproceso en el que se ejecuta la tarea. Para obtener más información, consulte la sección "Referencia cultural y operaciones asincrónicas basadas en tareas" en el CultureInfo tema.

System_CAPS_noteNota

Aplicaciones de la tienda siguen el tiempo de ejecución de Windows en establecer y obtener la referencia cultural predeterminada.

Para los desarrolladores que implementan a depuradores personalizados, varios miembros internos y privados de tarea pueden ser útiles (estos pueden cambiar de una versión a otra). El m_taskId campo sirve como almacén de respaldo para la Id propiedad, sin embargo al tener acceso a este campo directamente desde un depurador puede ser más eficaz que el acceso al mismo valor a través del método captador de la propiedad (el s_taskIdCounter contador se utiliza para recuperar el siguiente identificador disponible de una tarea). De forma similar, la m_stateFlags campo almacena información acerca de la fase del ciclo de vida actual de la tarea, la información también es accesible a través de la Status propiedad. El m_action campo almacena una referencia al delegado de la tarea y el m_stateObject campo almacena el estado asincrónico pasado a la tarea por el desarrollador. Por último, para los depuradores que analizan marcos de pila, el InternalWait método proporciona un marcador potencial para cuando una tarea está entrando en una operación de espera.

En el ejemplo siguiente se crea y ejecuta las cuatro tareas. Tres tareas ejecutan un Action<T> delegado denominado action, que acepta un argumento de tipo Object. Una cuarta tarea ejecuta una expresión lambda (un Action delegar) es definir en línea en la llamada al método de creación de tareas. Cada tarea se crea y se ejecuta de manera diferente:

  • Tarea t1 se crea una instancia mediante una llamada a un constructor de clase de tarea, pero se inicia llamando a su Start() método sólo después de la tarea de t2 se ha iniciado.

  • Tarea t2 se crea y se inicia en una única llamada al método mediante una llamada a la TaskFactory.StartNew(Action<Object>, Object) (método).

  • Tarea t3 se crea y se inicia en una única llamada al método mediante una llamada a la Run(Action) (método).

  • Tarea t4 se ejecuta sincrónicamente en el subproceso principal mediante una llamada a la RunSynchronously() (método).

Porque tarea t4 ejecuta de forma sincrónica, se ejecuta en el subproceso principal de la aplicación. Las tareas restantes ejecutan asincrónicamente normalmente en uno o más subprocesos de ThreadPool.

using System;
using System.Threading;
using System.Threading.Tasks;

class Example
{
    static void Main()
    {
        Action<object> action = (object obj) =>
                                {
                                   Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                   Task.CurrentId, obj,
                                   Thread.CurrentThread.ManagedThreadId);
                                };

        // Create a task but do not start it.
        Task t1 = new Task(action, "alpha");

        // Construct a started task
        Task t2 = Task.Factory.StartNew(action, "beta");
        // Block the main thread to demonstate that t2 is executing
        t2.Wait();

        // Launch t1 
        t1.Start();
        Console.WriteLine("t1 has been launched. (Main Thread={0})",
                          Thread.CurrentThread.ManagedThreadId);
        // Wait for the task to finish.
        t1.Wait();

        // Construct a started task using Task.Run.
        String taskData = "delta";
        Task t3 = Task.Run( () => {Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                                     Task.CurrentId, taskData,
                                                      Thread.CurrentThread.ManagedThreadId);
                                   });
        // Wait for the task to finish.
        t3.Wait();

        // Construct an unstarted task
        Task t4 = new Task(action, "gamma");
        // Run it synchronously
        t4.RunSynchronously();
        // Although the task was run synchronously, it is a good practice
        // to wait for it in the event exceptions were thrown by the task.
        t4.Wait();
    }
}
// The example displays output like the following:
//       Task=1, obj=beta, Thread=3
//       t1 has been launched. (Main Thread=1)
//       Task=2, obj=alpha, Thread=4
//       Task=3, obj=delta, Thread=3
//       Task=4, obj=gamma, Thread=1

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 4.0
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 5.0
Windows Phone Silverlight
Disponible desde 8.0
Windows Phone
Disponible desde 8.1

Todos los miembros de Task, excepto Dispose, es seguro para subprocesos y se pueden usar desde varios subprocesos simultáneamente.

Volver al principio
Mostrar:
© 2016 Microsoft