TaskFactory Clase

Definición

Proporciona compatibilidad para crear y programar objetos Task.Provides support for creating and scheduling Task objects.

public ref class TaskFactory
public class TaskFactory
type TaskFactory = class
Public Class TaskFactory
Herencia
TaskFactory

Ejemplos

En el ejemplo siguiente se usa la propiedad estática Factory para realizar dos llamadas al método TaskFactory.StartNew.The following example uses the static Factory property to make two calls to the TaskFactory.StartNew method. La primera rellena una matriz con los nombres de los archivos del directorio mis documentos del usuario, mientras que la segunda rellena una matriz con los nombres de los subdirectorios del directorio mis documentos del usuario.The first populates an array with the names of files in the user's MyDocuments directory, while the second populates an array with the names of subdirectories of the user's MyDocuments directory. A continuación, llama al método TaskFactory.ContinueWhenAll(Task[], Action<Task[]>), que muestra información sobre el número de archivos y directorios de las dos matrices después de que las dos primeras tareas hayan finalizado su ejecución.It then calls the TaskFactory.ContinueWhenAll(Task[], Action<Task[]>) method, which displays information about the number of files and directories in the two arrays after the first two tasks have completed execution.

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

public class Example
{
   public static void Main()
   {
      Task[] tasks = new Task[2];
      String[] files = null;
      String[] dirs = null;
      String docsDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

      tasks[0] = Task.Factory.StartNew( () => files = Directory.GetFiles(docsDirectory));
      tasks[1] = Task.Factory.StartNew( () => dirs = Directory.GetDirectories(docsDirectory));

      Task.Factory.ContinueWhenAll(tasks, completedTasks => {
                                             Console.WriteLine("{0} contains: ", docsDirectory);
                                             Console.WriteLine("   {0} subdirectories", dirs.Length);
                                             Console.WriteLine("   {0} files", files.Length);
                                          } );
   }
}
// The example displays output like the following:
//       C:\Users\<username>\Documents contains:
//          24 subdirectories
//          16 files
Imports System.IO
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks(1) As Task
      Dim files() As String = Nothing
      Dim dirs() As String = Nothing
      Dim docsDirectory As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
      
      tasks(0) = Task.Factory.StartNew( Sub()
                                           files = Directory.GetFiles(docsDirectory)
                                        End Sub )
      tasks(1) = Task.Factory.StartNew( Sub()
                                           dirs = Directory.GetDirectories(docsDirectory)
                                        End Sub )
      Task.Factory.ContinueWhenAll(tasks, Sub(completedTasks)
                                             Console.WriteLine("{0} contains: ", docsDirectory)
                                             Console.WriteLine("   {0} subdirectories", dirs.Length)
                                             Console.WriteLine("   {0} files", files.Length)
                                          End Sub)
   End Sub
End Module
' The example displays output like the following:
'       C:\Users\<username>\Documents contains:
'          24 subdirectories
'          16 files

Comentarios

El .NET Framework proporciona dos generadores para crear y programar tareas:The .NET Framework provides two factories for creating and scheduling tasks:

  • La clase TaskFactory, que crea objetos Task y Task<TResult>.The TaskFactory class, which creates Task and Task<TResult> objects. Puede llamar a las sobrecargas de este método para crear y ejecutar una tarea que requiere argumentos no predeterminados.You can call the overloads of this method to create and execute a task that requires non-default arguments.

    Advertencia

    A partir de .NET Framework 4.5.NET Framework 4.5, el método Task.Run proporciona la forma más sencilla de crear una tarea con valores de configuración predeterminados e iniciarla inmediatamente.Starting with the .NET Framework 4.5.NET Framework 4.5, the Task.Run method provides the easiest way to create a task with default configuration values and start it immediately.

  • La clase TaskFactory<TResult>, que crea objetos Task<TResult>.The TaskFactory<TResult> class, which creates Task<TResult> objects.

La clase TaskFactory permite hacer lo siguiente:The TaskFactory class allows you to do the following:

  • Cree una tarea e iníciela inmediatamente llamando al método StartNew.Create a task and start it immediately by calling the StartNew method.

    Advertencia

    A partir de .NET Framework 4.5.NET Framework 4.5, el método Task.Run proporciona la forma más sencilla de crear una tarea con valores de configuración predeterminados e iniciarla inmediatamente.Starting with the .NET Framework 4.5.NET Framework 4.5, the Task.Run method provides the easiest way to create a task with default configuration values and start it immediately.

  • Cree una tarea que se inicie cuando una de las tareas de una matriz se haya completado llamando al método ContinueWhenAny.Create a task that starts when any one of the tasks in an array has completed by calling the ContinueWhenAny method.

  • Cree una tarea que se inicie cuando todas las tareas de una matriz se hayan completado llamando al método ContinueWhenAll.Create a task that starts when all the tasks in an array have completed by calling the ContinueWhenAll method.

