Returning IAsyncEnumerable<T> and NotFound from Asp.Net Core Controller

Question

What is the right signature for a controller action that returns an IAsyncEnumerable<T> and a NotFoundResult but is still processed in an async fashion?

I used this signature and it doesn't compile because IAsyncEnumerable<T> isn't awaitable:

[HttpGet]
public async Task<IActionResult> GetAll(Guid id)
{
    try
    {
        return Ok(await repository.GetAll(id)); // GetAll() returns an IAsyncEnumerable
    }
    catch (NotFoundException e)
    {
        return NotFound(e.Message);
    }
}

This one compiles fine but its signature isn't async. So I'm worried whether it'll block thread pool threads or not:

[HttpGet]
public IActionResult GetAll(Guid id)
{
    try
    {
        return Ok(repository.GetAll(id)); // GetAll() returns an IAsyncEnumerable
    }
    catch (NotFoundException e)
    {
        return NotFound(e.Message);
    }
}

I tried using a await foreach loop on like this but that obviously wouldn't compile either:

[HttpGet]
public async IAsyncEnumerable<MyObject> GetAll(Guid id)
{
    IAsyncEnumerable<MyObject> objects;
    try
    {
        objects = repository.GetAll(id); // GetAll() returns an IAsyncEnumerable
    }
    catch (NotFoundException e)
    {
        return NotFound(e.Message);
    }

    await foreach (var obj in objects)
    {
        yield return obj;
    }
}

Answer 1

Option 2, which passes an implementation of IAsyncEnumerable<> into the Ok call, is fine. The ASP.NET Core plumbing takes care of the enumeration and is IAsyncEnumerable<>-aware as of 3.0.

Here's the call from the question, repeated for context:

return Ok(repository.GetAll(id)); // GetAll() returns an IAsyncEnumerable

The call to Ok creates an instance of OkObjectResult, which inherits ObjectResult. The value passed in to Ok is of type object, which is held in the ObjectResult's Value property. ASP.NET Core MVC uses the command pattern, whereby the command is an implementation of IActionResult and is executed using an implementation of IActionResultExecutor<T>.

For ObjectResult, ObjectResultExecutor is used to turn the ObjectResult into a HTTP response. It's the implementation of ObjectResultExecutor.ExecuteAsync that is IAsyncEnumerable<>-aware:

public virtual Task ExecuteAsync(ActionContext context, ObjectResult result)
{
    // ...

    var value = result.Value;

    if (value != null && _asyncEnumerableReaderFactory.TryGetReader(value.GetType(), out var reader))
    {
        return ExecuteAsyncEnumerable(context, result, value, reader);
    }

    return ExecuteAsyncCore(context, result, objectType, value);
}

As the code shows, the Value property is checked to see if it implements IAsyncEnumerable<> (the details are hidden in the call to TryGetReader). If it does, ExecuteAsyncEnumerable is called, which performs the enumeration and then passes the enumerated result into ExecuteAsyncCore:

private async Task ExecuteAsyncEnumerable(ActionContext context, ObjectResult result, object asyncEnumerable, Func<object, Task<ICollection>> reader)
{
    Log.BufferingAsyncEnumerable(Logger, asyncEnumerable);

    var enumerated = await reader(asyncEnumerable);
    await ExecuteAsyncCore(context, result, enumerated.GetType(), enumerated);
}

reader in the above snippet is where the enumeration occurs. It's buried a little, but you can see the source here:

private async Task<ICollection> ReadInternal<T>(object value)
{
    var asyncEnumerable = (IAsyncEnumerable<T>)value;
    var result = new List<T>();
    var count = 0;

    await foreach (var item in asyncEnumerable)
    {
        if (count++ >= _mvcOptions.MaxIAsyncEnumerableBufferLimit)
        {
            throw new InvalidOperationException(Resources.FormatObjectResultExecutor_MaxEnumerationExceeded(
                nameof(AsyncEnumerableReader),
                value.GetType()));
        }

        result.Add(item);
    }

    return result;
}

The IAsyncEnumerable<> is enumerated into a List<> using await foreach, which, almost by definition, doesn't block a request thread. As Panagiotis Kanavos called out in a comment on the OP, this enumeration is performed in full before a response is sent back to the client.