Liskov Substitution Principle (LSP)

 Liskov Substitution Principle (LSP)

The principle states that objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program.

Certainly! Let's demonstrate the Liskov Substitution Principle (LSP) with an example involving addition and subtraction operations in C#.

First, let's define an interface `IOperation` representing different mathematical operations:

```csharp

// Operation interface

public interface IOperation

{

    int Apply(int x, int y);

}

Next, we implement two classes, `Addition` and `Subtraction`, representing addition and subtraction operations, respectively:

```csharp

// Addition class implementing IOperation interface

public class Addition : IOperation

{

    public int Apply(int x, int y)

    {

        return x + y;

    }

}

// Subtraction class implementing IOperation interface

public class Subtraction : IOperation

{

    public int Apply(int x, int y)

    {

        return x - y;

    }

}

Now, let's create a calculator class `Calculator` that performs addition and subtraction operations based on the Liskov Substitution Principle:

```csharp

// Calculator class adhering to the Liskov Substitution Principle

public class Calculator

{

    public int PerformOperation(IOperation operation, int x, int y)

    {

        return operation.Apply(x, y);

    }

}

In this implementation, both `Addition` and `Subtraction` classes implement the `IOperation` interface. The `Calculator` class takes any object that implements `IOperation` and performs the operation without knowing the specific class being used, demonstrating the Liskov Substitution Principle.

Here's how you can use these classes:

```csharp

class Program

{

    static void Main()

    {

        Calculator calculator = new Calculator();

        IOperation addition = new Addition();

        int result1 = calculator.PerformOperation(addition, 10, 5);

        Console.WriteLine("Addition Result: " + result1); // Output: 15

        IOperation subtraction = new Subtraction();

        int result2 = calculator.PerformOperation(subtraction, 10, 5);

        Console.WriteLine("Subtraction Result: " + result2); // Output: 5

    }

}

In this example, both `Addition` and `Subtraction` classes can be substituted wherever an `IOperation` object is expected, without altering the correctness of the program, adhering to the Liskov Substitution Principle.