SOLID Principles in C# / .NET

SOLID Principles in C# and .NET with Examples

SOLID Principles in C# and .NET help developers build scalable, maintainable, and clean enterprise applications using object-oriented programming and ASP.NET Core.

What are SOLID Principles?

SOLID is a set of 5 object-oriented design principles used to build:

• Maintainable code
• Scalable applications
• Flexible architecture
• Clean and reusable systems

Created by Robert C. Martin.

---

Full Form of SOLID

Letter	Principle
S	Single Responsibility Principle
O	Open/Closed Principle
L	Liskov Substitution Principle
I	Interface Segregation Principle
D	Dependency Inversion Principle

---

1. Single Responsibility Principle (SRP)

Definition

A class should have only one reason to change.
👉 One class = One responsibility.

Bad Example ❌

public class InvoiceService
{
    public void CreateInvoice() { }

    public void SaveToDatabase() { }

    public void SendEmail() { }
}

👉 Too many responsibilities.

Good Example ✅

public class InvoiceService
{
    public void CreateInvoice() { }
}

public class InvoiceRepository
{
    public void Save() { }
}

public class EmailService
{
    public void Send() { }
}

Benefits

• Easier maintenance
• Better readability
• Easier testing
• Reduced side effects

Real-Time Use Case

• Service layer
• Repository layer
• Notification services

---

2. Open/Closed Principle (OCP)

Definition

Software entities should be:

• Open for extension
• Closed for modification

👉 Add new features without changing existing code.

Bad Example ❌

if(type == "GST")
{
}
else if(type == "NoTax")
{
}

Good Example ✅

public interface ITaxStrategy
{
    decimal Calculate(decimal amount);
}

👉 Add new strategy classes instead of modifying code.

Benefits

• Safer changes
• Scalable architecture
• Reduced bugs
• Extensible systems

Real-Time Use Case

• Payment gateways
• Tax calculation
• Authentication providers

---

3. Liskov Substitution Principle (LSP)

Definition

Derived classes should be replaceable with base classes without breaking behavior.
👉 Child class should behave properly like parent.

Bad Example ❌

public class Bird
{
    public virtual void Fly() { }
}

public class Ostrich : Bird
{
    public override void Fly()
    {
        throw new Exception();
    }
}

👉 Ostrich cannot fly.

Good Example ✅

public interface IBird { }

public interface IFlyingBird
{
    void Fly();
}

Benefits

• Better inheritance design
• Avoid unexpected behavior
• Improves polymorphism

Real-Time Use Case

• Payment providers
• Notification services
• Vehicle systems

---

4. Interface Segregation Principle (ISP)

Definition

Clients should not be forced to depend on interfaces they do not use.
👉 Small focused interfaces are better.

Bad Example ❌

public interface IWorker
{
    void Work();
    void Eat();
}

Robot class forced to implement Eat().

Good Example ✅

public interface IWorkable
{
    void Work();
}

public interface IEatable
{
    void Eat();
}

Benefits

• Cleaner interfaces
• Reduced unnecessary code
• Better flexibility

Real-Time Use Case

• Microservices contracts
• API interfaces
• Repository interfaces

---

5. Dependency Inversion Principle (DIP)

Definition

High-level modules should not depend on low-level modules.
Both should depend on abstractions.
👉 Depend on interfaces, not concrete classes.

Bad Example ❌

public class InvoiceService
{
    private SqlRepository _repo =
        new SqlRepository();
}

Good Example ✅

public class InvoiceService
{
    private readonly IRepository _repo;

    public InvoiceService(IRepository repo)
    {
        _repo = repo;
    }
}

Benefits

• Loose coupling
• Easier unit testing
• Better scalability
• Easier dependency injection

Real-Time Use Case

• ASP.NET Core DI container
• Repository pattern
• Service injection

---

SOLID Principles Summary Table

Principle	Goal
SRP	One responsibility
OCP	Extend without modifying
LSP	Proper inheritance
ISP	Small focused interfaces
DIP	Depend on abstractions

---

Why SOLID is Important?

SOLID helps build:

• Enterprise applications
• Microservices
• Clean Architecture
• Maintainable APIs
• Scalable systems

---

Real Project Mapping (.NET + Angular)

Feature	SOLID Principle
Repository pattern	DIP
Strategy pattern	OCP
Service separation	SRP
Small APIs	ISP
Polymorphic services	LSP

---

ASP.NET Core Real Examples

ASP.NET Core Feature	Principle
Dependency Injection	DIP
Middleware separation	SRP
Authentication providers	OCP
ILogger abstraction	DIP

---

Advantages of SOLID

• ✔ Cleaner architecture
• ✔ Easier maintenance
• ✔ Better scalability
• ✔ Easier testing
• ✔ Reduced coupling
• ✔ Better extensibility

---

Disadvantages

• ✖ More abstraction/classes
• ✖ Initial complexity
• ✖ Over-engineering in small projects

---

When to Use SOLID?

Use SOLID in:

• Enterprise applications
• APIs
• Microservices
• Large-scale projects
• Team-based development

---

Pro Tip

SOLID works best with:

• Design Patterns
• Clean Architecture
• CQRS
• DDD
• Dependency Injection

---

Summary

SOLID principles help you:

• Write clean code
• Build scalable systems
• Reduce tightly coupled code
• Improve maintainability

👉 Essential for:

• .NET Developers
• Solution Architects
• Enterprise Applications
• Clean Architecture Projects

FAQ

What are SOLID principles in C#?

SOLID principles are five object-oriented design principles used to build maintainable and scalable software applications.

Why are SOLID principles important in .NET?

SOLID principles improve code quality, scalability, maintainability, and testability in ASP.NET Core and enterprise applications.