ASP.NET Web API中IAsyncEnumerable与IActionResult混合的异常处理方案

问题场景 #

在ASP.NET Web API中，常规接口常使用IActionResult作为返回类型，方便在异常时返回BadRequest这类自定义错误响应；而IAsyncEnumerable<T>支持yield return语法，能实现无缓冲的流式返回，适合处理IO密集型的大结果集。

现在需要结合两者特性：既保留流式返回的无缓冲优势，又能将IAsyncEnumerable<T>执行过程中抛出的异常转换为自定义错误响应（如BadRequest），而非默认的500服务器错误。

常规异常处理示例：

public IActionResult DoSomething(string? data)
{
    try
    {
        if (data == null) 
            throw new ArgumentNullException(nameof(data));

        var myResults = SomeProcessing();
    
        return Ok(myResults);
    }
    catch
    {
        return BadRequest("Your request was not understood, etc.");
    }
}

流式返回示例：

public async IAsyncEnumerable<int> GetSlowData()
{
    var sample = Enumerable.Range(0, 10);

    foreach(var entry in sample)
    {
        await Task.Delay(1000);
        yield return entry;
    }
}

尝试的代码及问题 #

以下代码尝试结合两者，但IAsyncEnumerable<T>内部抛出的异常无法被外层try/catch捕获，最终返回500错误：

public IActionResult ReturnWithHandling()
{
    async IAsyncEnumerable<int> GetSlowData()
    {
        var sample = Enumerable.Range(0, 10);

        throw new Exception("Oh no! Sabotage!");

        foreach (var entry in sample)
        {
            await Task.Delay(1000);
            yield return entry;
        }
    }

    try
    {
        return Ok(GetSlowData());
    }
    catch
    {
        return BadRequest("GetSlowData had a problem with you.");
    }
}

核心原因：IAsyncEnumerable<T>的执行逻辑（包括异常抛出）会延迟到ASP.NET框架处理OkObjectResult时才触发，外层try/catch仅能捕获创建枚举对象时的异常，无法覆盖枚举迭代阶段的错误。

解决方案 #

1. 处理初始化阶段异常 #

如果异常发生在枚举初始化的同步代码段（比如参数校验、资源初始化），可以提前触发一次迭代来捕获异常，再返回包装后的流式结果：

public async Task<IActionResult> ReturnWithHandling()
{
    async IAsyncEnumerable<int> GetSlowData()
    {
        var sample = Enumerable.Range(0, 10);
        throw new Exception("Oh no! Sabotage!");
        
        foreach (var entry in sample)
        {
            await Task.Delay(1000);
            yield return entry;
        }
    }

    try
    {
        var asyncEnum = GetSlowData();
        using var enumerator = asyncEnum.GetAsyncEnumerator();
        var hasFirstItem = await enumerator.MoveNextAsync();

        return Ok(WrapEnumerator(enumerator, hasFirstItem));
    }
    catch (Exception ex)
    {
        return BadRequest($"GetSlowData initialization failed: {ex.Message}");
    }
}

private async IAsyncEnumerable<int> WrapEnumerator(IAsyncEnumerator<int> enumerator, bool hasFirstItem)
{
    if (hasFirstItem)
    {
        yield return enumerator.Current;
        while (await enumerator.MoveNextAsync())
        {
            yield return enumerator.Current;
        }
    }
    await enumerator.DisposeAsync();
}

这种方式能捕获枚举启动时的异常，但无法处理迭代过程中（比如第5个元素处理时）抛出的异常。

2. 处理全流程异常（初始化+迭代） #

要覆盖整个枚举生命周期的异常，需要自定义IAsyncEnumerable<T>包装器，结合异常过滤器实现：

步骤1：定义异常包装类和自定义异常

public class ErrorHandlingAsyncEnumerable<T> : IAsyncEnumerable<T>
{
    private readonly IAsyncEnumerable<T> _innerEnumerable;

    public ErrorHandlingAsyncEnumerable(IAsyncEnumerable<T> innerEnumerable)
    {
        _innerEnumerable = innerEnumerable;
    }

    public async IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
    {
        var enumerator = _innerEnumerable.GetAsyncEnumerator(cancellationToken);
        try
        {
            while (await enumerator.MoveNextAsync())
            {
                yield return enumerator.Current;
            }
        }
        catch (Exception ex)
        {
            // 抛出自定义异常，标记为需要返回BadRequest
            throw new StreamProcessingException("Stream processing failed", ex);
        }
        finally
        {
            await enumerator.DisposeAsync();
        }
    }
}

// 自定义异常，用于识别流式处理错误
public class StreamProcessingException : Exception
{
    public StreamProcessingException(string message, Exception innerException) 
        : base(message, innerException) { }
}

步骤2：添加异常过滤器

在Program.cs或Startup.cs中注册异常过滤器，将自定义异常转换为BadRequest响应：

builder.Services.AddControllers(options =>
{
    options.Filters.Add<StreamProcessingExceptionFilter>();
});

// 异常过滤器实现
public class StreamProcessingExceptionFilter : IExceptionFilter
{
    public void OnException(ExceptionContext context)
    {
        if (context.Exception is StreamProcessingException ex)
        {
            context.Result = new BadRequestObjectResult(ex.Message);
            context.ExceptionHandled = true;
        }
    }
}

步骤3：在接口中使用

public IActionResult ReturnWithHandling()
{
    async IAsyncEnumerable<int> GetSlowData()
    {
        var sample = Enumerable.Range(0, 10);
        foreach (var entry in sample)
        {
            await Task.Delay(1000);
            // 模拟迭代中抛出异常
            if (entry == 5)
                throw new Exception("Sabotage at entry 5!");
            yield return entry;
        }
    }

    // 前置参数校验可在此处处理，直接返回BadRequest
    // if (invalidCondition) return BadRequest(...);

    return Ok(new ErrorHandlingAsyncEnumerable<int>(GetSlowData()));
}

这种方式能捕获枚举初始化和迭代过程中的所有异常，并统一转换为BadRequest响应，同时保留流式返回的无缓冲特性。

内容的提问来源于stack exchange，提问作者SirKumbskull