从Asp.Net Core控制器返回IAsyncEnumerable <T>和NotFound

对于返回an IAsyncEnumerable<T>和a NotFoundResult但仍以异步方式处理的控制器操作，正确的签名是什么？

我使用了此签名，由于IAsyncEnumerable<T>无法等待，因此无法编译：

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

这个编译很好，但是它的签名不是异步的。因此，我担心它是否会阻塞线程池线程：

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

我试过await foreach像这样使用循环，但是显然也不会编译：

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

选项2可以将的实现传递IAsyncEnumerable<>给Ok调用。ASP.NET Core管道负责枚举，并且IAsyncEnumerable<>从3.0开始就知道。

这是来自问题的电话，重复了以下内容：

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

调用Ok创建一个实例OkObjectResult，该实例继承ObjectResult。传递给的值Ok的类型为object，保存在ObjectResult的Value属性中。ASP.NET Core MVC使用命令模式，其中命令是的实现，IActionResult并使用的实现执行IActionResultExecutor<T>。

对于ObjectResult，ObjectResultExecutor用于将ObjectResult转换为HTTP响应。这是执行的ObjectResultExecutor.ExecuteAsync是IAsyncEnumerable<>知晓：

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

如代码所示，将Value检查该属性以查看其是否实现IAsyncEnumerable<>（详细信息隐藏在对的调用中TryGetReader）。如果是，ExecuteAsyncEnumerable则调用，它执行枚举，然后将枚举的结果传递到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上面的代码段中是进行枚举的位置。它被埋了一点，但是您可以在这里看到源：

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

将IAsyncEnumerable<>其枚举为List<>using await foreach，几乎按照定义，它不会阻塞请求线程。正如Panagiotis Kanavos在对OP的评论中指出的那样，在将响应发送回客户端之前，将完全执行此枚举。