Dependency Inversion Principle (DIP)

Definition

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

Purpose

  • Reduce tight coupling
  • Improve flexibility
  • Enable dependency injection
  • Make unit testing easier
  • Build scalable architecture

Bad Example ❌

Low-Level Class


public class SqlRepository
{
    public void Save()
    {
        Console.WriteLine("Saved to SQL");
    }
}

High-Level Class


public class InvoiceService
{
    private readonly SqlRepository _repository =
        new SqlRepository();

    public void CreateInvoice()
    {
        _repository.Save();
    }
}

Problem

InvoiceService directly depends on: 


SqlRepository

If database changes:

  • MongoDB
  • PostgreSQL
  • MySQL

👉 High-level code must change.

This creates:

  • Tight coupling
  • Difficult testing
  • Poor scalability

Good Example ✅

Step 1: Abstraction


public interface IRepository
{
    void Save();
}

Step 2: Low-Level Implementation


public class SqlRepository : IRepository
{
    public void Save()
    {
        Console.WriteLine("Saved to SQL");
    }
}

Another Implementation


public class MongoRepository : IRepository
{
    public void Save()
    {
        Console.WriteLine("Saved to MongoDB");
    }
}

Step 3: High-Level Module


public class InvoiceService
{
    private readonly IRepository _repository;

    public InvoiceService(IRepository repository)
    {
        _repository = repository;
    }

    public void CreateInvoice()
    {
        _repository.Save();
    }
}

Usage Example


IRepository repository =
    new SqlRepository();

var service =
    new InvoiceService(repository);

service.CreateInvoice();

Output


Saved to SQL

Key Concept

Instead of:

Service → SQL Repository

We do:

Service → Interface ← Repository

👉 Loose coupling achieved.

Real-Time Scenario

Payment System:


IPaymentGateway
    ↓
Stripe
PayPal
Razorpay

👉 Change providers without changing business logic.

Advantages

  • ✔ Loose coupling
  • ✔ Easier testing/mock support
  • ✔ Better scalability
  • ✔ Flexible architecture
  • ✔ Easier maintenance

Disadvantages

  • ✖ More interfaces/classes
  • ✖ Slightly increased abstraction complexity

When to Use

Use DIP when:

  • Building enterprise applications
  • Using dependency injection
  • External systems may change
  • Unit testing is important
  • Scalability is required

Real Project Mapping (.NET + Angular)

Feature DIP Usage
Repository pattern DIP
Service injection DIP
Payment gateways DIP
Notification providers DIP
File storage providers DIP

ASP.NET Core Real Example

Dependency Injection Container


builder.Services.AddScoped<
    IRepository,
    SqlRepository>();

👉 ASP.NET Core DI is built around DIP.

Unit Testing Example


var mockRepo = new Mock<IRepository>();

👉 Easy mocking because of abstraction.

DIP vs OCP

DIP OCP
Depend on abstractions Extend without modifying
Focus on dependencies Focus on extensibility
Achieves loose coupling Achieves scalability

Common DIP Violation Signs

  • new Keyword inside services
  • Direct database dependency
  • Hardcoded implementations
  • Difficult unit testing

Pro Tip

DIP works best with:

  • Dependency Injection
  • Repository Pattern
  • Strategy Pattern
  • Clean Architecture
  • Microservices

Summary

DIP helps you:

  • Reduce tight coupling
  • Depend on abstractions
  • Build scalable systems

👉 Perfect for:

  • Enterprise applications
  • APIs
  • Microservices
  • Testable architectures

Comments

Post a Comment

Popular posts from this blog

Promises in Angular

🚀 Promises in Angular – The Complete Beginner’s Guide (with Examples) 📘 Introduction In modern Angular development, handling asynchronous operations is essential. Whether you're fetching data from an API, loading files, or wrapping browser-native APIs, Promises offer a clean and readable way to deal with one-time asynchronous operations. This guide explains: What Promises are How they compare with Observables Real-world examples using .then() and async/await When to use Promises vs Observables in Angular 📚 Table of Contents 🔍 What is a Promise? 🔁 Promise Lifecycle ✨ Key Features 📌 Syntax 💻 Example 1: Fetch 💻 Example 2: setTimeout 📊 Promises vs Observables 🎯 When to Use Promises 📦 Angular Service Example 🔄 Observable vs Promise ❓ FAQ ✅ Summary 🔍 What is a Promise? A Promise is a JavaScript object that represents the eventual success (fulfilled) or failure (rejected) of an asynchronous operation. 📌 Com...
Read more

Debouncing & Throttling in RxJS: Optimizing API Calls and User Interactions

RxJS Debounce vs Throttle in Angular – Best Practices & Examples What is RxJS — quick primer RxJS (Reactive Extensions for JavaScript) provides Observables and operators to model and manipulate streams of asynchronous events — from keystrokes and HTTP requests to timers and WebSocket messages. 💡 Why this matters: Operators like debounceTime and throttleTime help you control event frequency, reducing wasted CPU and network work while improving UX. 1. Debouncing — emit after silence Debouncing delays emitting a value until a specified period of inactivity. It's best for typeahead inputs where only the final value after the user stops typing is relevant. Live search example (production-ready) // search.component.ts import { Component, OnDestroy } from '@angular/core'; import { FormControl } from '@angular/forms'; import { Subject } from 'rxjs'; import { debounc...
Read more

Csharp Coding - Session

Image
✅ Reverse String Array using System; public class Program { public static void Main() { ReverseStringArray (); } public static void ReverseStringArray() { string[] str = { "priya", "Sai" }; int length = str.Length; for (int i = 0, j = length - 1; i < j; i++, j--) { string temp = str[i]; str[i] = str[j]; str[j] = temp; } Console.WriteLine(string.Join(", ", str)); // Output: Sai, priya } } Output: Sai, priya ✅ Reverse String Array + Each Word using System; public class Program { public static void Main() { ReverseStringArray(); } public static void ReverseStringArray() { string[] str = { "priya", "Sai" }; // Step 1: Reverse the array string[] reversedArray = ReverseArray (str); // Step 2: Reverse e...
Read more