Blog on Fabrizio Bagalà

Dependency Inversion Principle (DIP) in C#

Tue, 30 Jun 2026 08:12:00 +0200

The Dependency Inversion Principle is the “D” in SOLID, and it is the one that ties the whole acronym together. Robert C. Martin states it in two parts:

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.

The “inversion” in the name refers to flipping the usual flow of dependencies. Normally, your important business logic (high-level) reaches down and calls concrete helpers like a database or an SMTP client (low-level). DIP inverts that: both the business logic and the helpers depend on an abstraction in the middle, and the arrows now point inward, toward the policy that matters.

Interface Segregation Principle (ISP) in C#

Mon, 29 Jun 2026 21:50:00 +0200

The Interface Segregation Principle is the “I” in SOLID. Its definition is short:

No client should be forced to depend on methods it does not use.

Put another way: prefer several small, focused interfaces over one large, general-purpose one. A “fat” interface, one that bundles many unrelated operations, forces every implementer to deal with methods it does not care about, and forces every consumer to depend on capabilities it never touches.

Liskov Substitution Principle (LSP) in C#

Sun, 28 Jun 2026 20:33:00 +0200

The Liskov Substitution Principle is the “L” in SOLID, named after computer scientist Barbara Liskov. It is the most formal of the five, but the idea behind it is simple:

Open/Closed Principle (OCP) in C#

Sat, 27 Jun 2026 22:18:00 +0200

The Open/Closed Principle is the “O” in SOLID, and its definition sounds like a contradiction until you unpack it:

Software entities should be open for extension, but closed for modification.

Single Responsibility Principle (SRP) in C#

Fri, 26 Jun 2026 19:42:00 +0200

The Single Responsibility Principle is the “S” in SOLID, and it is the one developers most often get wrong. The usual paraphrase, “a class should do only one thing,” is too vague to be useful. What counts as “one thing”? A method does one thing. A whole microservice does one thing. The size of “one” is in the eye of the beholder.

SOLID Principles in C#: A Practical Introduction

Thu, 25 Jun 2026 21:05:00 +0200

If you have spent any time around object-oriented design, you have run into the acronym SOLID. It shows up in interviews, code reviews, and architecture discussions, often with the implicit assumption that everyone already agrees on what it means. In practice, many developers can recite the five names but struggle to explain why each principle exists or when it actually helps.

Welcome

Wed, 24 Jun 2026 18:30:00 +0200

Welcome and thank you for being here!

Whether you arrived from a search result, a link someone else shared, or just by clicking around, I’m glad you’ve come this way. Writing for myself is easy; writing knowing someone might read it is another story.