Articles → .NET → Interface Segregation Principal C#

Interface Segregation Principal C#

Interface segregation principle looks like a fancy term, isn’t. When I heard about it I got curious to learn about it. But after reading about the concept I found it very useful. So I decided to write an article on it.

Consider a scenario in which you (as the programmer) are working for an insurance company. The insurance company is providing car insurance, medical insurance and term insurance to everyone in the city. While planning, you have categorized people into four categories

   1. Children

   2. Serviceman

   3. Businessman

   4. Old age people

You have decided to make an interface IInsurance that contains following code.

public interface IInsurance
{
    void CarInsurance();
    void MedicalInsurance();
    void TermInsurance();
}

Now you create four classes, one for each category and implement IInsurance interface. So your classes will be

public class Children : IInsurance
{
    public void CarInsurance()
    {
        throw new NotImplementedException();
    }

    public void MedicalInsurance()
    {
        throw new NotImplementedException();
    }

    public void TermInsurance()
    {
        throw new NotImplementedException();
    }
}
public class ServiceMan : IInsurance
{
    public void CarInsurance()
    {
        throw new NotImplementedException();
    }

    public void MedicalInsurance()
    {
        throw new NotImplementedException();
    }

    public void TermInsurance()
    {
        throw new NotImplementedException();
    }
}

public class BusinessMan : IInsurance
{
    public void CarInsurance()
    {
        throw new NotImplementedException();
    }

    public void MedicalInsurance()
    {
        throw new NotImplementedException();
    }

    public void TermInsurance()
    {
        throw new NotImplementedException();
    }
}

public class OldAge : IInsurance
{
    public void CarInsurance()
    {
        throw new NotImplementedException();
    }

    public void MedicalInsurance()
    {
        throw new NotImplementedException();
    }

    public void TermInsurance()
    {
        throw new NotImplementedException();
    }
}

But insurance company is having certain rules that are specific to a category

   1. There is no relevance of car insurance for children

   2. There is no relevance of providing medical insurance to a serviceman because their employer has already opted the insurance for their employees (because of the government policy).

   3. No term insurance for old age people because according to the insurance company, maximum age should be 40.

So from the preceding rules

   1. CarInsurance method is not relevant for Children class.

   2. MedicalInsurance method is not relevant for ServiceMan class.

   3. TermInsurance method is not relevant for OldAge class.

But you need to add these methods in the class because you have implemented the interface. This is called polluted interface.

Interface segregation principle for rescue

According to interface segregation principle, we can split IInsurance interface into multiple interfaces. See the following code.

public interface ICarInsurance
{
    void CarInsurance();
}

public interface IMedicalInsurance
{
    void MedicalInsurance();
}
public interface ITermInsurance
{
    void TermInsurance();
}

And classes will only implement those interfaces that are relevant. In this way, they are not forced to implement any method that is not relevant. So according to this principle, the classes can be modified as

public class Children : IMedicalInsurance
{

    public void MedicalInsurance()
    {
        throw new NotImplementedException();
    }
}
public class ServiceMan : ICarInsurance,ITermInsurance
{

    public void CarInsurance()
    {
        throw new NotImplementedException();
    }

    public void TermInsurance()
    {
        throw new NotImplementedException();
    }
}

public class BusinessMan : ICarInsurance,IMedicalInsurance,ITermInsurance
{

    public void CarInsurance()
    {
        throw new NotImplementedException();
    }

    public void MedicalInsurance()
    {
        throw new NotImplementedException();
    }

    public void TermInsurance()
    {
        throw new NotImplementedException();
    }
}

public class OldAge : ICarInsurance
{

    public void CarInsurance()
    {
        throw new NotImplementedException();
    }
}

So interface segregation principle requires additional effort to implement but it makes your system more flexible.

Posted By -	Karan Gupta

Posted On -	Thursday, June 04, 2015

Query/Feedback

Your Email Id

Subject

Query/Feedback	Characters remaining 250