La propiedad estática Task<TResult>.Factory devuelve un objeto TaskFactory<TResult> predeterminado.The static Task<TResult>.Factory property returns a default TaskFactory<TResult> object. También puede llamar a uno de los constructores de clases TaskFactory para configurar los objetos Task que crea la clase TaskFactory.You can also call one of the TaskFactory class constructors to configure the Task objects that the TaskFactory class creates. En el ejemplo siguiente se configura un nuevo objeto TaskFactory para crear tareas que tienen un token de cancelación especificado, opciones de creación de tareas, opciones de continuación y un programador de tareas personalizado.The following example configures a new TaskFactory object to create tasks that have a specified cancellation token, task creation options, continuation options, and a customized task scheduler.

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

class Example
{
   static CancellationTokenSource cts = new CancellationTokenSource();
   
   static TaskFactory factory = new TaskFactory(
      cts.Token,
      TaskCreationOptions.PreferFairness,
      TaskContinuationOptions.ExecuteSynchronously,
      new CustomScheduler());

   static void Main()
   {
      var t2 = factory.StartNew(() => DoWork());
      cts.Dispose();
   }

   static void DoWork() {/*...*/ }
}
Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim cts As New CancellationTokenSource()
      Dim factory As New TaskFactory(cts.Token,
                                     TaskCreationOptions.PreferFairness,
                                     TaskContinuationOptions.ExecuteSynchronously,
                                     New CustomScheduler())

      Dim t2 = factory.StartNew(Sub() DoWork())
      cts.Dispose()
   End Sub

   Sub DoWork()
      ' ...
   End Sub
End Module

En la mayoría de los casos, no es necesario crear una nueva instancia de TaskFactory.In most cases, you do not have to instantiate a new TaskFactory instance. En su lugar, puede usar la propiedad Task.Factory, que devuelve un objeto de generador que usa los valores predeterminados.Instead, you can use the Task.Factory property, which returns a factory object that uses default values. A continuación, puede llamar a sus métodos para iniciar nuevas tareas o definir continuaciones de tareas.You can then call its methods to start new tasks or define task continuations. Para ver una ilustración, vea el ejemplo.For an illustration, see the example.

Constructores

TaskFactory()

Inicializa una instancia de TaskFactory con la configuración predeterminada.Initializes a TaskFactory instance with the default configuration.

TaskFactory(CancellationToken)

Inicializa una instancia de TaskFactory con la configuración especificada.Initializes a TaskFactory instance with the specified configuration.

TaskFactory(CancellationToken, TaskCreationOptions, TaskContinuationOptions, TaskScheduler)

Inicializa una instancia de TaskFactory con la configuración especificada.Initializes a TaskFactory instance with the specified configuration.

TaskFactory(TaskCreationOptions, TaskContinuationOptions)

Inicializa una instancia de TaskFactory con la configuración especificada.Initializes a TaskFactory instance with the specified configuration.

TaskFactory(TaskScheduler)

Inicializa una instancia de TaskFactory con la configuración especificada.Initializes a TaskFactory instance with the specified configuration.

Propiedades

CancellationToken

Obtiene el token de cancelación predeterminado para este generador de tareas.Gets the default cancellation token for this task factory.

ContinuationOptions

Obtiene las opciones predeterminadas de continuación de tareas para este generador de tareas.Gets the default task continuation options for this task factory.

CreationOptions

Obtiene las opciones predeterminadas de creación de tareas para este generador de tareas.Gets the default task creation options for this task factory.

Scheduler

Obtiene el programador de tareas predeterminado para este generador de tareas.Gets the default task scheduler for this task factory.

Métodos

ContinueWhenAll(Task[], Action<Task[]>)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll(Task[], Action<Task[]>, CancellationToken)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll(Task[], Action<Task[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll(Task[], Action<Task[]>, TaskContinuationOptions)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, TaskContinuationOptions)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, TaskContinuationOptions)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, TaskContinuationOptions)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.Creates a continuation task that starts when a set of specified tasks has completed.

ContinueWhenAny(Task[], Action<Task>)

Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

ContinueWhenAny(Task[], Action<Task>, CancellationToken)

Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

ContinueWhenAny(Task[], Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

ContinueWhenAny(Task[], Action<Task>, TaskContinuationOptions)

Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>)

Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken)

Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, TaskContinuationOptions)

Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>)

Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken)

Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, TaskContinuationOptions)

Crea un objeto Task de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task that will be started upon the completion of any Task in the provided set.

ContinueWhenAny<TResult>(Task[], Func<Task,TResult>)

Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken)

Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, TaskContinuationOptions)

Crea un objeto Task<TResult> de continuación que se iniciará cuando se complete cualquier tarea del conjunto proporcionado.Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.

Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object)

Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)

Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync(IAsyncResult, Action<IAsyncResult>)

