Может ли длинная цепочка асинхронного ожидания вызвать большое потребление памяти? (Теоретически)

Поскольку каждый конечный автомат хранится в памяти, может ли это вызвать большое потребление памяти?

Очень маловероятно. Каждый конечный автомат будет занимать несколько десятков байтов снаружи.

Так что это будет иметь значение только тогда, когда у вас их очень много. Вложение в действительности не будет причиной этого, но выполнение членов Task[] может.

Но это не совсем новая или другая форма любого другого типа ресурса.

Существует дополнительная стоимость, но она относительно небольшая.

Дополнительные расходы по сравнению с обычной функцией:

• Класс для государственной машины
• экземпляр этого класса
• один int для стадии исполнения
• Экземпляр AsyncTaskMethodBuilder

Кроме того, локальные переменные функции будут преобразованы в поля конечного автомата. Это перемещает некоторую память из стека в кучу.

Я рекомендую декомпилировать простую асинхронную функцию, чтобы увидеть сгенерированный конечный автомат и понять, чего ожидать.

Для этого также есть несколько онлайн-инструментов (например, sharplab.io). См. Результаты декомпиляции тривиальной асинхронной функции.

Не уверен насчет фактического потребления памяти, но тем не менее; шаблон, который вы описываете, по крайней мере, имеет некоторые другие проблемы.

await вызовет некоторые накладные расходы при хранении данных и переключении контекста синхронизации (если есть).

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

Отсутствие захвата возвращаемого значения после await можно считать запахом кода.

Итак, несколько примеров:

скорее

pivate Task<Foo> SomeWork()
{
    var theTask = ...
    return theTask;
}    

затем

pivate async Task<Foo> SomeWork()
{
    var theTask = ...
    return await theTask;
}    

так как

Звонок тот же:

pivate async Task SomeWrapper()
{
    var result = await someWorkObj.SomeWork();

    //some processing.     
}

---

а также

скорее

public async Task ConsumeAsync()
{
      Task[] tasks = new { task1, task2, ... };

       await Task.WhenAll(tasks);

      //do things
}

затем

public async Task<T> ConsumeAsync()
{
      await a();
      await b();
      await c();
      await d();
      //..
}

так как

Возможно чрезмерное (вложенное) await которое будет иметь дополнительные издержки. Я постараюсь найти несколько статей на эту тему.