在两个不同的ASP.Net核心API控制器中，如何确保定义相同的端点？

我需要有两个数据api，它们都应该有相同的方法或端点来实现。 例如，我们可以使用一个接口来确保两个类具有相同的函数。在另一个世界里，你定义了契约

public interface ITest
{
    void Foo();
}

public class Test : ITest
{
    public void Foo()
    {
        // Some logic
    }
}

public class OtherTest : ITest
{
    public void Foo()
    {
        // Some other logic 
    }
}

类似地，我希望控制器具有如下的路由和方法。假设在一个控制器中添加了一个新操作，那么代码应该在另一个控制器中强制执行它

DemoController
-- GET demo/api/action1
-- GET demo/api/action2

TestController
-- GET test/api/action1
-- GET test/api/action2

---

如何做到这一点？

好吧，你已经回答了你自己的问题，真的。如果您希望确保在多个类上实现相同的方法，那么接口就是用于此目的的。只要让每个控制器实现相同的接口，就可以了

至于确保类似的路由结构，可以使用继承。定义基本抽象控制器类。您可以选择在这里实现接口，并将所需的方法作为抽象“实现”。任何派生类都将被迫在基类上实现任何抽象方法，因此它具有与接口相同的效果。这在技术上意味着您可以放弃接口，只要依赖基类强制实现即可。由你决定。然后，您可以将路由属性应用于抽象方法，如下所示：

[Route("[controller]/api")]
public abstract BaseApiController : ControllerBase
{
    [HttpGet("action1")]
    public abstract IActionResult Action1();

    [HttpGet("action2")]
    public abstract IActionResult Action2();
}

---

如果您正在处理需要类似业务逻辑的不同实体，则可以创建通用基本控制器，并注入通用依赖项：

[Route("api/[controller]")]
[ApiController]
public class GenericBaseController<T> : ControllerBase where T : class
{
    private readonly ILogger _logger;

    public GenericBaseController(ILogger<GenericBaseController<T>> logger) {
        _logger = logger;
    }

    [HttpGet("get")]
    public IActionResult Get()
    {
        //...
    }

    [HttpPost("post")]
    public IActionResult Post(T value)
    {
        //...
    }
}

[路由（“api/[控制器]”）]
[ApiController]
公共类GenericBaseController:ControllerBase，其中T:class
{
专用只读ILogger\u记录器；
公共GenericBaseController（ILogger记录器）{
_记录器=记录器；
}
[HttpGet（“get”）]
public IActionResult Get（）
{
//...
}
[HttpPost（“post”）]
公共IActionResult Post（T值）
{
//...
}
}

然后可以扩展通用控制器：

[Route("api/[controller]")]
[ApiController]
public class MyFirstController : MyFirstController<FirstModel>
{
    public GenericBaseController(ILogger<MyFirstController> logger) : base(logger) 
    {
    }
}

[路由（“api/[控制器]”）]
[ApiController]
公共类MyFirstController:MyFirstController
{
公共GenericBaseController（ILogger记录器）：基本（记录器）
{
}
}

另一个：

[Route("api/[controller]")]
[ApiController]
public class MySecondController : GenericBaseController<SecondModel>
{
    public MySecondController(ILogger<MySecondController> logger) : base(logger) 
    {
    }
}

[路由（“api/[控制器]”）]
[ApiController]
公共类MySecondController:GenericBaseController
{
公共MySecondController（ILogger记录器）：基本（记录器）
{
}
}

如果每个继承的控制器具有相同的逻辑，则不必为其重新创建方法，或者如果需要，可以扩展其中任何一个：

[Route("api/[controller]")]
[ApiController]
public class MyThirdController : GenericBaseController<ThirdModel>
{
    public MyThirdController(ILogger<MyThirdController> logger) : base(logger) 
    {
    }

    [HttpPost("post")]
    public IActionResult Post(ThirdModel value)
    {
        // do some logic...
        return base.Post(value);
    }
}

[路由（“api/[控制器]”）]
[ApiController]
公共类MyThirdController:GenericBaseController
{
公共控制器（ILogger记录器）：基本（记录器）
{
}
[HttpPost（“post”）]
公共IActionResult Post（第三个模型值）
{
//做一些逻辑。。。
返回base.Post（值）；
}
}

不清楚，请理解，但您可以查看路由筛选器，将路由筛选器添加到操作中。您描述的路由只能手动设置，因为它的路由通常是

{domain}/{controller}/{action}

，根据您想要的示例，路由更像

{domain}/api/Testcontroller/action1

和

{domain}/api/DemoController/action1

我的意思是，除了继承之外，在回答其他问题之前，您能否先澄清一下这一部分，这是您想要的还是完全符合您的示例。