Task<TResult> Clase

Definición

Espacio de nombres:

System.Threading.Tasks

Ensamblado:

System.Runtime.dll

Source:

Future.cs

Representa una operación asincrónica que puede devolver un valor.

generic <typename TResult>
public ref class Task : System::Threading::Tasks::Task

public class Task<TResult> : System.Threading.Tasks.Task

type Task<'Result> = class
    inherit Task

Public Class Task(Of TResult)
Inherits Task

Parámetros de tipo

TResult

Tipo del resultado generado por este Task<TResult>.

Herencia

Object

Task

Task<TResult>

Comentarios

La clase Task<TResult> representa una sola operación que devuelve un valor y que normalmente se ejecuta de forma asincrónica. Task<TResult> objetos son uno de los componentes centrales del patrón asincrónico basado en tareas introducidos primero en .NET Framework 4. Dado que el trabajo realizado por un objeto de Task<TResult> normalmente se ejecuta de forma asincrónica en un subproceso de grupo de subprocesos en lugar de de forma sincrónica en el subproceso de aplicación principal, puede usar la propiedad Status, así como las propiedades IsCanceled, IsCompletedy IsFaulted, para determinar el estado de una tarea. Normalmente, se usa una expresión lambda para especificar el trabajo que se va a realizar la tarea.

Task<TResult> instancias se pueden crear de varias maneras. El enfoque más común, que está disponible a partir de .NET Framework 4.5, es llamar al método estático Task.Run<TResult>(Func<TResult>) o Task.Run<TResult>(Func<TResult>, CancellationToken). Estos métodos proporcionan una manera sencilla de iniciar una tarea mediante valores predeterminados y sin adquirir parámetros adicionales. En el ejemplo siguiente se usa el método Task.Run<TResult>(Func<TResult>) para iniciar una tarea que recorre un bucle y, a continuación, se muestra el número de iteraciones de bucle:

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task<int>.Run( () => {
                                      // Just loop.
                                      int max = 1000000;
                                      int ctr = 0;
                                      for (ctr = 0; ctr <= max; ctr++) {
                                         if (ctr == max / 2 && DateTime.Now.Hour <= 12) {
                                            ctr++;
                                            break;
                                         }
                                      }
                                      return ctr;
                                    } );
      Console.WriteLine("Finished {0:N0} iterations.", t.Result);
   }
}
// The example displays output like the following:
//        Finished 1,000,001 loop iterations.

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task(Of Integer) = Task.Run(Function()
                                  Dim max As Integer = 1000000
                                  Dim ctr As Integer
                                  For ctr = 0 to max
                                     If ctr = max \ 2 And Date.Now.Hour <= 12 Then
                                        ctr += 1
                                        Exit For
                                     End If
                                  Next
                                  Return ctr
                               End Function)
      Console.WriteLine("Finished {0:N0} iterations.", t.Result)
   End Sub
End Module
' The example displays the following output:
'       Finished 1,000,001 loop iterations

Una alternativa y la manera más común de iniciar una tarea en .NET Framework 4 es llamar al método estático TaskFactory.StartNew o TaskFactory<TResult>.StartNew. La propiedad Task.Factory devuelve un objeto TaskFactory y la propiedad Task<TResult>.Factory devuelve un objeto TaskFactory<TResult>. Las sobrecargas de su método de StartNew permiten pasar argumentos, definir opciones de creación de tareas y especificar un programador de tareas. En el ejemplo siguiente se usa el método TaskFactory<TResult>.StartNew(Func<TResult>) para iniciar una tarea. Es funcionalmente equivalente al código del ejemplo anterior.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task<int>.Factory.StartNew( () => {
                                      // Just loop.
                                      int max = 1000000;
                                      int ctr = 0;
                                      for (ctr = 0; ctr <= max; ctr++) {
                                         if (ctr == max / 2 && DateTime.Now.Hour <= 12) {
                                            ctr++;
                                            break;
                                         }
                                      }
                                      return ctr;
                               } );
      Console.WriteLine("Finished {0:N0} iterations.", t.Result);
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t = Task(Of Integer).Factory.StartNew(Function()
                                  Dim max As Integer = 1000000
                                  Dim ctr As Integer
                                  For ctr = 0 to max
                                     If ctr = max \ 2 And Date.Now.Hour <= 12 Then
                                       ctr += 1
                                       Exit For
                                     End If
                                  Next
                                  Return ctr
                               End Function)
      Console.WriteLine("Finished {0:N0} iterations.", t.Result)
   End Sub
