Liskov Substitution Principle (LSP)

Definition

Objects of a derived class should be replaceable with objects of the base class without breaking application behavior.
👉 Child class should behave properly like parent class.

Purpose

  • Ensure proper inheritance
  • Avoid incorrect subclass behavior
  • Improve polymorphism
  • Prevent runtime issues
  • Build reliable OOP design

Bad Example ❌

Parent Class


public class Bird
{
    public virtual void Fly()
    {
        Console.WriteLine("Bird Flying");
    }
}

Child Class


public class Ostrich : Bird
{
    public override void Fly()
    {
        throw new Exception("Ostrich can't fly");
    }
}

Problem


Bird bird = new Ostrich();

bird.Fly();

❌ Runtime failure.
👉 Child class breaks parent behavior.

This violates LSP.

Good Example ✅

Base Interface


public interface IBird
{
    void Eat();
}

Flying Bird Interface


public interface IFlyingBird
{
    void Fly();
}

Sparrow


public class Sparrow : IBird, IFlyingBird
{
    public void Eat()
    {
        Console.WriteLine("Sparrow Eating");
    }

    public void Fly()
    {
        Console.WriteLine("Sparrow Flying");
    }
}

Ostrich


public class Ostrich : IBird
{
    public void Eat()
    {
        Console.WriteLine("Ostrich Eating");
    }
}

Key Concept

Instead of:

Every bird must fly

We do:

Only flying birds implement Fly()

👉 Correct inheritance hierarchy.

Real-Time Scenario

Payment System:


PaymentMethod
   ↓
UPI
Card
Crypto

If one child behaves differently and breaks logic:
👉 LSP violation.

Advantages

  • ✔ Proper inheritance design
  • ✔ Safer polymorphism
  • ✔ Prevents unexpected behavior
  • ✔ Cleaner architecture
  • ✔ Easier maintenance

Disadvantages

  • ✖ Requires careful hierarchy design
  • ✖ More interfaces/classes possible

When to Use

Use LSP when:

  • Designing inheritance hierarchies
  • Using polymorphism
  • Creating reusable base classes
  • Building extensible frameworks

Real Project Mapping (.NET + Angular)

Feature LSP Usage
Payment providers LSP
Notification providers LSP
Authentication handlers LSP
Vehicle systems LSP
File storage providers LSP

ASP.NET Core Real Example


ILogger logger =
    new FileLogger();

OR

ILogger logger =
    new DatabaseLogger();

👉 Any logger should work without breaking behavior.

LSP vs OCP

LSP OCP
Proper inheritance Extend without modifying
Focus on child behavior Focus on extensibility
Polymorphism correctness Scalability

Common LSP Violation Signs

  • Child throws unsupported exceptions
  • Child ignores parent behavior
  • Extra unexpected restrictions
  • if(type is ChildClass) checks everywhere

Pro Tip

LSP works best with:

  • Interfaces
  • Composition over inheritance
  • Strategy Pattern
  • Dependency Injection

Summary

LSP helps you:

  • Build correct inheritance hierarchies
  • Ensure safe polymorphism
  • Avoid runtime surprises

👉 Perfect for:

  • Enterprise applications
  • Framework design
  • Reusable components
  • Extensible 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