SOLID principles
The SOLID principles are five object-oriented software design guidelines concerning responsibility, extensibility, substitutability, interface design, and dependency direction.
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 →
Grokking Software Architecture
SOLID principles are a group of object-oriented design principles for improving software structure, flexibility, and maintainability.
- How it is used
- Use the five principles as a pre-flight checklist for maintainable, testable, changeable object-oriented code.
- How deep it goes
- Defines all five principles and demonstrates an SRP refactor of order processing, with less concrete treatment of the remaining four.
- Examples
- Uses junk drawers, toolboxes, LEGO connections, and order processing to illustrate structure and an SRP refactor.
- What you can do after
- Evaluate class and component design against principles that support easier maintenance, testing, and change.
Read how Grokking Software Architecture 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 →
Build High Value Software Systems
A set of five software design principles intended to make code easier to change.
- How it is used
- Guides structural changes in legacy code where splitting classes, adding boundaries, or breaking dependencies may reduce friction.
- How deep it goes
- Relates five structural properties to waste and change frequency, with SRP and Open/Closed examples rather than details of all five.
- Examples
- Uses a frequently changing, collision-prone file to illustrate SRP and production-tested logic to illustrate Open/Closed.
- What you can do after
- Evaluate whether a structural change reduces friction on a high-churn path enough to justify added files and indirection.
Read how Build High Value Software Systems explains SOLID principles →
Also covered in
- .NET MAUI in Action
- Claude at WorkIn early access (MEAP)
- The Art of Code
- GitHub Actions in Action: Continuous integration and delivery for DevOps
- .NET in Action, Second Edition
- Clean Applications with Hexagonal ArchitectureIn early access (MEAP)
What to know first
- couplingCoupling is the degree of interdependence between software components, including their dependencies on one another’s structure, behavior, or availability.
- 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.
- cohesionCohesion is the degree to which the elements and responsibilities within a software unit are related and contribute to a coherent purpose.
- functional programmingFunctional programming is a programming paradigm that expresses computation through the evaluation and composition of functions, typically favoring immutable data and minimizing mutable state and side effects.
Related concepts
- Liskov Substitution Principlehas part · The Liskov Substitution Principle is a design principle requiring subtype instances to be usable wherever supertype instances are expected without violating behavioral expectations or program correctness.
- open-closed principleincludes · The open-closed principle is a software design principle stating that software entities should be open to extension but closed to modification.
- single responsibility principleincludes · The single responsibility principle is a software design principle that gives each component one focused responsibility and one primary reason to change.
- dependency inversionincludes · Dependency inversion is a software design principle in which high- and low-level components depend on abstractions rather than directly on implementation details.
- principlekind of · A principle is a general rule, guideline, or value that guides decisions, behavior, or judgments.
- Interface Segregation Principleincludes · The Interface Segregation Principle states that clients should not be forced to depend on interface operations they do not use, favoring focused, client-specific interfaces.
Questions about SOLID principles
What is SOLID principles?
The SOLID principles are five object-oriented software design guidelines concerning responsibility, extensibility, substitutability, interface design, and dependency direction.
Which Manning books explain SOLID principles?
AI-Powered Developer: Build software with ChatGPT and Copilot, ASP.NET Core in Action, 3e, Grokking Software Architecture, Functional Design and Architecture: Examples in Haskell and Build High Value Software Systems.
What should I know before learning SOLID principles?
Manning books that teach SOLID principles usually introduce coupling, interface, cohesion and functional programming first.
What kinds of SOLID principles are there?
Kinds of SOLID principles include open-closed principle, single responsibility principle, dependency inversion and Interface Segregation Principle.
What is SOLID principles a kind of?
SOLID principles is a kind of principle. A principle is a general rule, guideline, or value that guides decisions, behavior, or judgments.
What are the parts of SOLID principles?
SOLID principles includes Liskov Substitution Principle.
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.




