What is the dependency inversion principle and why is it important?

dependency inversion principle simple example in java
dependency inversion principle simple example c#
dependency inversion principle example
dependency inversion principle real world example
dependency inversion principle php
dependency inversion principle c
dependency inversion principle javascript
dependency inversion principle example stack overflow

What is the dependency inversion principle and why is it important?

SOLID Design Principles Explained: Dependency Inversion, Learn about Dependency Inversion Principle here. DIP is one of the Abstraction and encapsulation are important principles of object-oriented programming. Definition of the Dependency Inversion Principle. The general idea of this principle is as simple as it is important: High-level modules, which provide complex logic, should be easily reusable and unaffected by changes in low-level modules, which provide utility features.

The books Agile Software Development, Principles, Patterns, and Practices and Agile Principles, Patterns, and Practices in C# are the best resources for fully understanding the original goals and motivations behind the Dependency Inversion Principle. The article "The Dependency Inversion Principle" is also a good resource, but due to the fact that it is a condensed version of a draft which eventually made its way into the previously mentioned books, it leaves out some important discussion on the concept of a package and interface ownership which are key to distinguishing this principle from the more general advise to "program to an interface, not an implementation" found within the book Design Patterns (Gamma, et. al).

To provide a summary, the Dependency Inversion Principle is primarily about reversing the conventional direction of dependencies from "higher level" components to "lower level" components such that "lower level" components are dependent upon the interfaces owned by the "higher level" components. (Note: "higher level" component here refers to the component requiring external dependencies/services, not necessarily its conceptual position within a layered architecture.) In doing so, coupling isn't reduced so much as it is shifted from components that are theoretically less valuable to components which are theoretically more valuable.

This is achieved by designing components whose external dependencies are expressed in terms of an interface for which an implementation must be provided by the consumer of the component. In other words, the defined interfaces express what is needed by the component, not how you use the component (e.g. "INeedSomething", not "IDoSomething").

