c# - parallel - Task.Factory.StartNew con async lambda y Task.WaitAll

task parallel library c#

Question

Estoy tratando de usar Task.WaitAll en una lista de tareas. La Tasks.WaitAll es que las tareas son una lambda asíncrona que rompe las Tasks.WaitAll . Espera Tasks.WaitAll ya que nunca espera.

Aquí hay un bloque de código de ejemplo:

List<Task> tasks = new List<Task>();
tasks.Add(Task.Factory.StartNew(async () =>
{
using (dbContext = new DatabaseContext())
{
var records = await dbContext.Where(r => r.Id = 100).ToListAsync();
//do long cpu process here...
}
}
Task.WaitAll(tasks);
//do more stuff here 

Esto no espera debido a la lambda asíncrona. Entonces, ¿cómo se supone que debo esperar las operaciones de E / S en mi lambda?

Answer 1

Esto no espera debido a la lambda asíncrona. Entonces, ¿cómo se supone que debo esperar las operaciones de E / S en mi lambda?

La razón por la que Task.WaitAll no espera la finalización del trabajo de E / S presentado por su lambda asíncrona es porque Task.Factory.StartNew realidad devuelve una Task<Task> . Dado que su lista es una List<Task> (y la Task<T> deriva de la Task ), espera en la tarea externa iniciada por StartNew , mientras ignora la interna creada por el lambda asíncrono. Es por eso que dicen Task.Factory.StartNew es peligroso con respecto a async.

¿Cómo puedes arreglar esto? Podría llamar explícitamente a la Task<Task>.Unwrap() para obtener la tarea interna:

List<Task> tasks = new List<Task>();
tasks.Add(Task.Factory.StartNew(async () =>
{
using (dbContext = new DatabaseContext())
{
var records = await dbContext.Where(r => r.Id = 100).ToListAsync();
//do long cpu process here...
}
}).Unwrap());

O como dijeron otros, podría llamar a Task.Run en Task.Run lugar:

tasks.Add(Task.Run(async () => /* lambda */);

Además, dado que desea hacer las cosas bien, querrá usar Task.WhenAll , por qué se puede esperar asincrónicamente, en lugar de Task.WaitAll que bloquea sincrónicamente:

await Task.WhenAll(tasks);

Answer 2

Puedes hacer así.

 void Something()
{
List<Task> tasks = new List<Task>();
tasks.Add(ReadAsync());
Task.WaitAll(tasks.ToArray());
}
async Task ReadAsync() {
using (dbContext = new DatabaseContext())
{
var records = await dbContext.Where(r => r.Id = 100).ToListAsync();
//do long cpu process here...
}
}

Answer 3

tienes que usar el método Task.ContinueWith . Me gusta esto

List<Task> tasks = new List<Task>();
tasks.Add(Task.Factory.StartNew(() =>
{
using (dbContext = new DatabaseContext())
{
return dbContext.Where(r => r.Id = 100).ToListAsync().ContinueWith(t =>
{
var records = t.Result;
// do long cpu process here...
});
}
}
}

Answer 4

Task.Factory.StartNew no reconoce a los delegados async ya que no hay sobrecarga que acepte una función que devuelve una Task .

Esta más otras razones (ver StartNew es peligroso ) es la razón por la que deberías usar Task.Run aquí:

tasks.Add(Task.Run(async () => ...