SOLID principles
The SOLID principles are five object-oriented software-design principles concerning single responsibility, openness to extension, substitutability, interface segregation, and dependency inversion.
AI-Powered Developer: Build software with ChatGPT and Copilot
A set of five software-design principles intended to improve the flexibility and maintainability of object-oriented designs.
- How it is used
- Guides iterative object-model refinement toward designs that can accommodate future asset-management features.
- How deep it goes
- Defines all five principles briefly and demonstrates inheritance plus strategy substitution, without a detailed implementation-level treatment.
- Examples
- Uses an IT asset-management model with Asset and Hardware classes and interchangeable depreciation strategies.
- What you can do after
- Apply it via ChatGPT to question and refine class relationships, interfaces, and extension points in a proposed design.
Read how AI-Powered Developer: Build software with ChatGPT and Copilot explains SOLID principles →
ASP.NET Core in Action, 3e
SOLID is a mnemonic for five object-oriented design principles: single responsibility, open-closed, Liskov substitution, interface segregation, and dependency inversion.
- How it is used
- Frames object-oriented design guidance and motivates dependency injection as complexity grows.
- How deep it goes
- Defines the five-principle mnemonic and connects it to dependency injection, but does not explain each principle individually.
- Examples
- Uses C# registration handlers, email senders, manually created dependencies, and container-provided dependencies.
- What you can do after
- Understand how dependency injection applies one SOLID-related design idea to control application complexity.
Read how ASP.NET Core in Action, 3e explains SOLID principles →
Functional Design and Architecture: Examples in Haskell
SOLID is a set of five object-oriented design principles concerning responsibility, extensibility, substitutability, interface design, and dependency management.
- How it is used
- Guides maintainable and reusable design decisions in object-oriented and functional programs.
- How deep it goes
- Defines all five principles and works through LSP using a contract-violating lamp implementation.
- Examples
- Uses ILampSwitcher, DaylightLamp, TableLamp, and turnAllOff to demonstrate substitution and contract violation.
- What you can do after
- Evaluate design decisions with SOLID principles across object-oriented and functional code.
Read how Functional Design and Architecture: Examples in Haskell explains SOLID principles →
Related concepts
- Liskov Substitution Principlehas part · The Liskov Substitution Principle is a software design principle requiring objects of a subtype to be usable wherever objects of its supertype are expected without violating behavioral expectations or program correctness.
- single responsibility principleincludes · The single responsibility principle is a software design principle that gives a component one focused responsibility and one primary reason to change.
- open-closed principleincludes · The open-closed principle is a software design principle that software entities should be open to extension but closed to modification.
- wasteaddresses · Waste is activity or resource consumption that does not contribute useful value to an intended product, process, customer, or organizational outcome.
- Interface Segregation Principleincludes · The Interface Segregation Principle favors focused interfaces so clients and implementations depend only on operations they require.
- dependency inversionincludes · Dependency inversion is a design principle in which high-level policy and low-level implementation depend on abstractions rather than directly on each other.
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.