What the Dependency Inversion Principle does not refer to is the simple practice of abstracting dependencies through the use of interfaces (e.g. MyService → [ILogger ⇐ Logger]). While this decouples a component from the specific implementation detail of the dependency, it does not invert the relationship between the consumer and dependency (e.g. [MyService → IMyServiceLogger] ⇐ Logger.

The importance of the Dependency Inversion Principle can be distilled down to a singular goal of being able to reuse software components which rely upon external dependencies for a portion of their functionality (logging, validation, etc.)

Within this general goal of reuse, we can delineate two sub-types of reuse:

  1. Using a software component within multiple applications with sub-dependency implementations (e.g. You've developed a DI container and want to provide logging, but don't want to couple your container to a specific logger such that everyone that uses your container has to also use your chosen logging library).

  2. Using software components within an evolving context (e.g. You've developed business-logic components which remain the same across multiple versions of an application where the implementation details are evolving).

With the first case of reusing components across multiple applications, such as with an infrastructure library, the goal is to provide a core infrastructure need to your consumers without coupling your consumers to sub-dependencies of your own library since taking dependencies upon such dependencies requires your consumers to require the same dependencies as well. This can be problematic when consumers of your library choose to use a different library for the same infrastructure needs (e.g. NLog vs. log4net), or if they choose to use a later version of the required library which isn't backward compatible with the version required by your library.

With the second case of reusing business-logic components (i.e. "higher-level components"), the goal is to isolate the core domain implementation of your application from the changing needs of your implementation details (i.e. changing/upgrading persistence libraries, messaging libraries, encryption strategies, etc.). Ideally, changing the implementation details of an application shouldn't break the components encapsulating the application's business logic.

Note: Some may object to describing this second case as actual reuse, reasoning that components such as business-logic components used within a single evolving application represents only a single use. The idea here, however, is that each change to the application's implementation details renders a new context and therefore a different use case, though the ultimate goals could be distinguished as isolation vs. portability.

While following the Dependency Inversion Principle in this second case can offer some benefit, it should be noted that its value as applied to modern languages such as Java and C# is much reduced, perhaps to the point of being irrelevant. As discussed earlier, the DIP involves separating implementation details into separate packages completely. In the case of an evolving application, however, simply utilizing interfaces defined in terms of the business domain will guard against needing to modify higher-level components due to changing needs of implementation detail components, even if the implementation details ultimately reside within the same package. This portion of the principle reflects aspects that were pertinent to the language in view when the principle was codified (i.e. C++) which aren't relevant to newer languages. That said, the importance of the Dependency Inversion Principle primarily lies with the development of reusable software components/libraries.

A longer discussion of this principle as it relates to the simple use of interfaces, Dependency Injection, and the Separated Interface pattern can be found here. Additionally, a discussion of how the principle relates to dynamically-typed languages such as JavaScript can be foudn here.

Dependency Inversion Principle, If the mocking tool used relies only on inheritance, it may become necessary to widely apply the dependency inversion pattern. This has major drawbacks: Merely  Dependency inversion pattern generalization. In many projects the dependency inversion principle and pattern are considered as a single concept that should be generalized, i.e., applied to all interfaces between software modules. There are at least two reasons for that: It is simpler to see a good thinking principle as a coding pattern.

Dependency inversion principle, Having this idea in mind the Dependency Inversion Principle states that So, the main reason why DIP is so important is the modularity and  So, dependency inversion will add the flexibility to our program. If the external logic changes, TextConversionCoordinator will be able to handle it just the same. No changes will need to be applied to this class. The opposite of dependency inversion principle is tight coupling. And when this occurs, the flexibility in your program will disappear.

To me, the Dependency Inversion Principle, as described in the official article, is really a misguided attempt to increase the reusability of modules that are inherently less reusable, as well as a way to workaround an issue in the C++ language.

The issue in C++ is that header files typically contain declarations of private fields and methods. Therefore, if a high-level C++ module includes the header file for a low-level module, it will depend on actual implementation details of that module. And that, obviously, is not a good thing. But this is not an issue in the more modern languages commonly used today.

High-level modules are inherently less reusable than low-level modules because the former are normally more application/context specific than the latter. For example, a component that implements an UI screen is of the highest-level and also very (completely?) specific to the application. Trying to reuse such a component in a different application is counter-productive, and can only lead to over-engineering.

So, the creation of a separate abstraction at the same level of a component A that depends on a component B (which does not depend on A) can be done only if component A will really be useful for reuse in different applications or contexts. If that's not the case, then applying DIP would be bad design.

SOLID Principles in C# - Dependency Inversion Principle, In that kind of discussion, some people mention the importance of it and how the ideal system will need to have all of the characteristics of those  The “D” represents Dependency Inversion Principle (DIP) which is our topic for today. Today’s post is the final part of a 5-part series discussing SOLID design principles. I’ll intersperse screenshots in the article but full code can be found on GitHub .

Dependency inversion well applied gives flexibility and stability at the level of the entire architecture of your application. It will allow your application to evolve more securely and stable.

Traditional layered architecture

Traditionally a layered architecture UI depended on the business layer and this in turn depended on the data access layer.

You have to understand layer, package, or library. Let's see how the code would be.

We would have a library or package for the data access layer.

// DataAccessLayer.dll
public class ProductDAO {


And another library or package layer business logic that depends on the data access layer.

// BusinessLogicLayer.dll
using DataAccessLayer;
public class ProductBO { 
    private ProductDAO productDAO;
Layered architecture with dependency inversion

The dependency inversion indicates the following:

High-level modules should not depend on low-level modules. Both should depend on abstractions.

Abstractions should not depend on details. Details should depend on abstractions.

What are the high-level modules and low level? Thinking modules such as libraries or packages, high-level module would be those that traditionally have dependencies and low level on which they depend.

In other words, module high level would be where the action is invoked and low level where the action is performed.

A reasonable conclusion to draw from this principle is that there should be no dependence between concretions, but there must be a dependence on an abstraction. But according to the approach we take we can be misapplying investment depend dependency, but an abstraction.

Imagine that we adapt our code as follows:

We would have a library or package for the data access layer which define the abstraction.

// DataAccessLayer.dll
public interface IProductDAO
public class ProductDAO : IProductDAO{


And another library or package layer business logic that depends on the data access layer.

// BusinessLogicLayer.dll
using DataAccessLayer;
public class ProductBO { 
    private IProductDAO productDAO;

Although we are depending on an abstraction dependency between business and data access remains the same.

To get dependency inversion, the persistence interface must be defined in the module or package where this high level logic or domain is and not in the low-level module.

First define what the domain layer is and the abstraction of its communication is defined persistence.

// Domain.dll
public interface IProductRepository;

using DataAccessLayer;
public class ProductBO { 
    private IProductRepository productRepository;

After the persistence layer depends on the domain, getting to invert now if a dependency is defined.

// Persistence.dll
public class ProductDAO : IProductRepository{


(source: xurxodev.com)

Deepening the principle

It is important to assimilate the concept well, deepening the purpose and benefits. If we stay in mechanically and learn the typical case repository, we will not be able to identify where we can apply the principle of dependence.

But why do we invert a dependency? What is the main objective beyond specific examples?

Such commonly allows the most stable things, that are not dependent on less stable things, to change more frequently.

It is easier for the persistence type to be changed, either the database or technology to access the same database than the domain logic or actions designed to communicate with persistence. Because of this, the dependence is reversed because as it is easier to change the persistence if this change occurs. In this way we will not have to change the domain. The domain layer is the most stable of all, which is why it should not depend on anything.

But there is not just this repository example. There are many scenarios where this principle applies and there are architectures based on this principle.


There are architectures where dependency inversion is key to its definition. In all the domains it is the most important and it is abstractions that will indicate the communication protocol between the domain and the rest of the packages or libraries are defined.

Clean Architecture

In Clean architecture the domain is located in the center and if you look in the direction of the arrows indicating dependency, it is clear what are the most important and stable layers. The outer layers are considered unstable tools so avoid depending on them.

(source: 8thlight.com)

Hexagonal Architecture

It happens the same way with the hexagonal architecture, where the domain is also located in the central part and ports are abstractions of communication from the domino outward. Here again it is evident that the domain is the most stable and traditional dependence is inverted.

Understanding SOLID Principles: Dependency Inversion, The Dependency Inversion Principle (DIP) states that high level modules should not depend on low level modules; both should depend on abstractions. Dependency Inversion Principle…is a Tradeoff (SOLID is not solid) December 02, 2019 Join my mailing list… As mentioned in the original post, I’m realizing that the SOLID principles are not as…solid as it would seem.

Dependency Inversion Principle, So according to its definition, Dependency Inversion Principle is about And David Parnas has already said everything that was necessary on  One of these ways is the dependency inversion principle. It’s one of the most important principles in object-oriented design. And it’s why it’s part of the famous SOLID design principles. (It’s the “D” in SOLID.) The dependency inversion principle isn’t something that you see with WordPress.

Dependency Inversion Principle, I would just dare say that the Dependency Inversion Principle (DIP) is The second, which is equally important as the first one, is that now  Dependency Inversion Principle In the previous chapter, we learned about implementing the IoC principle using the Factory pattern and achieved the first level of loosely coupled design. Here, we will learn how to implement the Dependency Inversion Principle as the second step to achieve loosely coupled classes.

The Dependency Inversion Principle, Applying the dependency inversion principle starts by introducing an abstraction between the high level policy and the low level detail. This abstraction removes  As per the Dependency Inversion Principle in C#, the EmployeeBusinessLogic (high-level module) should not depend on concrete EmployeeDataAccess (low-level module) class. Both classes should depend on abstractions, meaning both classes should depend on either an interface or an abstract class.

  • Refer The Dependency Inversion Principle - Posted by Gabriel Schenker
  • Ridiculous quantity of answers on here using the "high level" and "low level" terms from Wikipedia. These terms are inaccessible and lead lots of readers to this page. If you're going to regurgitate wikipedia, please define these terms in your answers to give context!
  • This answer does not say why DIP is important, or even what DIP is. I have read the official DIP document, and think this is really a poor and unjustified "principle", because it's based on a flawed assumption: that high-level modules are reusable.
  • Consider a dependancy graph for some objects. Apply DIP to the objects. Now any object will be indpendent of the implementation of the other objects. Unit testing is now simple. Later refactoring for reuse is possible. Design changes have very limited change scopes. Design problems don not cascade. See also the AI pattern "Blackboard" for data dependaecy inversion. Together, very powerful tools fo making the software understandable, maintainable and reliable. Ignore dependency injection in this context. It is unrelated.
  • A class A using a class B does not mean A "depends" on the implementation of B; it depends on the public interface of B only. Adding a separate abstraction on which both A and B now depend only means that A will no longer have a compile-time dependency on the public interface of B. Isolation between units can be achieved easily without these extra abstractions; there are specific mocking tools for that, in Java and .NET, that deal with all situations (static methods, constructors, etc.). Applying DIP tends to make software more complex and less maintainable, and no more testable.
  • Then what is inversion of control? a way to achieve Dependency Inversion?
  • @Rogerio, see Derek Greer response below, he explains it. AFAIK, DIP says that it's A who mandates what A needs, and not B who says what A needs. So, the interface that A needs should not be given by B, but for A.
  • Thanks. I see now how my answer misses the point. The difference between MyService → [ILogger ⇐ Logger] and [MyService → IMyServiceLogger] ⇐ Logger is subtle but important.
  • In the same line its very well explained here: lostechies.com/derickbailey/2011/09/22/…
  • How I wished people would stop using loggers as the canonical usecase for dependency injection. Especially in connection with log4net where its almost an anti pattern. That aside, kickass explanation!
  • @ Casper Leon Nielsen - D.I.P. has nothing to do with D.I. They are not synonyms nor equivalent concepts.
  • @VF1 As stated in the summary paragraph, the importance of the Dependency Inversion Principle is primarily with reuse. If John releases a library that has an external dependency on a logging library and Sam wishes to use John's library, Sam takes on the transient logging dependency. Sam will never be able to deploy his application without the logging library John selected. If John follows the DIP, however, Sam is free to provide an adapter and use whatever logging library he chooses. The DIP isn't about convenience, but coupling.
  • Even if the high-level abstraction is useful only in context of that application it can have value when you want to replace the real implementation with a stub for testing (or provide command-line interface to an application usually available on the web)