End Module
' The example displays output like the following:
'       Finished 1,000,001 iterations

Para obtener ejemplos más completos, consulte programación asincrónica basada en tareas.

La clase Task<TResult> también proporciona constructores que inicializan la tarea, pero que no lo programan para su ejecución. Por motivos de rendimiento, los métodos Task.Run y Task.Factory.StartNew son los mecanismos preferidos para crear y programar tareas computacionales, pero en escenarios en los que se deben separar la creación y programación de tareas, se pueden usar los constructores y el método Start de la tarea se puede usar para programar la tarea para su ejecución más adelante.

A partir de aplicaciones de escritorio destinadas a .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, independientemente de la referencia cultural actual del subproceso en el que se ejecuta la tarea, la referencia cultural actual de la tarea es la referencia cultural del subproceso que realiza la llamada. En el caso de las aplicaciones destinadas a versiones de .NET Framework anteriores a .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, vea la sección "Referencia cultural y operaciones asincrónicas basadas en tareas" del tema CultureInfo. Tenga en cuenta que las aplicaciones de la Tienda siguen Windows Runtime en la configuración y obtienen la referencia cultural predeterminada.

Para las operaciones que no devuelven un valor, use la clase Task. A partir de C# 7.0, para una tarea más ligera que sea un tipo de valor en lugar de un tipo de referencia, use la estructura System.Threading.Tasks.ValueTask<TResult>.

Constructores

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

Propiedades

AsyncState	Obtiene el objeto de estado proporcionado cuando se creó el Task, o null si no se proporcionó ninguno. (Heredado de Task)
CreationOptions	Obtiene el TaskCreationOptions usado para crear esta tarea. (Heredado de Task)
Exception	Obtiene el AggregateException que provocó que el Task finalizara prematuramente. Si el Task se completó correctamente o aún no ha producido ninguna excepción, devolverá null. (Heredado de Task)
Factory	Obtiene un método de fábrica para crear y configurar instancias de Task<TResult>.
Id	Obtiene un identificador para esta instancia de Task. (Heredado de Task)
IsCanceled	Obtiene si esta instancia de Task ha completado la ejecución debido a la cancelación. (Heredado de Task)
IsCompleted	Obtiene un valor que indica si la tarea se ha completado. (Heredado de Task)
IsCompletedSuccessfully	Obtiene si la tarea se ejecutó hasta la finalización. (Heredado de Task)
IsFaulted	Obtiene si el Task completado debido a una excepción no controlada. (Heredado de Task)
Result	Obtiene el valor de resultado de este Task<TResult>.
Status	Obtiene el TaskStatus de esta tarea. (Heredado de Task)

Métodos

