Когда конвертировать IEnumerable в IAsyncEnumerable

Преимущество IAsyncEnumerable<T> по сравнению с IEnumerable<T> заключается в том, что первый потенциально более масштабируем, потому что он не использует поток, пока он перечисляется. Вместо синхронного метода MoveNext у него есть асинхронный MoveNextAsync. Это преимущество становится спорным вопросом, когда MoveNextAsync всегда возвращает уже завершенное ValueTask<bool> (enumerator.MoveNextAsync().IsCompleted == true), и в этом случае у вас есть только синхронное перечисление, замаскированное под асинхронное. В этом случае нет преимущества масштабируемости. Именно это и происходит в коде, показанном в вопросе. У вас есть шасси Porsche с двигателем Trabant, спрятанным под капотом.

Если вы хотите получить более глубокое понимание происходящего, вы можете перебрать асинхронную последовательность вручную вместо удобного await foreach и собрать отладочную информацию по каждому шагу перебора:

[HttpGet("asyncsale")]
public async IAsyncEnumerable<Product> GetOnSaleProductsAsync()
{
    var products = _productContext.Products.OrderBy(p => p.Name).AsAsyncEnumerable();

    Stopwatch stopwatch = new();
    await using IAsyncEnumerator<Product> enumerator = products.GetAsyncEnumerator();
    while (true)
    {
        stopwatch.Restart();
        ValueTask<bool> moveNextTask = enumerator.MoveNextAsync();
        TimeSpan elapsed1 = stopwatch.Elapsed;
        bool isCompleted = moveNextTask.IsCompleted;
        stopwatch.Restart();
        bool moved = await moveNextTask;
        TimeSpan elapsed2 = stopwatch.Elapsed;
        Console.WriteLine($"Create: {elapsed1}, Completed: {isCompleted}, Await: {elapsed2}");
        if (!moved) break;

        Product product = enumerator.Current;
        if (product.IsOnSale)
        {
            yield return product;
        }
    }
}

Скорее всего, вы обнаружите, что все MoveNextAsync операции завершаются при создании, по крайней мере, некоторые из них имеют значимое elapsed1 значение, и все они имеют нулевое elapsed2 значение.

По какой причине сначала нужно преобразовать в IAsyncEnumerable и выполнить ожидание для foreach?

Если вы хотите воспользоваться преимуществами асинхронного ввода-вывода. Всякий раз, когда вы извлекаете данные из базы данных в случае IEnumerable, это блокирующая операция. Вызывающий поток (ваш foreach) должен ждать, пока не придет ответ базы данных. В то время как в случае IAsyncEnumerable поток вызывающего абонента (ваш await foreach) может быть назначен другому запросу. Таким образом, он обеспечивает лучшую масштабируемость.

Это просто для упрощения синтаксиса или есть какие-то преимущества?

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

Есть ли преимущество в преобразовании любого IEnumerable в IAsyncEnumerable или только в том случае, если базовый IEnumerable также поддерживает потоковую передачу, например, через yield?

В вашем конкретном примере у вас есть два IAsyncEnumerables. Ваш источник данных и ваш http-ответ. Вам не обязательно использовать оба. Абсолютно нормально транслировать IEnumerable. Также можно асинхронно извлекать источник данных и возвращать результат всякий раз, когда доступны все данные.

Если у меня уже есть список, полностью загруженный в память, бессмысленно ли преобразовывать его в IAsyncEnumerable?

Что ж, если вы хотите передать ответ в потоковом режиме, то да, асинхронно извлекать источник данных не нужно.