Liskov Substitution Principle (LSP)

Liskov Substitution Principle (LSP)

Derived classes should be substitutable for their base classes without changing the expected behavior of the system.

Explanation:

If a class S is a subclass of class T, then objects of type T should be replaceable with objects of type S without breaking the behavior of the program.
The subclass must honor the expected behavior of the base class.

Why it's important:

  • Ensures reliable polymorphism
  • Prevents unexpected bugs when using inheritance
  • Makes code easier to maintain and extend

Payment Gateway System

Imagine building an e-commerce platform where customers can pay using different methods: Credit Card, UPI, or Wallet. You define a base class:

public class PaymentMethod

{

    public virtual void ProcessPayment(decimal amount)

    {

        // process payment logic

    }

}

Now you create specific payment types:

public class CreditCardPayment : PaymentMethod

{

    public override void ProcessPayment(decimal amount)

    {

        Console.WriteLine($"Paid {amount} via Credit Card.");

    }

}

 

public class UPIPayment : PaymentMethod

{

    public override void ProcessPayment(decimal amount)

    {

        Console.WriteLine($"Paid {amount} via UPI.");

    }

}

So far, all is good — both subclasses substitute the base class without changing behavior.

 

Violating LSP Example:

Now, someone adds a new subclass:

public class CODPayment : PaymentMethod

{

    public override void ProcessPayment(decimal amount)

    {

        throw new NotSupportedException("COD cannot be processed online.");

    }

}

This violates LSP, because code that expects PaymentMethod will crash when passed a CODPayment. For example:

List<PaymentMethod> payments = new List<PaymentMethod>

{

    new CreditCardPayment(),

    new UPIPayment(),

    new CODPayment() // Will throw at runtime

};

 

foreach (var method in payments)

{

    method.ProcessPayment(1000); // đŸ’„ COD breaks expectations

}

 

Solution (Follow LSP):

Refactor the design so that only supported payment types are processed:

public abstract class OnlinePaymentMethod

{

    public abstract void ProcessPayment(decimal amount);

}

 

public class CreditCardPayment : OnlinePaymentMethod

{

    public override void ProcessPayment(decimal amount)

    {

        Console.WriteLine($"Paid {amount} via Credit Card.");

    }

}

 

public class UPIPayment : OnlinePaymentMethod

{

    public override void ProcessPayment(decimal amount)

    {

        Console.WriteLine($"Paid {amount} via UPI.");

    }

}

 

// COD is no longer part of OnlinePaymentMethod

public class CODPayment

{

    public void PayOnDelivery(decimal amount)

    {

        Console.WriteLine($"Pay {amount} upon delivery.");

    }

}

Now OnlinePaymentMethod subclasses are 100% substitutable. Code expecting OnlinePaymentMethod will work safely with any derived class.

 

Summary

LSP ensures that subclasses behave as expected, avoiding runtime surprises or broken contracts. In real-world terms, if a system expects any PaymentMethod to "process payments," then all subclasses must actually do so — not throw errors or behave differently.

 

 

Comments

Post a Comment

Popular posts from this blog

Multiline to singleline IN C# - CODING

Multiline to singleline IN C# - CODING using System; using System.Linq; class Program {     static void Main(string[] args)     {         string input = @"This is                  multiline";                  // Split the input into lines, trim each line, and filter out empty lines         string result = string.Join(" ", input.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)                                                .Select(line => line.Trim()));         Console.WriteLine(result);     } } Output: This is  multiline
Read more

EF Core interview questions for beginners

1. What is Entity Framework Core (EF Core)? EF Core is an open-source Object-Relational Mapper (ORM) that enables .NET developers to work with databases using .NET objects. It allows you to interact with a database using strongly typed classes and LINQ queries, rather than writing raw SQL queries. EF Core supports various database providers, such as SQL Server, SQLite, PostgreSQL, MySQL, and more. 2. What are the advantages of using EF Core over traditional ADO.NET? Productivity:  EF Core allows you to work with databases using high-level objects, reducing the amount of boilerplate code you need to write. Cross-platform:  EF Core supports multiple databases and works on Windows, Linux, and macOS. LINQ Support:  You can query the database using LINQ, which is more type-safe and easier to maintain than raw SQL queries. Code-First & Database-First:  EF Core supports both approaches to model databases. Change Tra...
Read more

EF Core interview questions for experienced

EF Core interview questions for experienced 1. What are the main differences between Entity Framework (EF) and Entity Framework Core (EF Core)? EF Core is a complete rewrite of EF. Unlike EF, EF Core supports cross-platform development, improved performance, LINQ query translation, and has a more modular architecture. EF Core does not support all features that EF 6 does (like lazy loading and some database providers). 2. How does EF Core handle migrations, and what are some common pitfalls? EF Core uses migrations to update the database schema based on model changes. Common pitfalls include not applying migrations correctly, misalignment between model and database state, or missing/overwriting migrations during collaboration in a team environment. 3. Explain the difference between Add and Attach methods in EF Core. Add method is used to add a new entity to the context and mark it as Added , while Attach attaches an existing entity to the context with no changes. The Attach meth...
Read more