Aufgabe.Factory.StartNew mit asynchronen lambda und Aufgabe.WaitAll

Ich versuche zu verwenden Task.WaitAll auf eine Liste von Aufgaben. Die Sache ist, die Aufgaben sind eine asynchrone lambda bricht Tasks.WaitAll wie Sie es noch nie wartet.

Hier ist ein Beispiel code-block:

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

Diese nicht warten, weil der async-lambda. Also, wie soll ich das warten auf I/O-Operationen in meinem lambda?

Was ist der Punkt, über den Start einer Aufgabe auf einen anderen thread, wenn das erste, was Sie tun, nachdem Sie es starten, ist block auf die Task.WaitAll nennen? Sie erhalten eine bessere Leistung loszuwerden ToListAsync und machen es einfach ToList und es läuft synchron. (oder wenn Sie verwenden möchten ToListAsync dann müssen Sie die Verwendung von async-den ganzen Weg bis Ihre call-stack.

InformationsquelleAutor Jacob Roberts | 2015-06-13

  1. 15

    Task.Factory.StartNew nicht erkennen async Delegierten, da es keine überlastung, übernimmt eine Funktion Rückgabe eines Task.

    Diesem und anderen Gründen (siehe StartNew ist gefährlich) ist, warum Sie verwenden sollten Task.Run hier:

    tasks.Add(Task.Run(async () => ...
    Das hat funktioniert... irgendwie. Nicht sicher, ob das Problem jetzt, aber ich bin immer eine Aufgabe abgebrochen Ausnahme versucht, einen string zurückzugeben. Scheint ein anderes Problem, also ich fange einen neuen thread SO. Danke.
    Schade, Aufgabe.führen Sie nicht geben Sie TaskCreationOptions
    Task.Factory.StartNew(Func<Task> function scheint .NET Standard 1.6 - man hätte Unwrap() die daraus resultierenden Taskaber 🙂

    InformationsquelleAutor Charles Mager

  2. 17

    Diese nicht warten, weil der async-lambda. Also wie soll ich
    warten auf I/O-Operationen in meinem lambda?

    Den Grund Task.WaitAll nicht warten, für die Fertigstellung des IO-Arbeit vorgestellt, die durch die asynchrone lambda ist, da Task.Factory.StartNew tatsächlich gibt eine Task<Task>. Da Eure Liste ist List<Task> (und Task<T> stammt aus Task), Sie warten auf die äußere Aufgabe wurde gestartet durch StartNew, während ignorieren die innere erstellt durch die asynchrone lambda. Dies ist, warum Sie sagen Task.Factory.StartNew ist gefährlich mit Bezug auf async.

    Wie könnte man dieses Problem beheben? Sie könnten explizit aufrufen Task<Task>.Unwrap() um die innere Aufgabe:

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

    Oder wie andere sagten, Sie nennen könnte Task.Run statt:

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

    Auch, denn Sie wollen die Dinge richtig tun, werden Sie verwenden möchten Task.WhenAll warum ist asynchron wartemöglichkeit, statt Task.WaitAll welche synchron Blöcke:

    await Task.WhenAll(tasks);

    InformationsquelleAutor Yuval Itzchakov

  3. 0

    Können Sie dies so tun.

        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...
        }
    }
    Das war fast eine gute Antwort. Sie sollten nicht blockieren, auf Task.WaitAll wenn Sie async da kann man leicht einen deadlock.
    WaitAll ist, was Jakob tun wollte, nach der Frage.

    InformationsquelleAutor hebinda

  4. -2

    verwenden Sie den Task.ContinueWith Methode. Wie diese

    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

Schreibe einen Kommentar