如何从中间件调用控制器方法，并且只允许从该中间件调用该方法

Question

我有一个控制器，它有两个功能和一个中间件。

我的中间件

try
{
var request = httpContext.Request;
if (/* some logic here */)
{
await _next(httpContext);
// Some logic here
var someReturnValue = someFunction();
// Need to call the Controller Method here
// call SaveStaging(someReturnValue);
}
else
{
await _next(httpContext);
}
}
catch (Exception ex)
{
await _next(httpContext);
}

在我的控制器中

[Authorize(AuthenticationSchemes = "APIKeyAuthentication")]
[LogAction]
[ApiController]
[Route("api/[controller]/[action]")]
public class MyController : ControllerBase
{
private IHttpContextAccessor _accessor;
public MyController(IHttpContextAccessor accessor)
{
_accessor = accessor;
}
[HttpPost]
public async Task<ActionResult<ServiceResult>> PostData([FromBody] DataObj request)
{
ServiceResult result = new ServiceResult();
result.isSuccessful = true;
return Ok(result);
}
public async Task SaveStaging(int logNumber)
{
}
}

所以，最初，用户将调用PostData端点。在这个方法中，它将返回接受用户发布的数据。然后在中间件中，我需要做一些事情，最后，我想调用Controller中的SaveStaging方法。我希望这个SaveStaging方法只能由中间件访问，而不应该由用户直接调用。

所以我的问题是：

1. 如何从中间件调用此方法
2. 如何限制SaveStaging只能由中间件访问

Answer 1

您应该考虑将SaveStaging封装到服务中，因为这似乎是一个跨领域的问题。除此之外，通过重构来实现分层体系结构可能是明智的。

由于这是.NET核心，我建议完全接受依赖注入，并将服务注入到中间件中。

public interface IStagingService 
{
Task Save(int logNumber);
}
public class MyController : ControllerBase
{
private readonly IStagingService _service;
private readonly IHttpContextAccessor _accessor;
public MyController(IStagingService service, IHttpContextAccessor accessor)
{
_service = service ?? throw new ArgumentNullException(nameof(service));
_accessor = accessor  ?? throw new ArgumentNullException(nameof(accessor));;
}
//....
}
public class MyMiddleware
{
private readonly RequestDelegate _next;
private readonly IStagingService _service;
public RequestCultureMiddleware(RequestDelegate next, IStagingService service)
{
_next = next;
_service = service ?? throw new ArgumentNullException(nameof(service));
}
public async Task InvokeAsync(HttpContext context)
{
// ...
}

一开始，您的服务可能会从小而简单开始。如果应用程序增长，这一层的复杂性可能会增加，从而产生对一些门面服务(即由服务组成的服务(的需求，也许还需要一些数据访问之类的提供商。