ConfigureAwait(Boolean)	Configura un awaiter usado para esperar este Task<TResult>.
ConfigureAwait(ConfigureAwaitOptions)	Configura un awaiter usado para esperar este Task.
ContinueWith(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 se completa el destino Task. (Heredado de Task)
ContinueWith(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 se completa el Task de destino. (Heredado de Task)
ContinueWith(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 se completa el Task de destino. La continuación se ejecuta en función de un conjunto de condiciones especificadas y usa un programador especificado. (Heredado de Task)
ContinueWith(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 se completa el destino Task. La continuación se ejecuta en función de un conjunto de condiciones especificadas. (Heredado de Task)
ContinueWith(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 se completa el destino Task. La continuación usa un programador especificado. (Heredado de Task)
ContinueWith(Action<Task<TResult>,Object>, Object)	Crea una continuación que se pasa información de estado y que se ejecuta cuando se completa el Task<TResult> de destino.
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken)	Crea una continuación que se ejecuta cuando se completa el Task<TResult> de destino.
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuación que se ejecuta cuando se completa el Task<TResult> de destino.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions)	Crea una continuación que se ejecuta cuando se completa el Task<TResult> de destino.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler)	Crea una continuación que se ejecuta cuando se completa el Task<TResult> de destino.
ContinueWith(Action<Task<TResult>>)	Crea una continuación que se ejecuta de forma asincrónica cuando se completa la tarea de destino.
ContinueWith(Action<Task<TResult>>, CancellationToken)	Crea una continuación cancelable que se ejecuta de forma asincrónica cuando se completa el Task<TResult> de destino.
ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuación que se ejecuta según la condición especificada en continuationOptions.
ContinueWith(Action<Task<TResult>>, TaskContinuationOptions)	Crea una continuación que se ejecuta según la condición especificada en continuationOptions.
ContinueWith(Action<Task<TResult>>, TaskScheduler)	Crea una continuación que se ejecuta de forma asincrónica cuando se completa el Task<TResult> de destino.
ContinueWith(Action<Task>)	Crea una continuación que se ejecuta de forma asincrónica cuando se completa el Task de destino. (Heredado de Task)
ContinueWith(Action<Task>, CancellationToken)	Crea una continuación que recibe un token de cancelación y se ejecuta de forma asincrónica cuando se completa el Task de destino. (Heredado de Task)
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuación que se ejecuta cuando la tarea de destino compite según el TaskContinuationOptionsespecificado. La continuación recibe un token de cancelación y usa un programador especificado. (Heredado de Task)
ContinueWith(Action<Task>, TaskContinuationOptions)	Crea una continuación que se ejecuta cuando se completa la tarea de destino según el TaskContinuationOptionsespecificado. (Heredado de Task)
ContinueWith(Action<Task>, TaskScheduler)	Crea una continuación que se ejecuta de forma asincrónica cuando se completa el Task de destino. La continuación usa un programador especificado. (Heredado de Task)
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object)	Crea una continuación que se ejecuta cuando se completa el Task<TResult> de destino.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken)	Crea una continuación que se ejecuta cuando se completa el Task<TResult> de destino.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuación que se ejecuta cuando se completa el Task<TResult> de destino.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions)	Crea una continuación que se ejecuta cuando se completa el Task<TResult> de destino.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler)	Crea una continuación que se ejecuta cuando se completa el Task<TResult> de destino.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)	Crea una continuación que se ejecuta de forma asincrónica cuando se completa el Task<TResult> de destino.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken)	Crea una continuación que se ejecuta de forma asincrónica cuando se completa el Task<TResult> de destino.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuación que se ejecuta según la condición especificada en continuationOptions.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions)	Crea una continuación que se ejecuta según la condición especificada en continuationOptions.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskScheduler)	Crea una continuación que se ejecuta de forma asincrónica cuando se completa el Task<TResult> de destino.
ContinueWith<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 destino Task finaliza y devuelve un valor. (Heredado de Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	Crea una continuación que se ejecuta de forma asincrónica cuando el destino Task 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. (Heredado de Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuación que se ejecuta en función de las opciones de continuación de tareas especificadas cuando el destino Task 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. (Heredado de Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	Crea una continuación que se ejecuta en función de las opciones de continuación de tareas especificadas cuando se completa el destino Task. La continuación recibe información de estado proporcionada por el autor de la llamada. (Heredado de Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	Crea una continuación que se ejecuta de forma asincrónica cuando se completa el Task de destino. La continuación recibe información de estado proporcionada por el autor de la llamada y usa un programador especificado. (Heredado de Task)
ContinueWith<TResult>(Func<Task,TResult>)	Crea una continuación que se ejecuta de forma asincrónica cuando el destino Task<TResult> completa y devuelve un valor. (Heredado de Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	Crea una continuación que se ejecuta de forma asincrónica cuando el destino Task completa y devuelve un valor. La continuación recibe un token de cancelación. (Heredado de Task)
ContinueWith<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. La continuación se pasa un token de cancelación y usa un programador especificado. (Heredado de Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)	Crea una continuación que se ejecuta según las opciones de continuación especificadas y devuelve un valor. (Heredado de Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	Crea una continuación que se ejecuta de forma asincrónica cuando el destino Task completa y devuelve un valor. La continuación usa un programador especificado. (Heredado de Task)
Dispose()	Libera todos los recursos usados por la instancia actual de la clase Task. (Heredado de Task)
Dispose(Boolean)	Elimina el Task, liberando todos sus recursos no administrados. (Heredado de Task)
Equals(Object)	Determina si el objeto especificado es igual al objeto actual. (Heredado de Object)
GetAwaiter()	Obtiene un awaiter usado para esperar este Task<TResult>.
GetHashCode()	Actúa como función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Objectactual. (Heredado de Object)
RunSynchronously()	Ejecuta el Task sincrónicamente en el TaskScheduleractual. (Heredado de Task)
RunSynchronously(TaskScheduler)	Ejecuta el Task sincrónicamente en el TaskScheduler proporcionado. (Heredado de Task)
Start()	Inicia el Task, programando para su ejecución en el TaskScheduleractual. (Heredado de Task)
Start(TaskScheduler)	Inicia el Task, programando para su ejecución en el TaskSchedulerespecificado. (Heredado de Task)
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
Wait()	Espera a que el Task complete la ejecución. (Heredado de Task)
Wait(CancellationToken)	Espera a que el Task complete la ejecución. La espera finaliza si se cancela un token de cancelación antes de que se complete la tarea. (Heredado de Task)
Wait(Int32)	Espera a que el Task complete la ejecución dentro de un número especificado de milisegundos. (Heredado de Task)
Wait(Int32, CancellationToken)	Espera a que el Task complete la ejecución. La espera finaliza si transcurre un intervalo de tiempo de espera o se cancela un token de cancelación antes de que se complete la tarea. (Heredado de Task)
Wait(TimeSpan)	Espera a que el Task complete la ejecución dentro de un intervalo de tiempo especificado. (Heredado de Task)
Wait(TimeSpan, CancellationToken)	Espera a que el Task complete la ejecución. (Heredado de Task)
WaitAsync(CancellationToken)	Obtiene un Task<TResult> que se completará cuando se complete este Task<TResult> o cuando se haya solicitado la cancelación del CancellationToken especificado.
WaitAsync(TimeSpan)	Obtiene un Task<TResult> que se completará cuando se complete este Task<TResult> o cuando expire el tiempo de espera especificado.
WaitAsync(TimeSpan, CancellationToken)	Obtiene un Task<TResult> que se completará cuando finalice este Task<TResult>, cuando expire el tiempo de espera especificado o cuando se haya solicitado la cancelación del CancellationToken especificado.
WaitAsync(TimeSpan, TimeProvider)	Obtiene un Task<TResult> que se completará cuando se complete este Task<TResult> o cuando expire el tiempo de espera especificado.
WaitAsync(TimeSpan, TimeProvider, CancellationToken)	Obtiene un Task<TResult> que se completará cuando finalice este Task<TResult>, cuando expire el tiempo de espera especificado o cuando se haya solicitado la cancelación del CancellationToken especificado.

Implementaciones de interfaz explícitas

IAsyncResult.AsyncWaitHandle	Obtiene un WaitHandle que se puede usar para esperar a que se complete la tarea. (Heredado de Task)
IAsyncResult.CompletedSynchronously	Obtiene una indicación de si la operación se completó sincrónicamente. (Heredado de Task)

Métodos de extensión

AsyncWait<TException>(Task)	Representa una operación asincrónica que puede devolver un valor.
AwaitWithTimeout(Task, TimeSpan)	Representa una operación asincrónica que puede devolver un valor.
ToApm(Task, AsyncCallback, Object)	Representa una operación asincrónica que puede devolver un valor.
ToApm<TResult>(Task<TResult>, AsyncCallback, Object)	Representa una operación asincrónica que puede devolver un valor.
ToApmEnd(IAsyncResult)	Representa una operación asincrónica que puede devolver un valor.
ToApmEnd<TResult>(IAsyncResult)	Representa una operación asincrónica que puede devolver un valor.
Wait(Task, TimeSpan, Action<Exception,TimeSpan,String>, String)	Representa una operación asincrónica que puede devolver un valor.
WaitForCompletion(Task)	Representa una operación asincrónica que puede devolver un valor.
WaitForCompletion<TResult>(Task<TResult>)	Representa una operación asincrónica que puede devolver un valor.
WaitForCompletionNoSpin(Task)	Representa una operación asincrónica que puede devolver un valor.
WaitForCompletionNoSpin(Task, TimeSpan)	Representa una operación asincrónica que puede devolver un valor.
WaitForCompletionNoSpin<TResult>(Task<TResult>)	Representa una operación asincrónica que puede devolver un valor.
WaitAsync(Task, TimeSpan, TimeProvider, CancellationToken)	Obtiene un Task que se completará cuando finalice este Task, cuando expire el tiempo de espera especificado o cuando se haya solicitado la cancelación del CancellationToken especificado.
WaitAsync<TResult>(Task<TResult>, TimeSpan, TimeProvider, CancellationToken)	Obtiene un Task que se completará cuando finalice este Task, cuando expire el tiempo de espera especificado o cuando se haya solicitado la cancelación del CancellationToken especificado.

Seguridad para subprocesos

Todos los miembros de Task<TResult>, excepto para Dispose(), son seguros para subprocesos y se pueden usar de varios subprocesos simultáneamente.

Consulte también

• Task
• biblioteca paralela de tareas (TPL) de
• programación asincrónica basada en tareas
• ejemplos de para la programación en paralelo con .NET Core y .NET Standard