Task Clase
Definición
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í.
Representa una operación asincrónica.
public ref class Task : IAsyncResultpublic ref class Task : IAsyncResult, IDisposablepublic class Task : IAsyncResultpublic class Task : IAsyncResult, IDisposabletype Task = class
interface IAsyncResulttype Task = class
interface IAsyncResult
interface IDisposablePublic Class Task
Implements IAsyncResultPublic Class Task
Implements IAsyncResult, IDisposable- Herencia
-
Task
- Derivado
- Implementaciones
Comentarios
La Task clase representa una sola 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 del patrón asincrónico basado en tareas que se introdujo primero en .NET Framework 4. Dado que el trabajo realizado por un Task objeto normalmente se ejecuta de forma asincrónica en un subproceso del grupo de subprocesos en lugar de de forma sincrónica en el subproceso de aplicación principal, puede usar la Status propiedad , así como las IsCanceledpropiedades , 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.
Para las operaciones que devuelven valores, use la Task<TResult> clase .
En esta sección:
Ejemplos de creación de instancias de tareas
Creación y ejecución de una tarea
Separación de la creación y ejecución de tareas
Esperar a que se completen una o varias tareas
Tareas y referencia cultural
Para desarrolladores del depurador
Creación de instancias de tareas
En el ejemplo siguiente se crean y ejecutan 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 delegado) que se define en línea en la llamada al método de creación de tareas. Cada tarea se crea una instancia y se ejecuta de una manera diferente:
La tarea
t1se crea una instancia mediante una llamada a un constructor de clase Task, pero se inicia llamando a su Start() método solo después de que se haya iniciado la tareat2.La tarea
t2se crea una instancia y se inicia en una sola llamada de método mediante una llamada al TaskFactory.StartNew(Action<Object>, Object) método .La tarea
t3se crea una instancia y se inicia en una sola llamada de método mediante una llamada al Run(Action) método .La tarea
t4se ejecuta de forma sincrónica en el subproceso principal llamando al RunSynchronously() método .
Dado que la tarea t4 se ejecuta de forma sincrónica, se ejecuta en el subproceso de aplicación principal. Las tareas restantes se ejecutan de forma asincrónica normalmente en uno o varios subprocesos del grupo de subprocesos.
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 demonstrate 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
Imports System.Threading
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim action As Action(Of Object) =
Sub(obj As Object)
Console.WriteLine("Task={0}, obj={1}, Thread={2}",
Task.CurrentId, obj,
Thread.CurrentThread.ManagedThreadId)
End Sub
' Construct an unstarted task
Dim t1 As New Task(action, "alpha")
' Construct a started task
Dim t2 As Task = Task.Factory.StartNew(action, "beta")
' Block the main thread to demonstrate 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.
Dim taskData As String = "delta"
Dim t3 As Task = Task.Run(Sub()
Console.WriteLine("Task={0}, obj={1}, Thread={2}",
Task.CurrentId, taskData,
Thread.CurrentThread.ManagedThreadId)
End Sub)
' Wait for the task to finish.
t3.Wait()
' Construct an unstarted task
Dim t4 As 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()
End Sub
End Module
' 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=3
' Task=3, obj=delta, Thread=3
' Task=4, obj=gamma, Thread=1
Creación y ejecución de una tarea
Task Las 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 Run . El Run método proporciona una manera sencilla de iniciar una tarea mediante 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, se muestra el número de iteraciones de bucle:
using System;
using System.Threading.Tasks;
public class Example
{
public static async Task Main()
{
await Task.Run( () => {
// Just loop.
int ctr = 0;
for (ctr = 0; ctr <= 1000000; ctr++)
{}
Console.WriteLine("Finished {0} loop iterations",
ctr);
} );
}
}
// The example displays the following output:
// Finished 1000001 loop iterations
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim t As Task = Task.Run(Sub()
' Just loop.
Dim ctr As Integer = 0
For ctr = 0 to 1000000
Next
Console.WriteLine("Finished {0} loop iterations",
ctr)
End Sub)
t.Wait()
End Sub
End Module
' The example displays the following output:
' Finished 1000001 loop iterations
Una alternativa, y el método más común para iniciar una tarea en .NET Framework 4, es el método estático TaskFactory.StartNew . El Task.Factory propiedad devuelve un TaskFactory objeto. Las sobrecargas del TaskFactory.StartNew método permiten especificar parámetros para pasar a las opciones de creación de tareas y a 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 del 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
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim t As Task = Task.Factory.StartNew(Sub()
' Just loop.
Dim ctr As Integer = 0
For ctr = 0 to 1000000
Next
Console.WriteLine("Finished {0} loop iterations",
ctr)
End Sub)
t.Wait()
End Sub
End Module
' The example displays the following output:
' Finished 1000001 loop iterations
Para obtener ejemplos más completos, consulte Programación asincrónica basada en tareas.
Separación de la creación y ejecución de tareas
La Task clase también proporciona constructores que inicializan la tarea, pero que no lo programan para su ejecución. Por motivos de rendimiento, el Task.Run método o TaskFactory.StartNew es el mecanismo preferido para crear y programar tareas computacionales, pero en escenarios en los que se deben separar la creación y programación, puede usar los constructores y, a continuación, llamar al Task.Start método para programar la tarea para su ejecución más adelante.
Esperar a que se completen una o varias tareas
Dado que las tareas se ejecutan de forma asincrónica en un subproceso del grupo de subprocesos, 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 de aplicación principal, la aplicación puede finalizar antes de que la tarea comience realmente la ejecución. En otros, la lógica de la aplicación puede requerir que el subproceso de llamada continúe la ejecución solo cuando una o varias tareas hayan completado la ejecución. Puede sincronizar la ejecución del subproceso que realiza la llamada y las tareas asincrónicas que inicia llamando a un Wait método para esperar a que se completen una o varias tareas.
Para esperar a que se complete una sola tarea, puede llamar a su Task.Wait método. Una llamada al Wait método bloquea el subproceso que realiza la llamada hasta que la instancia de clase única haya completado la ejecución.
En el ejemplo siguiente se llama al método sin Wait() parámetros para esperar incondicionalmente hasta que se completa una tarea. La tarea simula el trabajo llamando al Thread.Sleep método para que se suspenda 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
Imports System.Threading
Imports System.Threading.Tasks
Module Example
Public Sub Main()
' Wait on a single task with no timeout specified.
Dim taskA = Task.Run( Sub() Thread.Sleep(2000))
Console.WriteLine("taskA Status: {0}", taskA.Status)
Try
taskA.Wait()
Console.WriteLine("taskA Status: {0}", taskA.Status)
Catch e As AggregateException
Console.WriteLine("Exception in taskA.")
End Try
End Sub
End Module
' The example displays output like the following:
' taskA Status: WaitingToRun
' taskA Status: RanToCompletion
También puede esperar condicionalmente a que se complete una tarea. Los Wait(Int32) métodos y Wait(TimeSpan) bloquean el subproceso que llama hasta que finaliza la tarea o transcurre un intervalo de tiempo de espera, lo que ocurra primero. Dado 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, el subproceso que realiza la llamada se bloquea hasta que expire el tiempo de espera y antes de que la tarea haya completado la 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.
Imports System.Threading
Imports System.Threading.Tasks
Module Example
Public Sub Main()
' Wait on a single task with a timeout specified.
Dim taskA As Task = Task.Run( Sub() Thread.Sleep(2000))
Try
taskA.Wait(1000) ' Wait for 1 second.
Dim completed As Boolean = taskA.IsCompleted
Console.WriteLine("Task.Completed: {0}, Status: {1}",
completed, taskA.Status)
If Not completed Then
Console.WriteLine("Timed out before task A completed.")
End If
Catch e As AggregateException
Console.WriteLine("Exception in taskA.")
End Try
End Sub
End Module
' The example displays the following output:
' Task A completed: False, Status: Running
' Timed out before task A completed.
También puede proporcionar un token de cancelación llamando a los Wait(CancellationToken) métodos y Wait(Int32, CancellationToken) . Si la propiedad del IsCancellationRequested token es true o se convierte true en mientras se ejecuta el Wait método , el método produce un OperationCanceledException.
En algunos casos, es posible que desee esperar a que se complete la primera de una serie de tareas en ejecución, pero no le importa qué tarea es. Para ello, puede llamar a una de las sobrecargas del Task.WaitAny método . En el ejemplo siguiente se crean tres tareas, cada una de las cuales se suspende durante un intervalo determinado por un generador de números aleatorios. El WaitAny(Task[]) método espera a que se complete la primera tarea. A continuación, en el ejemplo 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
Imports System.Threading
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim tasks(2) As Task
Dim rnd As New Random()
For ctr As Integer = 0 To 2
tasks(ctr) = Task.Run( Sub() Thread.Sleep(rnd.Next(500, 3000)))
Next
Try
Dim index As Integer= Task.WaitAny(tasks)
Console.WriteLine("Task #{0} completed first.", tasks(index).Id)
Console.WriteLine()
Console.WriteLine("Status of all tasks:")
For Each t in tasks
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status)
Next
Catch e As AggregateException
Console.WriteLine("An exception occurred.")
End Try
End Sub
End Module
' 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 a que se completen todas las tareas mediante una llamada al WaitAll método . En el ejemplo siguiente se crean diez tareas, se espera a que se completen las diez y, a continuación, se 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
Imports System.Threading
Imports System.Threading.Tasks
Module Example
Public Sub Main()
' Wait for all tasks to complete.
Dim tasks(9) As Task
For i As Integer = 0 To 9
tasks(i) = Task.Run( Sub() Thread.Sleep(2000) )
Next
Try
Task.WaitAll(tasks)
Catch ae As AggregateException
Console.WriteLine("One or more exceptions occurred: ")
For Each ex In ae.Flatten().InnerExceptions
Console.WriteLine(" {0}", ex.Message)
Next
End Try
Console.WriteLine("Status of completed tasks:")
For Each t in tasks
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status)
Next
End Sub
End Module
' 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 espere a que se completen una o varias tareas, las excepciones producidas en las tareas en ejecución se propagan en el subproceso que llama al método , como se muestra en el Wait ejemplo siguiente. Inicia 12 tareas, tres de las cuales se completan normalmente y tres de las cuales inician una excepción. De las seis tareas restantes, se cancelan tres antes de que se inicien y se cancelan tres mientras se ejecutan. Las excepciones se inician en la llamada al WaitAll método y se controlan mediante 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
Imports System.Threading
Imports System.Threading.Tasks
Module Example
Public Sub Main()
' Create a cancellation token and cancel it.
Dim source1 As New CancellationTokenSource()
Dim token1 As CancellationToken = source1.Token
source1.Cancel()
' Create a cancellation token for later cancellation.
Dim source2 As New CancellationTokenSource()
Dim token2 As CancellationToken = source2.Token
' Create a series of tasks that will complete, be cancelled,
' timeout, or throw an exception.
Dim tasks(11) As Task
For i As Integer = 0 To 11
Select Case i Mod 4
' Task should run to completion.
Case 0
tasks(i) = Task.Run( Sub() Thread.Sleep(2000))
' Task should be set to canceled state.
Case 1
tasks(i) = Task.Run( Sub() Thread.Sleep(2000), token1)
Case 2
' Task should throw an exception.
tasks(i) = Task.Run( Sub()
Throw New NotSupportedException()
End Sub)
Case 3
' Task should examine cancellation token.
tasks(i) = Task.Run( Sub()
Thread.Sleep(2000)
If token2.IsCancellationRequested
token2.ThrowIfCancellationRequested()
End If
Thread.Sleep(500)
End Sub, token2)
End Select
Next
Thread.Sleep(250)
source2.Cancel()
Try
Task.WaitAll(tasks)
Catch ae As AggregateException
Console.WriteLine("One or more exceptions occurred:")
For Each ex in ae.InnerExceptions
Console.WriteLine(" {0}: {1}", ex.GetType().Name, ex.Message)
Next
End Try
Console.WriteLine()
Console.WriteLine("Status of tasks:")
For Each t in tasks
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status)
If t.Exception IsNot Nothing Then
For Each ex in t.Exception.InnerExceptions
Console.WriteLine(" {0}: {1}", ex.GetType().Name,
ex.Message)
Next
End If
Next
End Sub
End Module
' 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 operaciones asincrónicas basadas en tareas, vea Control de excepciones.
Tareas y referencia cultural
A partir de las 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 CultureInfo tema.
Nota:
Las aplicaciones de la Tienda siguen el Windows Runtime en la configuración y la obtención de la referencia cultural predeterminada.
Para desarrolladores del depurador
Para los desarrolladores que implementan depuradores personalizados, pueden resultar útiles varios miembros internos y privados de la tarea (estos pueden cambiar de versión a versión). El m_taskId campo actúa como almacén de respaldo para la Id propiedad, pero el acceso a este campo directamente desde un depurador puede ser más eficaz que tener acceso al mismo valor a través del método getter de la propiedad (el s_taskIdCounter contador se usa para recuperar el siguiente identificador disponible para una tarea). Del mismo modo, el m_stateFlags campo almacena información sobre la fase actual del ciclo de vida 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 fotogramas de pila, el InternalWait método sirve un marcador potencial para cuando una tarea entra en una operación de espera.
Constructores
| 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, CancellationToken, TaskCreationOptions) |
Inicializa un nuevo objeto Task con la acción y las opciones de creación especificadas. |
| 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<Object>, Object, CancellationToken) |
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<Object>, Object, TaskCreationOptions) |
Inicializa un nuevo objeto Task con la acción, el estado y las opciones especificados. |
Propiedades
| AsyncState |
Obtiene el objeto de estado que se proporcionó al crearse el objeto Task, o null si no se proporcionó ningún objeto de estado. |
| CompletedTask |
Obtiene una tarea que ya ha finalizado correctamente. |
| CreationOptions |
Obtiene el objeto TaskCreationOptions usado para crear esta tarea. |
| CurrentId |
Devuelve el identificador del objeto Task que se está ejecutando actualmente. |
| Exception |
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á |
| Factory |
Proporciona acceso a patrones de diseño para crear y configurar instancias de Task y Task<TResult>. |
| Id |
Obtiene un identificador para esta instancia de Task. |
| IsCanceled |
Obtiene un valor que indica si esta instancia de Task ha completado su ejecución debido a una cancelación. |
| IsCompleted |
Obtiene un valor que indica si la tarea se ha completado. |
| IsCompletedSuccessfully |
Obtiene si la tarea se ejecutó hasta completarse. |
| IsFaulted |
Obtiene un valor que indica si el objeto Task se ha completado debido a una excepción no controlada. |
| Status |
Obtiene el objeto TaskStatus de esta tarea. |
Métodos
| ConfigureAwait(Boolean) |
Configura un awaiter utilizado para esperar a este objeto 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 el elemento Task de destino se completa. |
| 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 el elemento Task de destino se completa. |
| 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 el elemento Task de destino se completa. La continuación se ejecuta según un conjunto de condiciones especificadas y usa un programador especificado. |
| 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 el elemento Task de destino se completa. La continuación se ejecuta según un conjunto de condiciones especificadas. |
| 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 el elemento Task de destino se completa. La continuación usa un programador especificado. |
| ContinueWith(Action<Task>) |
Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino. |
| ContinueWith(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. |
| ContinueWith(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. |
| ContinueWith(Action<Task>, TaskContinuationOptions) |
Crea una continuación que se ejecuta cuando se completa la tarea de destino según el elemento TaskContinuationOptions especificado. |
| ContinueWith(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. |
| 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 elemento Task de destino se completa y devuelve un valor. |
| ContinueWith<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. |
| ContinueWith<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. |
| ContinueWith<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. |
| ContinueWith<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. |
| ContinueWith<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. |
| ContinueWith<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. |
| 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. Se pasa un token de cancelación a la continuación y usa un programador especificado. |
| 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. |
| ContinueWith<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. |
| Delay(Int32) |
Crea una tarea que se completa después de un número especificado de milisegundos. |
| Delay(Int32, CancellationToken) |
Crea una tarea cancelable que se completa después de un número especificado de milisegundos. |
| Delay(TimeSpan) |
Crea una tarea que se completa después de un intervalo de tiempo especificado. |
| Delay(TimeSpan, CancellationToken) |
Crea una tarea cancelable que se completa después de un intervalo de tiempo específico. |
| Dispose() |
Libera todos los recursos usados por la instancia actual de la clase Task. |
| Dispose(Boolean) |
Desecha el objeto Task y libera todos sus recursos no administrados. |
| Equals(Object) |
Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object) |
| FromCanceled(CancellationToken) |
Crea una Task que se finaliza debido a la cancelación con un token de cancelación especificado. |
| FromCanceled<TResult>(CancellationToken) |
Crea una Task<TResult> que se finaliza debido a la cancelación con un token de cancelación especificado. |
| FromException(Exception) |
Crea una Task que finalizó con una excepción especificada. |
| FromException<TResult>(Exception) |
Crea una Task<TResult> que finalizó con una excepción especificada. |
| FromResult<TResult>(TResult) |
Crea un objeto Task<TResult> que se ha completado correctamente con el resultado especificado. |
| GetAwaiter() |
Obtiene un awaiter utilizado para esperar a este objeto Task. |
| GetHashCode() |
Sirve como la función hash predeterminada. (Heredado de Object) |
| GetType() |
Obtiene el Type de la instancia actual. (Heredado de Object) |
| MemberwiseClone() |
Crea una copia superficial del Object actual. (Heredado de Object) |
| Run(Action) |
Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un objeto Task que representa ese trabajo. |
| Run(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 si aún no se ha iniciado. |
| Run(Func<Task>) |
Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un proxy para la tarea devuelta por |
| Run(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 |
| Run<TResult>(Func<Task<TResult>>) |
Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un proxy para |
| Run<TResult>(Func<Task<TResult>>, CancellationToken) |
Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un proxy para |
| Run<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. Un token de cancelación permite cancelar el trabajo si aún no se ha iniciado. |
| Run<TResult>(Func<TResult>, CancellationToken) |
Pone en cola el trabajo especificado para ejecutarlo en el grupo de subprocesos y devuelve un objeto |
| RunSynchronously() |
Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler actual. |
| RunSynchronously(TaskScheduler) |
Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler proporcionado. |
| Start() |
Inicia el objeto Task, programando su ejecución en el objeto TaskScheduler actual. |
| Start(TaskScheduler) |
Inicia el objeto Task, programando su ejecución en el objeto TaskScheduler especificado. |
| ToString() |
Devuelve una cadena que representa el objeto actual. (Heredado de Object) |
| Wait() |
Espera a que se complete la ejecución del objeto Task. |
| Wait(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. |
| Wait(Int32) |
Espera a que el objeto Task complete la ejecución dentro de un número especificado de milisegundos. |
| Wait(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. |
| Wait(TimeSpan) |
Espera a que Task complete la ejecución dentro de un intervalo de tiempo especificado. |
| Wait(TimeSpan, CancellationToken) |
Espera a que se complete la ejecución del objeto Task. |
| WaitAll(Task[]) |
Espera que se complete la ejecución de todos los objetos Task proporcionados. |
| WaitAll(Task[], CancellationToken) |
Espera que se complete la ejecución de todos los objetos Task proporcionados, a menos que se cancele la espera. |
| WaitAll(Task[], Int32) |
Espera a que todos los objetos proporcionados de Task completen la ejecución dentro de un número especificado de milisegundos. |
| WaitAll(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. |
| WaitAll(Task[], TimeSpan) |
Espera a que todos los objetos Task cancelables que se hayan proporcionado completen la ejecución en un intervalo de tiempo especificado. |
| WaitAny(Task[]) |
Espera a que se complete la ejecución de cualquiera de los objetos Task proporcionados. |
| WaitAny(Task[], CancellationToken) |
Espera que se complete la ejecución de cualquiera de los objetos Task proporcionados, a menos que se cancele la espera. |
| WaitAny(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. |
| WaitAny(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. |
| WaitAny(Task[], TimeSpan) |
Espera a que se complete la ejecución de cualquier objeto Task proporcionado en un intervalo de tiempo especificado. |
| WaitAsync(CancellationToken) |
Obtiene un Task objeto que se completará cuando se complete o Task cuando se haya solicitado la cancelación especificada CancellationToken . |
| WaitAsync(TimeSpan) |
Obtiene un Task objeto que se completará cuando finalice o Task cuando expire el tiempo de espera especificado. |
| WaitAsync(TimeSpan, CancellationToken) |
Obtiene un Task objeto que se completará cuando Task finalice, cuando expire el tiempo de espera especificado o cuando se haya solicitado la cancelación especificada CancellationToken . |
| WhenAll(IEnumerable<Task>) |
Crea una tarea que se completará cuando todos los objetos Task de una colección enumerable se hayan completado. |
| WhenAll(Task[]) |
Crea una tarea que se completará cuando todos los objetos Task de una matriz se hayan completado. |
| WhenAll<TResult>(IEnumerable<Task<TResult>>) |
Crea una tarea que se completará cuando todos los objetos Task<TResult> de una colección enumerable se hayan completado. |
| WhenAll<TResult>(Task<TResult>[]) |
Crea una tarea que se completará cuando todos los objetos Task<TResult> de una matriz se hayan completado. |
| WhenAny(IEnumerable<Task>) |
Crea una tarea que se completará cuando se haya completado cualquiera de las tareas proporcionadas. |
| WhenAny(Task, Task) |
Crea una tarea que se finalizará cuando se haya completado cualquiera de las tareas proporcionadas. |
| WhenAny(Task[]) |
Crea una tarea que se completará cuando se haya completado cualquiera de las tareas proporcionadas. |
| WhenAny<TResult>(IEnumerable<Task<TResult>>) |
Crea una tarea que se completará cuando se haya completado cualquiera de las tareas proporcionadas. |
| WhenAny<TResult>(Task<TResult>, Task<TResult>) |
Crea una tarea que se finalizará cuando se haya completado cualquiera de las tareas proporcionadas. |
| WhenAny<TResult>(Task<TResult>[]) |
Crea una tarea que se completará cuando se haya completado cualquiera de las tareas proporcionadas. |
| Yield() |
Crea una tarea que admite "await" que, de forma asincrónica, devuelve al contexto actual cuando es "awaited". |
Implementaciones de interfaz explícitas
| IAsyncResult.AsyncWaitHandle |
Obtiene un identificador WaitHandle que se puede usar para esperar a que se complete la tarea. |
| IAsyncResult.CompletedSynchronously |
Obtiene un valor que indica si la operación se ha completado sincrónicamente. |
Métodos de extensión
| DispatcherOperationWait(Task) |
Espera indefinidamente a que se complete la DispatcherOperation subyacente. |
| DispatcherOperationWait(Task, TimeSpan) |
Espera la cantidad de tiempo especificada para que se complete el DispatcherOperation subyacente. |
| IsDispatcherOperationTask(Task) |
Devuelve un valor que indica si este Task está asociado con un DispatcherOperation. |
| AsAsyncAction(Task) |
Devuelve una acción asincrónica de Windows Runtime que representa una tarea iniciada. |
Se aplica a
Seguridad para subprocesos
Todos los miembros de Task, excepto para Dispose(), son seguros para subprocesos y se pueden usar desde varios subprocesos simultáneamente.