The SOLID Principles are the design principles that enable us to manage several software design problems. These principles provide us with ways to move from tightly coupled code to loosely coupled and encapsulated real business needs properly. Also readable, adaptable, and scalable code.
The SOLID Principles guide developers as they write
readable, adaptable, and scalable code or design an application.
The SOLID Principles can be applied to any OOP program.
The SOLID Principles were developed by computer science instructor and author Robert C. Martin. Now, SOLID principles have also been adopted in both agile development and adaptive software development.
The 5 principles of SOLID are:
1. Single Responsibility Principle (SRP)
2. Open-Closed Principle (OCP)
3. Liskov Substitution Principle (LSP)
4. Interface Segregation Principle (ISP)
5. DependencyInversion Principle (DIP)
SOLID Principle: (3) Liskov Substitution Principle (LSP):
The Liskov Substitution Principle
(LSP) states that any class must be directly replaceable by any of its
subclasses without error. By Barbara Liskov and Jeannette Wing.
The Liskov Substitution Principle (LSP) states that even if the child object is replaced with the parent, the behavior should not be changed. That means child class objects should be able to replace parent class objects without compromising application integrity. So, child class should be perfectly substitutable for their parent class.
Using the Liskov Substitution Principle (LSP) can check whether inheritance is applied correctly or not in our application code.
The advantage of Using the Liskov Substitution Principle (LSP) is that
increases code reusability.
Real-Time Example of Liskov Substitution Principle (LSP) in C#:
Bank Accounts
Let’s see a real-time example of Bank Accounts to understand the Liskov Substitution Principle (LSP).
In the below example, we have a base class called BankAccount with Deposit and Withdraw methods. Two derived classes, SavingsAccount and CurrentAccount, inherit from it. Each derived class overrides the Withdraw method to implement account-specific withdrawal rules.
In the Main method, we create objects for SavingsAccount and CurrentAccount, but we define them as BankAccount type. This follows the Liskov Substitution Principle (LSP), which allows us to replace instances of derived classes with the base class without affecting the correctness (शुद्धता) of the program.
When performing withdrawal transactions on these accounts, their types do not need to be specified. The Withdraw method for each account type is implemented correctly based on its actual type.
Let's see the code sample,
namespace LSP
{
//Imagine you have a base class BankAccount
public class BankAccount
{
public string AccountNumber { get; set; }
public decimal Balance { get; set; }
public BankAccount(string accountNumber, decimal balance)
{
AccountNumber = accountNumber;
Balance = balance;
}
public virtual void
Deposit(decimal amount)
{
Balance += amount;
}
public virtual void
Withdraw(decimal amount)
{
if (amount
<= Balance)
{
Balance -= amount;
}
else
{
//Insufficient balance.
}
}
}
//We have two derived classes: SavingsAccount and
CurrentAccount
public class SavingsAccount : BankAccount
{
public decimal InterestRate { get; set; }
public SavingsAccount(string accountNumber, decimal balance, decimal interestRate)
: base(accountNumber, balance)
{
InterestRate = interestRate;
}
public override void
Withdraw(decimal amount)
{
if (amount
<= Balance)
{
Balance -= amount;
}
else
{
//Insufficient Funds.
}
}
}
public class CurrentAccount : BankAccount
{
public decimal OverdraftLimit { get; set; }
public CurrentAccount(string accountNumber, decimal balance, decimal overdraftLimit)
: base(accountNumber, balance)
{
OverdraftLimit = overdraftLimit;
}
public override void
Withdraw(decimal amount)
{
if (amount
<= Balance + OverdraftLimit)
{
Balance -= amount;
}
else
{
//Exceeded Overdraft Limit.
}
}
}
//Follow the Liskov Substitution Principle (LSP)
public class Program
{
public static void Main()
{
BankAccount savingsAccount = new SavingsAccount("AKSA12345", 10000m, 0.03m);
BankAccount currentAccount = new CurrentAccount("AKCA67891", 15000m, 5000m);
savingsAccount.Withdraw(5000m);
currentAccount.Withdraw(20000m);
//Check A/C Balance
PrintAccountBalanceDetails(savingsAccount);
PrintAccountBalanceDetails(currentAccount);
Console.ReadKey();
}
static void PrintAccountBalanceDetails(BankAccount
account)
{
Console.WriteLine($"Account Number: {account.AccountNumber}, Balance: {account.Balance}");
}
}
}
Advantages of the Liskov Substitution Principle (LSP):
1.
Support for Polymorphism: LSP enables the
effective use of polymorphism, allowing a single interface to be implemented by
multiple classes with different behavior.
2.
Code Reusability
3.
Flexibility and Extensibility
4.
Design by Contract
Disadvantages of the Liskov Substitution Principle (LSP):
1.
Complexity in Inheritance Hierarchies:
Inheritance hierarchies that become too deep or complex can make it challenging
to maintain and ensure compliance with LSP
2. Violations Can Be Subtle: Violations of the Liskov Substitution Principle can sometimes be subtle and difficult to detect.