✨ Shield now has support for Avalonia UI

Liskov Substitution Principle in C# with Examples

Feb 8, 2023 | C#, .NET

The Liskov Substitution Principle (LSP) is a crucial concept in object-oriented programming, which helps in maintaining the integrity of the system’s design. In this article, we will explore the Liskov Substitution Principle in C# and its significance in the SOLID principles. Moreover, we will delve into practical examples and best practices to ensure a robust and maintainable codebase.

Understanding SOLID Principles

Before diving into the LSP, let’s take a quick look at the SOLID principles that guide object-oriented programming:

Defining the Liskov Substitution Principle (LSP)

The LSP, formulated by Barbara Liskov, states that objects of a derived class should be able to replace objects of the base class without affecting the correctness of the program. In other words, if a class S is a subclass of class T, an object of class T should be replaceable by an object of class S without altering the desirable properties of the program.

liskov substitution principle example c#

Importance of LSP

The LSP is vital because it ensures that the inheritance hierarchy is correctly designed and implemented, promoting code reusability and maintainability. Adhering to LSP leads to a robust and flexible system architecture that can easily accommodate changes in requirements.

Examples of Violating LSP

Incorrect Hierarchy

An incorrect class hierarchy violates the LSP when the derived class does not correctly represent the base class. This often happens when the inheritance relationship is based on implementation details rather than a true “is-a” relationship.

Violating Method Signatures

When a derived class changes the method signature or return type of a base class method, it violates the LSP as the derived class can no longer be substituted for the base class without causing issues.

Misuse of Inheritance

Using inheritance to reuse code rather than establish a true “is-a” relationship is another way to violate LSP. When the derived class only inherits the base class for code reuse and not to represent a proper relationship, it can lead to design issues and decreased maintainability.

LSP in C#: Key Concepts

To understand the LSP in C#, let’s first explore some key concepts:

Base Class

A base class is a general class that acts as a foundation for more specific classes, known as derived classes. The base class defines common properties and methods that the derived classes will inherit.

Derived Class

Derived classes are specialized versions of the base class, inheriting its properties and methods. They can also override or extend the functionality provided by the base class.

Method Overriding

Method overriding is the process by which a derived class provides a new implementation for a method declared in its base class. This allows the derived class to customize the behavior of the inherited method without changing the base class’s code.

Liskov Substitution Principle C# Example

Now, let’s consider a simple example to illustrate the LSP in C#. Suppose we have a base class Shape and two derived classes, Rectangle and Square.

public class Shape
    public virtual double Area() { /*...*/ }

public class Rectangle : Shape
    public double Width { get; set; }
    public double Height { get; set; }

    public override double Area()
        return Width * Height;

public class Square : Rectangle
    public override double Area()
        return Width * Width;

In this example, the Square class is a subclass of Rectangle, which is a subclass of Shape. Because Square is a type of Rectangle, it should be able to replace Rectangle objects without causing any issues. This is an example of the LSP in action, as the derived classes can be substituted for their base classes without affecting the program’s correctness.

C# LSP: Best Practices

To ensure adherence to the LSP, follow these best practices:

Design by Contract

When designing classes and their relationships, ensure that derived classes fulfill the contract established by the base class. This includes adhering to method signatures, return types, and any specified behavior.

Favor Composition over Inheritance

Instead of relying heavily on inheritance, consider using composition to achieve code reuse and flexibility. This can help avoid LSP violations and other design pitfalls associated with inheritance.

Use Interface-Based Programming

Implementing interfaces rather than inheriting from concrete classes can help enforce LSP adherence, as interfaces define contracts that must be fulfilled by any implementing class.

LSP and Other SOLID Principles

The LSP is an essential part of the SOLID principles, ensuring that derived classes can be substituted for their base classes without causing issues. Adhering to the LSP often goes hand-in-hand with following the other SOLID principles, resulting in a maintainable and flexible codebase.


The Liskov Substitution Principle is a crucial concept in object-oriented programming that promotes robust and maintainable code. By understanding the LSP and adhering to its guidelines, developers can create flexible and scalable applications that can easily accommodate changing requirements.


What is the main goal of the Liskov Substitution Principle?

The main goal of the LSP is to ensure that derived classes can be substituted for their base classes without affecting the program’s correctness.

How does LSP relate to the other SOLID principles?

LSP is a part of the SOLID principles and is closely related to the other principles. Following the LSP often goes hand-in-hand with adhering to the other SOLID principles, such as the Single Responsibility Principle, Open/Closed Principle, Interface Segregation Principle, and Dependency Inversion Principle. Together, these principles contribute to a more maintainable and flexible codebase.

Can you provide an example of when to use composition over inheritance?

Consider a scenario where you need to model a zoo with various types of animals, each having unique characteristics and behaviors. Instead of creating an inheritance hierarchy with a base Animal class and derived classes for each animal type, you can use composition by defining separate classes or interfaces for the various behaviors (e.g., IFlyable, ISwimmable). This allows you to compose animal objects with the required behaviors and avoids the complexity and potential LSP violations associated with inheritance.

How does interface-based programming help with adhering to LSP?

Interface-based programming helps with LSP adherence by defining contracts that must be fulfilled by any implementing class. This ensures that derived classes follow the established contract, making it easier to substitute them for their base classes without causing issues.

Is the Liskov Substitution Principle applicable only to C#?

No, the Liskov Substitution Principle is a general concept in object-oriented programming and can be applied to any programming language that supports inheritance, such as Java, Python, and C++.

You May Also Like