This is the ‘D’ in SOLID, also see Dependency Injection Frameworks
Definition (Robert C. Martin and Micah Martin)
The Dependency Inversion Principle states that high-level modules should not depend on low-level modules. Both should depend on abstractions. Furthermore, abstractions should not depend on details, but rather details should depend on abstractions. This is from the Agile Principles, Patterns, and Practices in C# book by Robert C. Martin and Micah Martin.
Definition (Mark Seemann)
“Dependency Injection is a set of software design principles and patterns that enable us to develop loosely coupled code.”
Inversion of Control
IOC (Inversion of control) is a general parent term while DI (Dependency injection) is a subset of IOC.
IOC is a concept where the flow of application is inverted. … DI provides objects that an object needs. So rather than the dependencies construct themselves they are injected by some external means.
- https://stackoverflow.com/questions/6550700/inversion-of-control-vs-dependency-injection
- https://www.codeproject.com/Articles/592372/Dependency-Injection-DI-vs-Inversion-of-Control-IO
Inversion of Control of IoC can be implemented in two ways, one using a Service Locator and another is Dependency Injection.
Implementation - Dependency Injection
This is a Strategy Pattern. The most common implementation is constructor injection. Dependencies are passed in via the constructor. The constructor then is being honest with the things that call it in that it is explicitly stating the things that it needs in order for it to be in a valid state and to be able to do the work that it expects to be able to do.
PROS
- Classes are self-document what they need
- Works well with or without a container
- Classes are always in a valid state once constructed.
CONS
- Constructors can end up with many parameters/dependencies, which is a design smell.
- Some features, EG, serialization, may require a default constructor.
- Some methods in the class may not require things that other methods require, which is a design smell.
The dependencies can also be injected using:
Implementation - Service Locator
With the Service Locator, the class is still responsible for creating its dependencies. It just uses the service locator to do it. With DI, the class is given its dependencies.
- https://martinfowler.com/articles/injection.html
- https://www.c-sharpcorner.com/UploadFile/dacca2/service-locator-design-pattern/
References & Sample Code
- https://github.com/carlpaton/SOLID/blob/master/5_DIP_code_problem.md
- https://github.com/carlpaton/SOLID/blob/master/5_DIP_code_refactor.md
docs.microsoft.com
- Dependency injection in ASP.NET Core
- Dependency injection into controllers in ASP.NET Core
- ASP.NET MVC 4 Dependency Injection
pluralsight.com
Other
- https://blog.elmah.io/appsettings-in-aspnetcore/
- https://cmatskas.com/net-core-dependency-injection-with-constructor-parameters-2/
- https://www.codeproject.com/Tips/1033646/SOLID-Principle-with-Csharp-Example
- https://www.intertech.com/Blog/the-single-responsibility-principle-with-c-examples/
- https://en.wikipedia.org/wiki/SOLID_(object-oriented_design)
- https://stackoverflow.com/questions/7542051/learning-single-responsibility-principle-with-c-sharp
- /inversion-of-control-ioc/
- https://aspnetboilerplate.com/Pages/Documents/Dependency-Injection
- https://medium.com/@ivorobioff/dependency-injection-vs-service-locator-2bb8484c2e20