如何为ASP.NET MVC（非Core版）Web API优雅提供可选同步方法？

针对你遇到的ASP.NET MVC非Core版AuthorizationAttribute不支持异步钩子的问题，我整理了几个实用且优雅的方案，既能保留原有的异步API，又能提供同步调用入口：

方案1：通过查询参数区分请求模式（最简单直接） #

不需要修改现有路由，只需在请求中添加一个查询参数（比如mode=sync），让API根据参数选择执行同步或异步逻辑。你可以选择在同一个Action里处理，或者拆分两个Action通过参数约束匹配：

方式A：单Action分支处理 #

[Route("api/v1/users/{userGuid}")]
public async Task<IHttpActionResult> GetUser(Guid userGuid, [FromUri] string expand = null, [FromUri] string mode = "async")
{
    if (mode.Equals("sync", StringComparison.OrdinalIgnoreCase))
    {
        // 执行同步业务逻辑
        var user = _userService.GetUser(userGuid, expand);
        return Ok(user);
    }
    
    // 原异步逻辑
    var user = await _userService.GetUserAsync(userGuid, expand);
    return Ok(user);
}

方式B：双Action+参数约束 #

public class UsersController : ApiController
{
    [Route("api/v1/users/{userGuid}")]
    public async Task<IHttpActionResult> GetUserAsync(Guid userGuid, [FromUri] string expand = null)
    {
        var user = await _userService.GetUserAsync(userGuid, expand);
        return Ok(user);
    }

    [Route("api/v1/users/{userGuid}")]
    [ActionName("GetUser")]
    public IHttpActionResult GetUserSync(Guid userGuid, [FromUri] string expand = null, [FromUri] string mode = "sync")
    {
        // 这里可以通过自定义约束确保mode=sync时才匹配此Action
        var user = _userService.GetUser(userGuid, expand);
        return Ok(user);
    }
}

方案2：自定义Action选择器（最灵活优雅） #

通过自定义ActionSelectorAttribute，可以根据请求头、查询参数甚至请求内容自动选择对应的同步/异步Action，完全对客户端透明：

1. 实现自定义Action选择器 #

public class SyncAsyncActionSelector : ActionSelectorAttribute
{
    public override bool IsValidForRequest(HttpControllerContext controllerContext, HttpActionDescriptor actionDescriptor)
    {
        // 优先从请求头获取模式，没有则查查询参数
        var requestMode = controllerContext.Request.Headers.GetValues("X-Request-Mode")?.FirstOrDefault()
                           ?? controllerContext.Request.GetQueryNameValuePairs()
                               .FirstOrDefault(kv => kv.Key.Equals("mode", StringComparison.OrdinalIgnoreCase)).Value;

        // 根据模式匹配对应的Action
        if (string.Equals(requestMode, "sync", StringComparison.OrdinalIgnoreCase))
        {
            return actionDescriptor.ActionName.Equals("GetUserSync", StringComparison.OrdinalIgnoreCase);
        }
        else
        {
            return actionDescriptor.ActionName.Equals("GetUserAsync", StringComparison.OrdinalIgnoreCase);
        }
    }
}

2. 在控制器上应用选择器 #

[SyncAsyncActionSelector]
public class UsersController : ApiController
{
    [Route("api/v1/users/{userGuid}")]
    public async Task<IHttpActionResult> GetUserAsync(Guid userGuid, [FromUri] string expand = null)
    {
        var user = await _userService.GetUserAsync(userGuid, expand);
        return Ok(user);
    }

    [Route("api/v1/users/{userGuid}")]
    public IHttpActionResult GetUserSync(Guid userGuid, [FromUri] string expand = null)
    {
        var user = _userService.GetUser(userGuid, expand);
        return Ok(user);
    }
}

客户端只需在请求头添加X-Request-Mode: sync，或者携带?mode=sync参数，API就会自动路由到同步方法。

方案3：复用业务逻辑，拆分Action入口（基础规范） #

不管选择哪种路由方案，核心是把业务逻辑从Action中抽离，让同步和异步Action都调用同一个业务层的对应方法，避免代码重复：

// 业务层服务（核心逻辑抽离）
public class UserService
{
    // 同步业务方法
    public User GetUser(Guid userGuid, string expand)
    {
        // 实际同步数据查询逻辑
    }

    // 异步业务方法
    public async Task<User> GetUserAsync(Guid userGuid, string expand)
    {
        // 实际异步数据查询逻辑，比如调用异步DB驱动
        return await _dbContext.Users.FindAsync(userGuid);
    }
}

// API控制器
public class UsersController : ApiController
{
    private readonly UserService _userService = new UserService();

    [Route("api/v1/users/{userGuid}")]
    public async Task<IHttpActionResult> GetUserAsync(Guid userGuid, [FromUri] string expand = null)
    {
        return Ok(await _userService.GetUserAsync(userGuid, expand));
    }

    [Route("api/v1/users/{userGuid}/synchronous")] // 你原来的路由方案
    public IHttpActionResult GetUserSync(Guid userGuid, [FromUri] string expand = null)
    {
        return Ok(_userService.GetUser(userGuid, expand));
    }
}

各方案对比 #

总结推荐 #

如果希望路由简洁且灵活，优先选择自定义Action选择器方案；如果追求快速实现，查询参数区分是最快的方式；如果需要明确的语义化路由，你的原方案也完全可行——核心是保证业务逻辑的复用，避免同步/异步代码重复。

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