очікуємо vs Task.Wait - Тупик?

Я не зовсім розумію різницю між Task.Waitі await.

У сервісі ASP.NET WebAPI у мене є щось подібне до таких функцій:

public class TestController : ApiController
{
    public static async Task<string> Foo()
    {
        await Task.Delay(1).ConfigureAwait(false);
        return "";
    }

    public async static Task<string> Bar()
    {
        return await Foo();
    }

    public async static Task<string> Ros()
    {
        return await Bar();
    }

    // GET api/test
    public IEnumerable<string> Get()
    {
        Task.WaitAll(Enumerable.Range(0, 10).Select(x => Ros()).ToArray());

        return new string[] { "value1", "value2" }; // This will never execute
    }
}

Де Getбуде тупик.

Що може спричинити це? Чому це не викликає проблем, коли я використовую блокування очікування, а не await Task.Delay?

Waitі await- хоча подібні концептуально - насправді абсолютно різні.

Waitбуде синхронно блокувати, поки завдання не буде виконано. Тож поточний потік буквально блокується в очікуванні завершення завдання. Як загальне правило, слід використовувати « asyncдо кінця вниз»; тобто не блокуйте asyncкод. У своєму блозі я розглядаю деталі того, як блокування в асинхронному коді викликає тупик .

awaitбуде асинхронно чекати, поки завдання не буде виконано. Це означає, що поточний метод "призупинено" (його стан захоплено), і метод повертає незавершене завдання своєму абоненту. Пізніше, коли awaitвираз закінчується, решта методу планується як продовження.

Ви також згадали про "кооперативний блок", під яким я припускаю, що ви маєте на увазі завдання, яке ви виконуєте, Waitможливо виконати в очікуванні потоку. Бувають ситуації, коли це може статися, але це оптимізація. Існує багато ситуацій, коли це не може статися, наприклад, якщо завдання призначене для іншого планувальника, або якщо воно вже запущене, або якщо це завдання без коду (наприклад, у прикладі вашого коду: Waitне можна виконати Delayзавдання в рядку, оскільки немає коду для нього).

Ви можете знайти мій async/ awaitінтро корисно.

На основі прочитаного з різних джерел:

awaitВираз не блокує нитка , на якій він виконується. Натомість він змушує компілятор підписати решту asyncметоду як продовження очікуваного завдання. Потім контроль повертається до абонента asyncметоду. Коли завдання виконано, він викликає його продовження, а виконання asyncметоду поновлюється там, де воно припинено.

Щоб дочекатися завершення синглу task, ви можете викликати його Task.Waitметод. Виклик Waitметоду блокує нитку виклику до тих пір, поки екземпляр одного класу не завершить виконання. Безпараметричний Wait()метод використовується для беззастережного очікування, поки завдання не буде виконано. Завдання імітує роботу, викликаючи Thread.Sleepметод спати протягом двох секунд.

Ця стаття також добре прочитана.

Деякі важливі факти не були наведені в інших відповідях:

"async await" є складнішим на рівні CIL і, таким чином, коштує часу на пам'ять та процесор.

Будь-яке завдання можна скасувати, якщо час очікування неприйнятний.

У випадку, коли "асинхронізація чекає", у нас немає обробника такої задачі, щоб її скасувати чи контролювати.

Використання Завдання є більш гнучким, ніж "асинхронізація чекає".

Будь-яка функція синхронізації може бути завершена асинхронізацією.

public async Task<ActionResult> DoAsync(long id) 
{ 
    return await Task.Run(() => { return DoSync(id); } ); 
} 

"Асинхронізація чекає" породжує багато проблем. Зараз ми не очікуємо, що заява буде досягнута без налагодження часу виконання та налагодження контексту. Якщо спочатку дочекатися не досягнутого, все блокується . Десь навіть очікують, що, здається, все-таки заблоковано:

https://github.com/dotnet/runtime/isissue/36063

Я не бачу, чому я повинен жити з дублюванням коду для методу синхронізації та асинхронізації або з використанням хаків.

Висновок: Створювати завдання вручну та керувати ними набагато краще. Обробник Завдання дає більше контролю. Ми можемо контролювати Завдання та керувати ними:

https://github.com/lsmolinski/MonitoredQueueBackgroundWorkItem

Вибачте за мою англійську.