Devolver IAsyncEnumerable <T> y NotFound desde Asp.Net Core Controller

¿Cuál es la firma correcta para una acción de controlador que devuelve un IAsyncEnumerable<T>y a NotFoundResultpero que aún se procesa de forma asíncrona?

IAsyncEnumerable<T>Usé esta firma y no se compila porque no está a la espera:

[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);
    }
}

Este se compila bien pero su firma no es asíncrona. Entonces me preocupa si bloqueará los hilos del grupo de hilos o no:

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

Intenté usar un await foreachbucle como este, pero eso obviamente tampoco compilaría:

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

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

La opción 2, que pasa una implementación IAsyncEnumerable<>a la Okllamada, está bien. La fontanería ASP.NET Core se encarga de la enumeración y tiene IAsyncEnumerable<>conocimiento de 3.0.

Aquí está la llamada de la pregunta, repetida para el contexto:

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

La llamada a Okcrea una instancia de OkObjectResult, que hereda ObjectResult. El valor pasado a Okes de tipo object, que se celebra en el ObjectResult's Valuepropiedad. ASP.NET Core MVC usa el patrón de comando , mediante el cual el comando es una implementación de IActionResulty se ejecuta usando una implementación de IActionResultExecutor<T>.

Para ObjectResult, ObjectResultExecutorse utiliza para convertir el ObjectResulten una respuesta HTTP. Es la implementación de ObjectResultExecutor.ExecuteAsynceso es 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);
}

Como muestra el código, la Valuepropiedad se verifica para ver si se implementa IAsyncEnumerable<>(los detalles están ocultos en la llamada a TryGetReader). Si lo hace, ExecuteAsyncEnumerablese llama, que realiza la enumeración y luego pasa el resultado enumerado a 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);
}

readeren el fragmento anterior es donde ocurre la enumeración. Está enterrado un poco, pero puedes ver la fuente aquí :

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;
}

El IAsyncEnumerable<>se enumera en un List<>uso await foreach, que, casi por definición, no bloquea un hilo de solicitud. Como Panagiotis Kanavos llamó en un comentario sobre el OP, esta enumeración se realiza en su totalidad antes de que se envíe una respuesta al cliente.