路由外部ID转控制器内部Guid参数：Filter失效问题及方案问询

我有一个重复出现的场景：控制器接收string类型的外部ID，调用服务转换为Guid类型的内部ID后再处理逻辑。最初的实现代码如下：

[HttpGet("{externalId}")]
public async IActionResult GetInternalId(string externalId)
{
    var internalId = await _externalService.GetInternalId(externalId);
    return internalId == null ? NotFound() : Ok(internalId);
}

为了复用逻辑，我尝试用IAsyncActionFilter封装转换逻辑：

public class ExternalIdActionFilter : IAsyncActionFilter
{
    private readonly ExternalService _externalService;
    public ExternalIdActionFilter(ExternalService externalService) =>
        _externalService = externalService;

    public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
    {
        var externalId = context.RouteData.Values["externalId"]?.ToString();
        if (string.IsNullOrEmpty(externalId))
        {
            context.Result = new BadRequestResult();
            return;
        }

        var internalId = await _externalService.GetInternalId(externalId);

        if (internalId == null)
        {
            context.Result = new NotFoundResult();
            return;
        }

        context.RouteData.Values.Add("internalId", internalId);
        await next();
    }
}

应用Filter后，控制器的internalId始终是Guid.Empty：

[HttpGet("{externalId}")]
[ServiceFilter(typeof(ExternalIdActionFilter))]
public IActionResult GetAccountId(Guid internalId)
{        
    return Ok(internalId);
}

请问哪里出错了？有没有更优实现方式？另外，我想保留原有接收内部ID的控制器：

[HttpGet("{internalId}")]
public IActionResult GetAccountId(Guid internalId)
{        
    return Ok(internalId);
}

通过中间件实现外部ID到内部ID的转换并转发，这种方案可行吗？

一、ActionFilter失效的原因 #

ASP.NET Core的模型绑定在ActionFilter执行之前就已完成。你在Filter中修改RouteData.Values时，控制器方法的参数绑定已经结束，所以internalId还是默认的Guid.Empty。

修正方案：直接修改ActionExecutingContext的ActionArguments集合，替换参数值：

public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
    var externalId = context.RouteData.Values["externalId"]?.ToString();
    if (string.IsNullOrEmpty(externalId))
    {
        context.Result = new BadRequestResult();
        return;
    }

    var internalId = await _externalService.GetInternalId(externalId);

    if (internalId == null)
    {
        context.Result = new NotFoundResult();
        return;
    }

    // 直接覆盖Action方法的参数值
    context.ActionArguments["internalId"] = internalId.Value;
    await next();
}

修改后，模型绑定会使用你传入的参数值，控制器就能拿到正确的Guid。

二、中间件转发方案的可行性 #

这种方案是可行的，但需要注意几个细节：

1. 避免暴露内部ID：如果使用3xx重定向，客户端会看到内部Guid，若有隐私需求，建议直接转发请求而非重定向。
2. 保留请求上下文：转发时要保留原请求的Header、Query等信息，防止丢失业务数据。
3. 依赖注入注意事项：中间件是单例的，不能通过构造函数注入ExternalService，需通过context.RequestServices获取：

示例实现：

app.MapGet("{externalId}", async (HttpContext context, RequestDelegate next) =>
{
    var externalId = context.GetRouteValue("externalId")?.ToString();
    if (string.IsNullOrEmpty(externalId))
    {
        context.Response.StatusCode = StatusCodes.Status400BadRequest;
        return;
    }

    var externalService = context.RequestServices.GetRequiredService<ExternalService>();
    var internalId = await externalService.GetInternalId(externalId);

    if (internalId == null)
    {
        context.Response.StatusCode = StatusCodes.Status404NotFound;
        return;
    }

    // 修改请求路径，转发到内部路由
    context.Request.Path = $"/your-controller/{internalId}";
    // 让管道继续处理修改后的请求
    await next(context);
});

但这种方式需要明确控制器的路由路径，灵活性不如ActionFilter或模型绑定器方案。

三、更优实现：自定义模型绑定器 #

相比Filter，自定义模型绑定器是更贴合ASP.NET Core设计的方案，专门用于参数绑定逻辑，复用性更强：

1. 实现IModelBinder：

public class ExternalIdModelBinder : IModelBinder
{
    private readonly ExternalService _externalService;

    public ExternalIdModelBinder(ExternalService externalService)
    {
        _externalService = externalService;
    }

    public async Task BindModelAsync(ModelBindingContext bindingContext)
    {
        var externalId = bindingContext.ValueProvider.GetValue("externalId").FirstValue;
        if (string.IsNullOrEmpty(externalId))
        {
            bindingContext.ModelState.AddModelError("externalId", "外部ID不能为空");
            return;
        }

        var internalId = await _externalService.GetInternalId(externalId);
        if (internalId == null)
        {
            bindingContext.ModelState.AddModelError("externalId", "外部ID不存在");
            return;
        }

        bindingContext.Result = ModelBindingResult.Success(internalId.Value);
    }
}

2. 创建绑定器提供器：

public class ExternalIdModelBinderProvider : IModelBinderProvider
{
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context.Metadata.ModelType == typeof(Guid) && 
            context.BindingInfo.BinderType == typeof(ExternalIdModelBinder))
        {
            var externalService = context.Services.GetRequiredService<ExternalService>();
            return new ExternalIdModelBinder(externalService);
        }
        return null;
    }
}

3. 在Program.cs注册：

builder.Services.AddControllers(options =>
{
    options.ModelBinderProviders.Insert(0, new ExternalIdModelBinderProvider());
});

4. 控制器中使用：

[HttpGet("{externalId}")]
public IActionResult GetAccountId([ModelBinder(BinderType = typeof(ExternalIdModelBinder))] Guid internalId)
{        
    return Ok(internalId);
}

这种方式将转换逻辑融入模型绑定流程，代码更简洁，也符合框架设计理念。

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