Dependency inversion
Dependency inversion is a software design principle in which high- and low-level components depend on abstractions rather than directly on implementation details.
.NET MAUI in Action
Dependency inversion is a design principle in which higher-level code depends on abstractions rather than concrete implementation details.
- How it is used
- Defines View and ViewModel requirements as interfaces before services provide their implementations.
- How deep it goes
- Explains consumer-defined, focused interfaces and constructor injection, while deferring deeper SOLID treatment.
- Examples
- Uses login authentication, a Sum dependency, inventory services, and swapping a REST API for GraphQL.
- What you can do after
- Apply it via constructor injection and ServiceCollection to replace service implementations without changing consumers.
Read how .NET MAUI in Action explains dependency inversion →
Grokking Software Architecture
The Dependency Inversion Principle states that high-level and low-level modules should depend on abstractions, while abstractions should not depend on implementation details.
- How it is used
- Uses shared contracts to decouple business logic from implementation details and protect the application core.
- How deep it goes
- Explains dependency direction through before-and-after implementations and applies it to logging and architectural boundaries.
- Examples
- Uses a coach and interchangeable players, an injected order-service logger, and a checkout workflow with a hardcoded HTTP dependency.
- What you can do after
- Apply dependency inversion by defining a shared contract and supplying an implementation to high-level logic.
Read how Grokking Software Architecture explains dependency inversion →
Functional Design and Architecture: Examples in Haskell
The dependency inversion principle is a design principle requiring high-level policy to depend on abstractions rather than directly on low-level implementation details.
- How it is used
- Decouples business logic from external subsystems so implementations can change without exposing their details.
- How deep it goes
- Explains the principle through injected functional interfaces, implementation selection, and testability trade-offs.
- Examples
- Uses greeting handles and a configurable meteor-reporting interface to illustrate implementation substitution.
- What you can do after
- Apply dependency inversion by defining an interface and injecting an implementation into business logic.
Read how Functional Design and Architecture: Examples in Haskell explains dependency inversion →
Clean Applications with Hexagonal Architecture
A design principle stating that high-level and low-level components should depend on abstractions rather than concrete implementation details.
- How it is used
- Uses dependency inversion to protect the application core within hexagonal architecture.
- How deep it goes
- Explains port ownership and dependency direction through repository and use-case interfaces, with implementation and testing consequences.
- Examples
- Uses an article-creation handler, a repository interface, mock and JPA adapters, and a REST-facing use-case interface.
- What you can do after
- Evaluate dependency boundaries by identifying core-owned ports, adapter dependencies, and leaks of business logic or infrastructure concerns.
Read how Clean Applications with Hexagonal Architecture explains dependency inversion →
AI-Powered Developer: Build software with ChatGPT and Copilot
A software-design principle stating that high-level policy should not depend directly on low-level details and that both should depend on abstractions.
- How it is used
- Guides flexible architecture documentation by separating high-level behavior from low-level implementation details.
- How deep it goes
- Defines DIP briefly and illustrates it with an interface plus four concrete depreciation implementations.
- Examples
- Uses an IT asset model where FundingDetails selects among four DepreciationStrategy implementations.
- What you can do after
- Evaluate/understand designs that replace direct implementation dependencies with interface-based collaborators.
ASP.NET Core in Action, 3e
The dependency inversion principle is a design principle in which high-level modules depend on abstractions rather than low-level implementation details.
- How it is used
- Uses dependency inversion to keep application code independent from low-level service construction as complexity grows.
- How deep it goes
- Defines the principle, distinguishes it from dependency injection, and demonstrates container-provided services without exploring container internals.
- Examples
- Demonstrates user registration, EmailSender, MessageFactory, NetworkClient, and email server settings.
- What you can do after
- Apply it via ASP.NET Core dependency injection by declaring required services instead of constructing their dependency graph manually.
Read how ASP.NET Core in Action, 3e explains dependency inversion →
.NET in Action, Second Edition
The dependency inversion principle is a software design principle in which high-level modules depend on abstractions rather than concrete low-level implementations.
- How it is used
- Uses abstractions to make production components replaceable and unit tests controllable.
- How deep it goes
- Explains interface substitution, constructor injection, default implementations, and deterministic fakes through C# examples.
- Examples
- Demonstrates card shuffling with randomization interfaces and stopwatch timing with an injectable system clock.
- What you can do after
- Build it from scratch with interfaces and constructor injection, then test behavior using deterministic implementations.
Read how .NET in Action, Second Edition explains dependency inversion →
Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
A software design principle stating that high-level components should depend on abstractions rather than low-level implementation details.
- How it is used
- Protects high-level infrastructure resources from low-level module changes and reduces deployment disruption.
- How deep it goes
- Defines the principle, compares three abstraction forms, and demonstrates attribute interpolation, while deferring full implementations of other forms.
- Examples
- Uses network, subnet, and server modules, with Python attribute interpolation and module or state-based metadata access.
- What you can do after
- Apply it by inserting abstractions between infrastructure resources and selecting attributes, outputs, or state for metadata exchange.
Also covered in
- The Art of Code
- Functional Programming in C#, Second Edition
- Go in Action, Second Edition
- Shipping Go: Develop, deliver, discuss, design, and go again
- Simple Object-Oriented Design: Create clean, maintainable applications
What to know first
- unit testA unit test is an automated test that checks whether a relatively small unit of software behaves as expected, typically in isolation from external dependencies.
- interfaceAn interface is a contract or boundary that specifies the operations, members, or data shape a type or component exposes, without prescribing its complete implementation.
- business logicBusiness logic is the domain-specific rules, computations, and decisions that determine how a software system processes operations and behaves.
- abstractionAbstraction is a simplified representation that preserves relevant properties or behavior while omitting details unnecessary at a given level or for a given purpose.
Related concepts
- dependency injectionused by · Dependency injection is a software design technique in which a component receives its dependencies from outside rather than creating or locating them internally.
- abstractionuses · Abstraction is a simplified representation that preserves relevant properties or behavior while omitting details unnecessary at a given level or for a given purpose.
- interfaceuses · An interface is a contract or boundary that specifies the operations, members, or data shape a type or component exposes, without prescribing its complete implementation.
- couplingaddresses · Coupling is the degree of interdependence between software components, including their dependencies on one another’s structure, behavior, or availability.
- ASP.NET Coreimplemented by · ASP.NET Core is Microsoft's open-source, cross-platform framework for building web applications and services on .NET.
- requestscontrasts with · Requests is a Python library that provides a high-level interface for sending HTTP requests and handling responses.
Questions about dependency inversion
What is dependency inversion?
Dependency inversion is a software design principle in which high- and low-level components depend on abstractions rather than directly on implementation details.
Which Manning books explain dependency inversion?
.NET MAUI in Action, Grokking Software Architecture, Functional Design and Architecture: Examples in Haskell, Clean Applications with Hexagonal Architecture, AI-Powered Developer: Build software with ChatGPT and Copilot, ASP.NET Core in Action, 3e, .NET in Action, Second Edition and Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform.
What should I know before learning dependency inversion?
Manning books that teach dependency inversion usually introduce unit test, interface, business logic and abstraction first.
What is the difference between dependency inversion and requests?
Dependency inversion is a software design principle in which high- and low-level components depend on abstractions rather than directly on implementation details. Requests is a Python library that provides a high-level interface for sending HTTP requests and handling responses.
What is dependency inversion also called?
Dependency inversion is also called DIP.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.







