I In SOLID - Interface Segregation Principle (ISP)

Before discussing the ISP, we need to know about Interface.

What is Interface and what is the use of interface

As per Wikipedia “An INTERFACE in C# is a type definition like a class, except that it purely represents a contract between an object and its user. It can neither be directly instantiated as an object, nor can data members be defined. So, an interface is nothing but a collection of method and property declarations.”

So when an interface is the collection of method and property Declaration then where is the implementation?

Implementation will be in the class and interface need to be inherited to that class. So, it will be a contract between interface and class.

With the help of an interface, we can achieve loose coupling. The loose coupled architecture of the application helps to accommodate changes easily.

Please refer below CODE,

interface IVehicle
{
int NumberOfPeople { get; set; }
string Color { get; set; }
int SittingCapacity();
bool Airbags { get; set; }
}
class TwoWheeler : IVehicle
{
private int NumberOfPeople { get; set; }
public string Color { get; set; }
public bool Airbags { get; set; }
public int SittingCapacity()
{
NumberOfPeople = 2;
return NumberOfPeople;
}
}
class FourWheeler : IVehicle
{
private int NumberOfPeople { get; set; }
public string Color { get; set; }
public bool Airbags { get; set; }
public int SittingCapacity()
{
NumberOfPeople = 5;
return NumberOfPeople;
}
}

This way we can inherit interface IVehicle interface to the class FourWheeler, FiveWheeler and so on.

Now, what is the role of ISP. “According to Wiki, ISP states that no client should be forced to depend on methods it does not use”. It means if one client needs 2 methods and 3 properties to use then there must be only 2 methods and 3 properties in the interface not more than that because the client is not using it. As we all know all properties and methods in the interface must be implemented in the inherited class, so it will be overhead of methods or properties for the client which the client is not using.

In this case, we need to separate the interfaces. In the above example of interface there is 1 property “Airbags” which is not getting used in TwoWheeler case, however, as it is declared in interface all the classes who are inheriting the interface IVehicle must implement the property. In this case it is the violation of Interface Segregation Principle (ISP). So to achieve ISP please refer below code.

interface ITwoWheeler
{
int NumberOfPeople { get; set; }
string Color { get; set; }
int SittingCapacity();
}
interface IFourWheeler
{
int NumberOfPeople { get; set; }
string Color { get; set; }
int SittingCapacity();
bool Airbags { get; set; }
}

And now we can implement the respective classes,

class TwoWheeler : ITwoWheeler
{
private int NumberOfPeople { get; set; }
public string Color { get; set; }
public int SittingCapacity()
{
NumberOfPeople = 2;
return NumberOfPeople;
}
}
class FourWheeler : IFourWheeler
{
private int NumberOfPeople { get; set; }
public string Color { get; set; }
public bool Airbags { get; set; }
public int SittingCapacity()
{
NumberOfPeople = 5;
return NumberOfPeople;
}
}

ISP gives us to modularize and maintainable code so that everyone has its own class and interface, no one will interfere in others functionality.

--Happy Coding--