Почему эти асинхронные методы С# не выполняются после Task.Delay()?

What happened to "Boilwater end" statement and all other method calls? If I put async/await only in the BoilWater method, I get the same output.

Как было сказано zerkms, ваша программа завершает работу до того, как ваша задача будет завершена.

If I remove await from all method calls -

Я считаю, что если await не вызывается нигде в асинхронной задаче, то она просто обрабатывает ее синхронно; это объясняет, почему на выходе отображаются все «стартовые» сообщения.

Что касается того, что случилось с операторами «конца», я считаю, что если вы не ждете Task.Delay, то он фактически не будет ждать (задерживать), и ваш код будет продолжаться. На самом деле я только что нашел это, который объясняет это лучше.

Общий рабочий процесс асинхронного метода заключается в том, что код до ожидания запускается синхронно (т.е. как есть), затем возвращается объект задачи с ожидаемой задачей, и все, что после ожидания помещается как продолжение этой задачи который должен быть выполнен, когда задача завершится.

Теперь, если ожидается только BoilWater, стартовое сообщение выполняется синхронно, а все остальные вызовы ставятся как продолжение. Поскольку MakeBreakfast не ожидается, программа выполнится до того, как BoilWater сможет завершить/подождать свои миллисекунды, и, следовательно, продолжения (то есть другие задачи) не выполняются.

Если BoilWater не ожидается, другие MakeBreakfast задачи не ставятся как продолжение BoilWater задачи. Это означает, что BoilWater снова запускается до Task.Delay и возвращает это как задачу. Однако, поскольку эта задача не ожидается, следующая MakeBreakfast запускается таким же образом. По сути, все MakeBreakfast задачи запускаются последовательно, и MakeBreakfast может вернуться только тогда, когда SpreadWater запускается и возвращает свою задачу. Опять же, задачи по-прежнему выполняются в фоновом режиме, ожидая своих миллисекунд, но программа завершает работу до этого периода времени, и, таким образом, продолжения сообщения о закрытии не могут быть запущены.

Ваша программа начинается с вызова Main и завершается, когда это делается.

Так как Main просто создает экземпляр Program, а затем вызывает MakeBreakfast(), который возвращает Task обратно в main, как только он достигает своего первого await. Таким образом, Main существует почти сразу.

Давайте немного изменим код, чтобы увидеть, так ли это:

static void Main(string[] args)
{
    Program p = new Program();
    p.MakeBreakfast();
    Console.WriteLine("Done!");
    Console.ReadLine();
}

public async Task MakeBreakfast()
{
    Console.WriteLine("Starting MakeBreakfast");
    Thread.Sleep(1000);
    Console.WriteLine("Calling await BoilWater()");
    await BoilWater();
    Console.WriteLine("Done await BoilWater()");
    StartToaster();
    PutTeainWater();
    PutBreadinToaster();
    SpreadButter();
}

Теперь, если я позволю этому завершиться, я увижу этот вывод:

Starting MakeBreakfast
Calling await BoilWater()
BoilWater start
Done!
BoilWater end
Done await BoilWater()
StartToaster start
PutTeainWater start
StartToaster end
PutBreadinToaster start
SpreadButter start
SpreadButter end
PutTeainWater end
PutBreadinToaster end

Код действительно попадает в await, а затем возвращается к Main.

Чтобы код был завершен правильно, нам нужно await все. У вас есть два способа сделать это:

(1)

static async Task Main(string[] args)
{
    Program p = new Program();
    await p.MakeBreakfast();
    Console.WriteLine("Done!");
    Console.ReadLine();
}

public async Task MakeBreakfast()
{
    await BoilWater();
    await StartToaster();
    await PutTeainWater();
    await PutBreadinToaster();
    await SpreadButter();
}

Теперь, когда это запускается, вы получаете этот вывод:

BoilWater start
BoilWater end
StartToaster start
StartToaster end
PutTeainWater start
PutTeainWater end
PutBreadinToaster start
PutBreadinToaster end
SpreadButter start
SpreadButter end
Done!

(2)

static async Task Main(string[] args)
{
    Program p = new Program();
    await p.MakeBreakfast();
    Console.WriteLine("Done!");
    Console.ReadLine();
}

public async Task MakeBreakfast()
{
    var tasks = new[]
    {
        BoilWater(),
        StartToaster(),
        PutTeainWater(),
        PutBreadinToaster(),
        SpreadButter(),
    };
    await Task.WhenAll(tasks);
}

Теперь эта версия запускает все задачи завтрака одновременно, но ждет их завершения, прежде чем вернуться.

Вы получаете этот вывод:

BoilWater start
StartToaster start
PutTeainWater start
PutBreadinToaster start
SpreadButter start
StartToaster end
SpreadButter end
BoilWater end
PutTeainWater end
PutBreadinToaster end
Done!

Альтернатива, которая дает более логичное выполнение кода - вскипятите воду, затем заварите чай; и запустить тостер, приготовить тост, намазать тост - может быть так:

public async Task MakeBreakfast()
{
    async Task MakeTea()
    {
        await BoilWater();
        await PutTeainWater();      
    }

    async Task MakeToast()
    {
        await StartToaster();
        await PutBreadinToaster();
        await SpreadButter();           
    }       
    await Task.WhenAll(MakeTea(), MakeToast());
}

Это дает:

BoilWater start
StartToaster start
StartToaster end
PutBreadinToaster start
BoilWater end
PutTeainWater start
PutTeainWater end
PutBreadinToaster end
SpreadButter start
SpreadButter end
Done!