ASP.NET项目中如何在Controller B内调用Controller A的方法？

核心原则：抽离共享业务逻辑 #

控制器的职责是接收HTTP请求、调用业务逻辑、返回响应，直接在控制器间调用会违反单一职责原则，导致代码耦合度高、难以维护和测试。正确的做法是把Controller A和Controller B共用的功能抽离到独立的服务类中。

步骤1：创建共享服务类 #

把Controller A中需要被复用的逻辑封装到一个服务类里，比如：

public class UserService
{
    // 假设这是Controller A中需要被Controller B调用的功能
    public string GetUserFullName(int userId)
    {
        // 这里写具体的业务逻辑，比如从数据库获取用户信息
        return $"用户{userId}的全名";
    }
}

步骤2：注册服务到依赖注入容器 #

在Program.cs（ASP.NET Core 6+）或者Startup.cs（旧版本）中注册这个服务：

// ASP.NET Core 6+
builder.Services.AddScoped<UserService>();

步骤3：在两个控制器中注入服务 #

现在Controller A和Controller B都可以通过构造函数注入这个服务，各自调用需要的逻辑：

Controller A的实现

[ApiController]
[Route("api/[controller]")]
public class UserController : ControllerBase
{
    private readonly UserService _userService;

    public UserController(UserService userService)
    {
        _userService = userService;
    }

    [HttpGet("{userId}/fullname")]
    public IActionResult GetUserFullName(int userId)
    {
        var fullName = _userService.GetUserFullName(userId);
        return Ok(fullName);
    }
}

Controller B的实现

[ApiController]
[Route("api/[controller]")]
public class OrderController : ControllerBase
{
    private readonly UserService _userService;

    public OrderController(UserService userService)
    {
        _userService = userService;
    }

    [HttpGet("{orderId}/user-info")]
    public IActionResult GetOrderUserInfo(int orderId)
    {
        // 假设从订单中拿到userId
        int userId = 123;
        var userFullName = _userService.GetUserFullName(userId);
        return Ok(new { OrderId = orderId, UserFullName = userFullName });
    }
}

特殊场景：必须复用Controller A的整个端点逻辑？ #

如果确实需要复用Controller A的完整端点逻辑（包括参数验证、模型绑定等），可以通过IActionInvokerFactory来调用控制器的Action，而不是直接实例化控制器：

实现示例 #

[ApiController]
[Route("api/[controller]")]
public class OrderController : ControllerBase
{
    private readonly IActionInvokerFactory _actionInvokerFactory;
    private readonly IServiceProvider _serviceProvider;

    public OrderController(IActionInvokerFactory actionInvokerFactory, IServiceProvider serviceProvider)
    {
        _actionInvokerFactory = actionInvokerFactory;
        _serviceProvider = serviceProvider;
    }

    [HttpGet("invoke-user-endpoint")]
    public async Task<IActionResult> InvokeUserEndpoint(int userId)
    {
        // 构造模拟的HTTP请求上下文
        var httpContext = new DefaultHttpContext { RequestServices = _serviceProvider };
        httpContext.Request.Path = $"/api/user/{userId}/fullname";
        httpContext.Request.Method = HttpMethods.Get;

        // 创建Action上下文
        var actionContext = new ActionContext(httpContext, new RouteData(), new ControllerActionDescriptor
        {
            ControllerName = "User",
            ActionName = "GetUserFullName"
        });

        // 调用Action
        var invoker = _actionInvokerFactory.CreateInvoker(actionContext);
        await invoker.InvokeAsync();

        // 获取返回结果
        return httpContext.Response.StatusCode switch
        {
            StatusCodes.Status200OK => Ok(await httpContext.Response.ReadFromJsonAsync<string>()),
            _ => StatusCode(httpContext.Response.StatusCode)
        };
    }
}

注意：这种方式仅适用于特殊场景，因为它会引入控制器间的耦合，尽量优先使用抽离服务的方案。

为什么不推荐静态方法或localhost调用？ #

• 静态方法：难以进行单元测试，无法依赖注入其他服务，容易导致代码变成“静态地狱”，维护性差。
• localhost调用：会产生额外的HTTP请求开销，增加系统复杂度，还会引入跨域、端口依赖等问题，测试和部署都很麻烦。

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