Microsoft Dependency Injection Addscoped

#Microsoft Dependency Injection Addscoped Full Working Example#

Update Custom Class example. It is now availble for a read here. You followed a few steps to register and get your dependencies automatically resolved by the built-in IoC Container.Steve mentioned in our discussion he was working on a post to do with the Dependency Injection with multiple implementations interface. In the previous section, you implemented Dependency Injection for an ASP.NET Web application. Dependency Injection in a Console Application.

Sorry ASP.NET Core!AddScoped < IServiceFactory. This was a hangover from how unity did it due to it's limitations and how I had implemented the pattern previously. There are several different ways that you can achieve the same outcome:After a review by Steve Gordon (thanks Steve!) he has pointed out that the ASP.NET Core IoC container can't handle IMathOperator as a depenency however it can handle IEnumerable and not require the additional factory pattern.

IMathOperator interface which defines the operator type and the calculation each implementation will execute. How do I implement this?Working with the basic arithmatic operators, which James uses, as an example you will need the following: Based on the selection specified, in my example this will be an enum value, it will locate a single processor which corresponds to that processor which will execute. What is the strategy pattern?The basic premise is the calling code has a single point of entry determined by user input or system specification. They help with code readability, maintainability and allow for applying SOLID principles to your code.I have used the strategy pattern a number of times over the years for various tasks and the main part that I enjoy, once setup correctly, is that the main class does not need to be changed when adding more functionality into the processing.To implement the strategy pattern cleanly you need to harness the power of using Dependency Injection and not rely on the concrete implementations.After reading Strategy Pattern Implementations there are many ways of implementing the pattern but none of the methods James discuses harnesses the power of DI.

Implementing in ASP.NET CoreIt is possible to implement the above in ASP.NET Core with some juggling but you will require the use of a factory pattern at the point the dependencies are registered. ASP.NET Core RestrictionsThe IoC container which ships with ASP.NET Core is relatively basic, it allows for registration of implementatons with dependency trees however does not allow for the registration of the same interface with different implementations as Unity would and use them with a requirement of IMathOperator. However this is not possible in the basic IoC in ASP.NET Core. Public class MathStrategy : IMathStrategyPrivate readonly IMathOperator _operators Public MathStrategy(IMathOperator operators)Once they have been injected in when the Calculate method is called the first processor which corresponds to the operator specified is located and executed.With IoC containers, such as Unity, you can register all the concrete implementations of IMathOperator as named registrations and then when an array of IMathOperator are requested it injects all of the implementations. This way the consuming code does not care about the implementation of the concrete classes and has a level of abstraction to allow for single responsibility.Int Calculate(int a, int b, Operator op) The implementation of the strategy requires to have the implementations of IMathOperator injected into it's constructor through DI.

Microsoft Dependency Injection Addscoped Full Working Example

ConclusionWe've looked at implementing the Strategy pattern harnessing the power of DI in ASP.NET Core to keep the consuming processing code SOLID.A full working example can be found on Github. The Single Responsibility Principle is applied to all concrete implementations as they have a single function to handle, the strategy is dealing with finding the appropriate implementation and calling it and the Controller calls the method and returns the result not caring about the processing.But what about the Open/Closed principle? Well if we were to include a new operator, multiplication for example, we whould have to extend the enum, create a new concrete implementation and register it and that would be it.Unfortunately as we are not using an IoC container such as Unity then we need to modify the factory which is a slight violation but I think one we can live with for the power of the functionality added. Open for extensionI mentioned at the beginning this method allows for applying the SOLID principles. This allows for easy unit testing as you can test each implementation separately and it means the HomeController has only one interface to mock. Public class HomeController : ControllerBasePrivate readonly IMathStrategy _mathStrategy Public HomeController(IMathStrategy mathStrategy)Int result = _mathStrategy.Calculate(a, b, Operator.Add) As you can see from the above, the HomeController does not care about how the strategy pattern is implemented nor how the calculations are found and executed, it only cares about calling it with the values and specifying the action to run on them.