Skip to main content

SOLID-Liskov Substitution Principle (LSP) Real-Time Example in C#

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.

By Anil Singh | Rating of this article (*****)

Popular posts from this blog

List of Countries, Nationalities and their Code In Excel File

Download JSON file for this List - Click on JSON file    Countries List, Nationalities and Code Excel ID Country Country Code Nationality Person 1 UNITED KINGDOM GB British a Briton 2 ARGENTINA AR Argentinian an Argentinian 3 AUSTRALIA AU Australian an Australian 4 BAHAMAS BS Bahamian a Bahamian 5 BELGIUM BE Belgian a Belgian 6 BRAZIL BR Brazilian a Brazilian 7 CANADA CA Canadian a Canadian 8 CHINA CN Chinese a Chinese 9 COLOMBIA CO Colombian a Colombian 10 CUBA CU Cuban a Cuban 11 DOMINICAN REPUBLIC DO Dominican a Dominican 12 ECUADOR EC Ecuadorean an Ecuadorean 13 EL SALVADOR

39 Best Object Oriented JavaScript Interview Questions and Answers

Most Popular 37 Key Questions for JavaScript Interviews. What is Object in JavaScript? What is the Prototype object in JavaScript and how it is used? What is "this"? What is its value? Explain why "self" is needed instead of "this". What is a Closure and why are they so useful to us? Explain how to write class methods vs. instance methods. Can you explain the difference between == and ===? Can you explain the difference between call and apply? Explain why Asynchronous code is important in JavaScript? Can you please tell me a story about JavaScript performance problems? Tell me your JavaScript Naming Convention? How do you define a class and its constructor? What is Hoisted in JavaScript? What is function overloadin

React | Encryption and Decryption Data/Text using CryptoJs

To encrypt and decrypt data, simply use encrypt () and decrypt () function from an instance of crypto-js. Node.js (Install) Requirements: 1.       Node.js 2.       npm (Node.js package manager) 3.       npm install crypto-js npm   install   crypto - js Usage - Step 1 - Import var   CryptoJS  =  require ( "crypto-js" ); Step 2 - Encrypt    // Encrypt    var   ciphertext  =  CryptoJS . AES . encrypt ( JSON . stringify ( data ),  'my-secret-key@123' ). toString (); Step 3 -Decrypt    // Decrypt    var   bytes  =  CryptoJS . AES . decrypt ( ciphertext ,  'my-secret-key@123' );    var   decryptedData  =  JSON . parse ( bytes . toString ( CryptoJS . enc . Utf8 )); As an Example,   import   React   from   'react' ; import   './App.css' ; //Including all libraries, for access to extra methods. var   CryptoJS  =  require ( "crypto-js" ); function   App () {    var   data

25 Best Vue.js 2 Interview Questions and Answers

What Is Vue.js? The Vue.js is a progressive JavaScript framework and used to building the interactive user interfaces and also it’s focused on the view layer only (front end). The Vue.js is easy to integrate with other libraries and others existing projects. Vue.js is very popular for Single Page Applications developments. The Vue.js is lighter, smaller in size and so faster. It also supports the MVVM ( Model-View-ViewModel ) pattern. The Vue.js is supporting to multiple Components and libraries like - ü   Tables and data grids ü   Notifications ü   Loader ü   Calendar ü   Display time, date and age ü   Progress Bar ü   Tooltip ü   Overlay ü   Icons ü   Menu ü   Charts ü   Map ü   Pdf viewer ü   And so on The Vue.js was developed by “ Evan You ”, an Ex Google software engineer. The latest version is Vue.js 2. The Vue.js 2 is very similar to Angular because Evan You was inspired by Angular and the Vue.js 2 components looks like -

Encryption and Decryption Data/Password in Angular

You can use crypto.js to encrypt data. We have used 'crypto-js'.   Follow the below steps, Steps 1 –  Install CryptoJS using below NPM commands in your project directory npm install crypto-js --save npm install @types/crypto-js –save After installing both above commands it looks like  – NPM Command  1 ->   npm install crypto-js --save NPM Command  2 ->   npm install @types/crypto-js --save Steps 2  - Add the script path in “ angular.json ” file. "scripts" : [                "../node_modules/crypto-js/crypto-js.js"               ] Steps 3 –  Create a service class “ EncrDecrService ” for  encrypts and decrypts get/set methods . Import “ CryptoJS ” in the service for using  encrypt and decrypt get/set methods . import  {  Injectable  }  from   '@angular/core' ; import   *   as   CryptoJS   from   'crypto-js' ; @ Injectable ({    providedIn:   'root' }) export   class   EncrDecrS