Как работают await async

Question

Прочитал много литературы но пока никак не могу понять как работает await и async. Ну хоть убейте. Везде примеры с httpclient, но для меня они не понятны. Пытаюсь разобраться сам. Вот что я понял:

Как только наш код встречает await происходит возврат управления. После завершения ожидаемой операции метод восстанавливается. Точнее продолжает выполнение с того места, на котором остановился, когда столкнулся с await.

Хорошо, я написал пару строк кода(возможно просто что-то сделал не так)

async Task myMethod() {
    int sum = 0;
    await SomeCycleAsync();
    Console.WriteLine("выполнился цикл2");
}
async Task SomeCycleAsync() {
    var myTask = await ResultOfCycle();

    Console.WriteLine("выполнился цикл1");
}
async Task < int > ResultOfCycle() {
    int sum = 0;
    for (int i = 0; i < 1000000000; i++) {
        sum += i;
    }
    return sum;
}

private void Form1_Load(object sender, EventArgs e) {
    myMethod();
}

1. В методе myMethod встречается слово await и, на сколько я понимаю, управление должна перейти обратно в form_load, верно?

2. Во время выполнения метода SomeCycleAsync встречается await, т.е. по логике управление должно перейти к Console.WriteLine("выполнился цикл2"); Но результат работы такой:

выполнился цикл1

выполнился цикл2

Объясните мне пожалуйста почему? Совсем не понимаю

Answer 1

Смотрите.

Сами по себе async/await не включают таинственным образом многопоточность/асинхронность. Они лишь создают условия, при которых эту самую асинхронность легко реализовать.

На самом деле, когда вызывается async-метод, происходит следующее.

1. Начинает синхронно выполняться async-метод. Если этот метод заканчивается до первого await, результат доставляется синхронно, и из метода возвращается уже закончившийся, завершённый Task.
2. Если в процессе выполнения встретился await, система проверяет, отработало ли уже задание, на которое вызывался await. Если это задание отработало, то подставляется его результат, и синхронное выполнение продолжается дальше.
3. Если задание, на которое происходит await, ещё не отработало, в этот момент из метода возвращается незавершённый Task. В этой точке внешний код получает управление и продолжает выполняться. Например, этот код может записать Task в переменную и продолжать заниматься своими делами. Или он может выполнить await на полученный Task, и поскольку этот Task ещё не завершён, внешний код в этот момент аналогично отдаст управление ещё более внешнему коду, и. т. д.
4. Когда Task, на который происходит await, завершится (произведя результат или исключение), код после await возобновит свою работу.

---

В вашем случае происходит следующее:

1. Вызывается Form1_Load.
2. Выполняется строчка myMethod();. Этот код произведёт Task, который впоследствии будет просто проигнорирован.
3. Начинает выполняться код метода myMethod. Выполняется синхронно int sum = 0;. Для выполнения следующей строчки для начала нужно выполнить метод SomeCycleAsync а затем await на результирующий Task.
4. Начинается выполнение SomeCycleAsync. Для получения Task'а, по которому нужно делать await, запускается метод ResultOfCycle.
5. Начинается выполнение ResultOfCycle(). Поскольку нигде в нём нету асинхронных вызовов, он выполняется полностью синхронно. Из метода возвращается завершённый Task.
6. Управление возвращается в SomeCycleAsync. Выполняется await на Task, полученный в предыдущем пункте. Поскольку этот Task уже завершён, в переменную myTask просто записывается int-результат. Выполняется строчка Console.WriteLine("выполнился цикл1");. На этом выполнение метода SomeCycleAsync оканчивается. Поскольку в нём не было асинхронного ожидания, возвращается завершённый Task.
7. Управление возвращается в метод myMethod(). Начинает выполняться await на полученный Task. Поскольку Task завершён, ничего не происходит, метод продолжает синхронно выполняться. Срабатывает строчка Console.WriteLine("выполнился цикл2");, метод заканчивается, возвращая завершённый Task.
8. Управление возвращается в Form_Load. Полученный Task игнорируется, выполнение завершается.

---

Для ваших целей правильнее было бы явно запускать вычисления асинхронным образом. Например, так:

async Task myMethod() {
    await SomeCycleAsync();
    Console.WriteLine("выполнился цикл-2");
}

async Task SomeCycleAsync() {
    Console.WriteLine("стартует цикл");
    // это запускает длинное вычисление на пуле потоков
    var result = await Task.Run(ResultOfCycle);
    Console.WriteLine("выполнился цикл, результат: " + result);
}

int ResultOfCycle()
{
    int sum = 0;
    for (int i = 0; i < 1000000000; i++)
        sum += i;
    return sum;
}

private async void Form1_Load(object sender, EventArgs e)
{
    await myMethod();
}

Answer 2

У тебя ResultOfCycle() должна вернуть Task<int>, но возвращает sum, которая является просто int. В самом методе нету второго потока, в котором он бы выполнялся. Await пишется перед объектом Task или методом, возвращающим объект Task.

Пример для Task(вызов функции, которая ничего не возвращает):

static void Main(string[] args)
{
    My();

    for (int i = 1; i <= 10; i++)
    {
        Thread.Sleep(1000);
        Console.WriteLine($"* {i*1000}");
    }
    Console.ReadLine();
}

static async void My()
{
    await GetMessage(3000);
}

static Task GetMessage(int time)
{
    return Task.Run(() => {
        Thread.Sleep(time);
        Console.WriteLine($"zxzxz {time.ToString()}");
    });
}

Пример для Task<T>(вызов функции, которая возвращает объект типа T или в нашем случае string):

static void Main(string[] args)
{
    My();

    for (int i = 1; i < 10; i++)
    {
        Thread.Sleep(1000);
        Console.WriteLine($"* {i*1000}");
    }
    Console.ReadLine();
}

static async void My()
{
    string message = await GetMessage(3000);
    Console.WriteLine(message);
}

static Task<string> GetMessage(int time)
{
    return Task.Run(() => {
        Thread.Sleep(time);
        return $"zxzxz {time.ToString()}";
    });
}