Tag: net

I had this base class that inherits from interface where all methods created where the same resource name, same method parameters in MVC controllers to be used. So I design that every time I add or changed the parent interface, it will then notify others in the code editor that something need to be implemented or has changed. I am asking if these are a good practice. So I decided to design my architecture like these:

The goal here is that MVC Controller Company1 and Company2 or any future controller addition as long they inherit BaseApiController can make a request to logic GetEmployeeContractual

MVC Controller for Company1

(Authorize)
(Route("api/(controller)"))
(ApiController)
public class Company1Controller : BaseApiController<CompanyController>
{
    private readonly IBusLogic _busLogic;
    public CompanyController (
        ILogger<CompanyController> logger,
        IBaseActionClass baseActionClass,
        BusLogic busLogic
        ) : base(logger, baseActionClass)
    {
        _busLogic = busLogic;
    }

    (HttpGet("GetEmployee"))
    public async Task<IEnumerable<SomeData>> GetEmployee((FromQuery) SomeDataParamData paramData,
        CancellationToken cancellationToken)
    {
        LogInfo(paramData, ControllerContext.ActionDescriptor.ActionName,
            ControllerContext.ActionDescriptor.ControllerName);

        return await _busLogic.GetEmployee(paramData, cancellationToken);
    }
}

MVC Controller for Company2

(Authorize)
(Route("api/(controller)"))
(ApiController)
public class Company2Controller : BaseApiController<CompanyController>
{
    private readonly IBusLogic _busLogic;
    public CompanyController (
        ILogger<CompanyController> logger,
        IBaseActionClass baseActionClass,
        BusLogic busLogic
        ) : base(logger, baseActionClass)
    {
        _busLogic = busLogic;
    }       
}

Base Api Controller

public abstract class BaseApiController<T> : LogBaseController<T>, IBaseActionClass where T : class
{
    private readonly IBaseActionClass _baseActionClass;
    private readonly string _controllerName = typeof(T).Name;

    protected BaseApiController(ILogger<T> logger, IBaseActionClass baseActionClass = null) :
        base(logger)
    {
        _baseActionClass = baseActionClass;
    }

    (HttpGet("GetEmployeeContractual"))
    public virtual async Task<IEnumerable<SomeData>> GetEmployeeContractual(
        (FromQuery) SomeParamData paramData,
        CancellationToken cancellationToken)
    {
        LogInfo(paramData, ControllerContext.ActionDescriptor.ActionName, _controllerName);
        return await _baseActionClass.GetEmployeeContractual(paramData, cancellationToken);
    }
}

Base Class

public class BaseActionClass : IBaseActionClass 
{
    private readonly IRepositoryDataService<SomeData> _repositoryDataService;

    public IBaseActionClass(IRepositoryDataService<SomeData> repositoryDataService)
    {
        _repositoryDataService = repositoryDataService;
    }

    public async Task<IEnumerable<SomeData>> GetPaymentVendorDt(SomeParamData someData, CancellationToken cancellationToken)
    {
        return await _repositoryDataService.ExecuteList(someData, cancellationToken);
    }
}

**Base Interface IBaseActionClass **

public interface IBaseActionClass : IBaseAction {}

**Interface IBaseAction **

public interface IBaseAction 
{
    Task<IEnumerable<SomeData>> GetPaymentVendorDt(SomeParamData someData, CancellationToken cancellationToken);
}

Now, notice that each time I want to add signature method here in interface named IBaseAction, the base class named **BaseActionClass ** and base Api Controller named BaseApiController will also gets notified to implement or should changed their implementations.

So again, my question is: Is this fine or a Best practice? Or is it fine for MVC Controllers to inherit interface like this?