Crea un objeto Task que ejecuta una acción del método End cuando se completa la interfaz IAsyncResult especificada.Creates a Task that executes an end method action when a specified IAsyncResult completes.

FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions)

Crea un objeto Task que ejecuta una acción del método End cuando se completa la interfaz IAsyncResult especificada.Creates a Task that executes an end method action when a specified IAsyncResult completes.

FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions, TaskScheduler)

Crea un objeto Task que ejecuta una acción del método End cuando se completa la interfaz IAsyncResult especificada.Creates a Task that executes an end method action when a specified IAsyncResult completes.

FromAsync<TArg1,TArg2,TArg3,TResult>(Func<TArg1,TArg2,TArg3,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object)

Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync<TArg1,TArg2,TArg3,TResult>(Func<TArg1,TArg2,TArg3,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object, TaskCreationOptions)

Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync<TArg1,TArg2,TArg3>(Func<TArg1,TArg2,TArg3,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, TArg3, Object)

Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync<TArg1,TArg2,TArg3>(Func<TArg1,TArg2,TArg3,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, TArg3, Object, TaskCreationOptions)

Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync<TArg1,TArg2,TResult>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object)

Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync<TArg1,TArg2,TResult>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object, TaskCreationOptions)

Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync<TArg1,TArg2>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, Object)

Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync<TArg1,TArg2>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, Object, TaskCreationOptions)

Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync<TArg1,TResult>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, Object)

Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync<TArg1,TResult>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, Object, TaskCreationOptions)

Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync<TArg1>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, Object)

Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync<TArg1>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, Object, TaskCreationOptions)

Crea un objeto Task que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync<TResult>(Func<AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, Object)

Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync<TResult>(Func<AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, Object, TaskCreationOptions)

Crea un objeto Task<TResult> que representa un par de métodos Begin y End que se ajustan al modelo de programación asincrónica.Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>)

Crea un objeto Task<TResult> que ejecuta una función del método End cuando se completa la interfaz IAsyncResult especificada.Creates a Task<TResult> that executes an end method function when a specified IAsyncResult completes.

FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions)

Crea un objeto Task<TResult> que ejecuta una función del método End cuando se completa la interfaz IAsyncResult especificada.Creates a Task<TResult> that executes an end method function when a specified IAsyncResult completes.

FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions, TaskScheduler)

Crea un objeto Task<TResult> que ejecuta una función del método End cuando se completa la interfaz IAsyncResult especificada.Creates a Task<TResult> that executes an end method function when a specified IAsyncResult completes.

GetHashCode()

Sirve como función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
StartNew(Action)

Crea e inicia una tarea.Creates and starts a task.

StartNew(Action, CancellationToken)

Crea e inicia un objeto Task.Creates and starts a Task.

StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)

Crea e inicia un objeto Task.Creates and starts a Task.

StartNew(Action, TaskCreationOptions)

Crea e inicia un objeto Task.Creates and starts a Task.

StartNew(Action<Object>, Object)

Crea e inicia un objeto Task.Creates and starts a Task.

StartNew(Action<Object>, Object, CancellationToken)

Crea e inicia un objeto Task.Creates and starts a Task.

StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)

Crea e inicia un objeto Task.Creates and starts a Task.

StartNew(Action<Object>, Object, TaskCreationOptions)

Crea e inicia un objeto Task.Creates and starts a Task.

StartNew<TResult>(Func<Object,TResult>, Object)

Crea e inicia un objeto Task<TResult>.Creates and starts a Task<TResult>.

StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken)

Crea e inicia un objeto Task<TResult>.Creates and starts a Task<TResult>.

StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)

Crea e inicia un objeto Task<TResult>.Creates and starts a Task<TResult>.

StartNew<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)

Crea e inicia un objeto Task<TResult>.Creates and starts a Task<TResult>.

StartNew<TResult>(Func<TResult>)

Crea e inicia un objeto Task<TResult>.Creates and starts a Task<TResult>.

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

Crea e inicia un objeto Task<TResult>.Creates and starts a Task<TResult>.

StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)

Crea e inicia un objeto Task<TResult>.Creates and starts a Task<TResult>.

StartNew<TResult>(Func<TResult>, TaskCreationOptions)

Crea e inicia un objeto Task<TResult>.Creates and starts a Task<TResult>.

ToString()

Devuelve un valor de tipo string que representa el objeto actual.Returns a string that represents the current object.

(Heredado de Object)

Se aplica a

Seguridad para subprocesos

Todos los miembros públicos y protegidos de TaskFactory son seguros para subprocesos y se pueden usar simultáneamente desde varios subprocesos.All public and protected members of TaskFactory are thread-safe and may be used concurrently from multiple threads.

Consulte también: