De la tâche.Usine.StartNew avec async lambda et de la Tâche.WaitAll

Je suis en train d'utiliser Task.WaitAll sur une liste de tâches. Le truc, c'est que les tâches sont un async lambda qui rompt Tasks.WaitAll comme il n'attend jamais.

Voici un exemple de bloc de code:

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

Cela ne veut pas attendre, car le lambda asynchrone. Alors, comment suis-je censé attendre opérations d'e/S dans ma lambda?

  • Quel est le point de commencer une tâche sur un autre thread si la première chose que vous faites après que vous commencez, il est bloquer sur le Task.WaitAll appel? Vous obtiendrez de meilleures performances se débarrasser de ToListAsync et de le rendre juste ToList et en l'exécutant en mode synchrone. (ou si vous voulez utiliser ToListAsync ensuite, vous devez utiliser asynchrone tout en haut de votre pile d'appel.
InformationsquelleAutor Jacob Roberts | 2015-06-13
  1. 17

    Task.Factory.StartNew ne reconnaît pas async délégués qu'il n'y a pas de surcharge qui accepte une fonction retournant une Task.

    Cela en plus d'autres raisons (voir StartNew est dangereux) est pourquoi vous devriez être en utilisant Task.Run ici:

    tasks.Add(Task.Run(async () => ...
    • Cela a fonctionné... en quelque sorte. Pas sûr que le problème maintenant, mais je suis une tâche annulée exception d'essayer de renvoyer une chaîne de caractères. Semble comme un problème différent, donc je vais commencer un nouveau fil. Merci.
    • Trop mauvais Tâche.exécuter ne vous donne pas TaskCreationOptions
    • Task.Factory.StartNew(Func<Task> function semble être disponible dans .NET Standard 1.6 - l'on peut avoir à Unwrap() l'résultant Taskbien 🙂
    InformationsquelleAutor Charles Mager
  2. 18

    Cela ne veut pas attendre, car le lambda asynchrone. Alors, comment suis-je censé
    attendent opérations d'e/S dans ma lambda?

    La raison Task.WaitAll ne pas attendre l'achèvement de l'OI travail présenté par votre async lambda est parce que Task.Factory.StartNew retourne en fait un Task<Task>. Depuis votre liste est une List<Task> (et Task<T> dérive de Task), vous vous attendez à l'extérieur de la tâche a commencé par StartNew, tandis que ignorant l'intérieur créé par le lambda asynchrone. C'est pourquoi ils disent Task.Factory.StartNew est dangereux à l'égard de async.

    Comment pouvez-vous résoudre ce problème? Vous pourriez appeler explicitement Task<Task>.Unwrap() afin d'obtenir l'intérieure de la tâche:

    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());

    Ou comme d'autres ont dit, vous pouvez l'appeler Task.Run à la place:

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

    Aussi, puisque vous voulez faire les choses, vous aurez envie d'utiliser Task.WhenAll, pourquoi est asynchrone waitable, au lieu de Task.WaitAll qui synchrone blocs:

    await Task.WhenAll(tasks);
    InformationsquelleAutor Yuval Itzchakov
  3. 0

    Vous pouvez faire comme ceci.

        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...
        }
    }
    • C'était presque une bonne réponse. Vous ne devez pas bloquer sur Task.WaitAll si vous utilisez async parce que vous pouvez facilement l'impasse.
    • WaitAll est ce que Jacob voulait faire en fonction de la question.
    InformationsquelleAutor hebinda
  4. -2

    vous devez utiliser le Task.ContinueWith méthode. Comme ce

    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...
            });
        }
    }
}
    InformationsquelleAutor couven92