How to avoid redundant DI code in ASP.NET Core

When doing the job with controllers in world wide web programs using ASP.Net Main or ASP.Net Main MVC, you could possibly have encountered code redundancy. For case in point, you could possibly have occur throughout controllers that use dependency injection (DI) to inject services that they need. If the code that injects the dependencies has been reused in many controllers, then you have code redundancy and violation of the DRY principle (never repeat oneself).

This post appears at DI code redundancy and displays how to make your customized foundation controller to stay away from such problems. To perform with the code illustrations furnished in this post, you should have Visual Studio 2019 put in in your process. If you never by now have a duplicate, you can download Visual Studio 2019 below.

Create an ASP.Net Main MVC venture in Visual Studio

Very first off, let us produce an ASP.Net Main venture in Visual Studio 2019. Subsequent these actions will produce a new ASP.Net Main MVC venture in Visual Studio 2019.

1. Start the Visual Studio IDE.
2. Click on on “Create new venture.”
3. In the “Create new project” window, decide on “ASP.Net Main World-wide-web App (Design-See-Controller)” from the list of templates shown.
4. Click on Future.
5. In the “Configure your new project” window, specify the title and locale for the new venture.
6. Optionally examine the “Place solution and venture in the exact same directory” examine box, depending on your tastes.
7. Click on Future.
8. In the “Additional Information” window demonstrated future, decide on .Net 5. as the focus on framework from the drop-down list at the major. Leave the “Authentication Type” as “None” (default).
9. Make certain that the examine packing containers “Enable Docker,” “Configure for HTTPS,” and “Enable Razor runtime compilation” are unchecked as we will not be using any of those people attributes below.
10. Click on Create.

A new ASP.Net Main MVC venture will be established. We’ll use this venture to perform with dependency injection in the subsequent sections of this post.

Now observe the actions outlined beneath to produce additional controllers in your venture.

1. Correct-click on the Controllers solution folder.
2. Pick out Include -> Controller.
3. In the “Add New Scaffolded Item” dialog, decide on API as the template (by default MVC will be selected).
4. Pick out the product “API Controller with read/produce steps.”
5. Click on Include.
6. In the “Add New Item” dialog demonstrated future, specify a title for your new controller.
7. Click on Include.

Designed-in foundation controller lessons in ASP.Net Main

There are two foundation lessons for controllers, particularly ControllerBase and Controller. The ControllerBase class implements the IController interface and presents the implementation for several approaches and houses. It defines an abstract approach named ExecuteCore that is applied to find the motion approach and execute it. You should use ControllerBase whenever you are building your APIs.

The Controller class extends the ControllerBase class, presents the ExecuteCore approach, and provides several approaches you can use in your controller lessons such as See() and Redirect(). Like ControllerBase, the Controller class is a foundation controller class with look at assist. Hence you should use the Controller class whenever you’re making your controllers in ASP.Net Main MVC. The ControllerBase class presents the needed integration with routing and HttpContext so that you can leverage them. It also consists of the code needed for controlling ViewData and TempData.

Put into action a foundation controller class in ASP.Net Main

When we produce a new API controller class in ASP.Net Main, it extends the ControllerBase class by default. Future, we’ll produce our implementation of a foundation controller. Our foundation controller class will increase the ControllerBase class of the framework.

In this article is an entity class we will be using in this case in point:

public class Purchase
    
        public int Id  get established 
        public int CustomerId  get established 
        public string Handle  get established        
    

Now produce the subsequent interface named IOrderManager that consists of the declaration of a approach named ProcessOrder.

public interface IOrderManager
    
        public void ProcessOrder(Purchase get)
    

Future produce the OrderManager class that extends the IOrderManager interface and implements its ProcessOrder approach.

public class OrderManager : IOrderManager

   public void ProcessOrder(Purchase get)
   
      throw new Process.NotImplementedException()
   

The subsequent code listing displays how you can produce a foundation controller class by deriving it from the ControllerBase class.

[Route("api/[controller]")]
[ApiController]
public class BaseController : ControllerBase

   secured readonly ILogger _logger
   secured readonly IOrderManager _orderManager
   public BaseController(ILogger logger,
   IOrderManager orderManager)
   
       _logger = logger
       _orderManager = orderManager
   

Extend your customized foundation controller in ASP.Net Main

You can now produce your controllers by deriving from this customized foundation controller we just established. The subsequent code listing illustrates how you can produce your controller class by extending it from the newly established foundation controller class.

[Route("api/[controller]")]
[ApiController]
public class OrderController : BaseController

   non-public readonly ILogger _logger
  [HttpGet]
   public string Get()
   
       return "OrderController"
   
   [HttpPost]
   public void ProcessOrder(Purchase get)
   
      _orderManager.ProcessOrder(get)
   

Having said that, you will discover that the over code will not compile. In this article is the mistake you will be introduced with in Visual Studio:

IDG

public abstract class BaseController : ControllerBase wherever T : BaseController

  non-public ILogger _logger
  secured ILogger Logger => _logger ?? (_logger = HttpContext.RequestServices.GetService>())       

[Route("api/[controller]")]
[ApiController]
public class OrderController : BaseController
    
        non-public readonly IOrderManager _orderManager
        public OrderController(IOrderManager orderManager)
        
            _orderManager = orderManager
        
        [HttpGet]
        public string Get()
        
            Logger.LogInformation("Hello Planet!")
            return "Inside the Get approach of OrderController"
        
        [HttpPost]
        public void ProcessOrder(Purchase get)
        
            _orderManager.ProcessOrder(get)
        
    

public void ConfigureServices(IServiceCollection services)
        
            services.AddTransient()
            services.AddControllersWithViews()