Open/Close Principle in OOPS

Question

I am working on a telecom project. I have implemented Open/Closed principle in my project. Below are my classes.

MainServiceClass.CS

public abstract class BaseServiceClass
{
    public abstract IEnumerable<string> GetServiceData();
    public abstract IEnumerable<string> GetDashBoardData();
}

Web_Service.CS

public class WebServiceClass : BaseServiceClass
{
    public override IEnumerable<string> GetServiceData()
    {
        List<string> MyList = new List<string>();
        return MyList;
    }

    public override IEnumerable<string> GetDashBoardData()
    {
        List<string> MyList = new List<string>();
        return MyList;
    }
}

Voice_Service.CS

public class VoiceSericeClass : BaseServiceClass
{
    public override IEnumerable<string> GetServiceData()
    {
        List<string> MyList = new List<string>();
        return MyList;
    }

    public override IEnumerable<string> GetDashBoardData()
    {
        List<string> MyList = new List<string>();
        return MyList;
    }
}

In the future, If I need to implement Video service, I will create a new Video_Service class.I believe that I will achieve Open/Close principle.

If I need to add a new method in my MainServiceClass.cs , I will add a new Method (GetNewTypeOfData()).

Question : Here, I am modifying a class. Still, am I following OCP? Or, is there any way to add new method in the MainServiceClass.cs??

Please suggest.

P.S. I need to implement this method in all the derived classes i.e. Web_Service.cs, Voice_Service.cs, and Video_Service.cs

Updating my question after CrudaLilium reply.

This is my understanding. Please correct me if I am wrong.

My Current Code :

 public interface IMainBase
{
    IEnumerable<string> GetData2016();
}

public class VoiceService : IMainBase
{
    public IEnumerable<string> GetData2016()
    {
        return Enumerable.Empty<string>();
    }
}

I would get a new requirement in 2017. So, I will update my code in 2017

public interface IMainBase
{
    IEnumerable<string> GetData2016();
}    

public class VoiceService : IMainBase
{
    public IEnumerable<string> GetData2016()
    { 
        return Enumerable.Empty<string>();
    }
}

//New Code will be Added in 2017....Start

public interface IMainBase2017 : IMainBase
{
    IEnumerable<string> GetData2017();
}

public class voiceService2017 : VoiceService, IMainBase2017
{
    public IEnumerable<string> GetData2017()
    {
        return Enumerable.Empty<string>();
    }
}

//New Code Added be in 2017...Ended

I would again get a new requirement in 2018. So, I will update my code in 2018.

 public interface IMainBase
{
    IEnumerable<string> GetData2016();
}    

public class VoiceService : IMainBase
{
    public IEnumerable<string> GetData2016()
    { 
        return Enumerable.Empty<string>();
    }
}

//New Code will be Added in 2017....Start

public interface IMainBase2017 : IMainBase
{
    IEnumerable<string> GetData2017();
}

public class voiceService2017 : VoiceService, IMainBase2017
{
    public IEnumerable<string> GetData2017()
    {
        return Enumerable.Empty<string>();
    }
}

//New Code Added be in 2017...Ended

//New Code will be Added in 2018...Start

public class WebService2018 : IMainBase2017
{
    public IEnumerable<string> GetData2016()
    {
        return Enumerable.Empty<string>();
    }

    public IEnumerable<string> GetData2017()
    {
        return Enumerable.Empty<string>();
    }
}


//New Code will be Added in 2018...End

As per above code, I am not violating OCP. Is this a good practice or do I have any alternative way also?

are you saying you wanted to add new method and implementation that will appear at all classes ? — Turbot, Sep 10 '16 at 05:46
Yes, I want to add a new method in the MainService class and later I will override it in derived classes. — KiddoDeveloper, Sep 10 '16 at 05:50
You will be violating OCP when you have to change an existing class when adding a new feature. So you are not following OCP; you are breaking it. — Steven, Sep 10 '16 at 07:02
@Steven Fine, I understand it. But can you please tell me How I can add a new method in the MainService class. Shall I create a Interface or abstract class? Please suggest. — KiddoDeveloper, Sep 10 '16 at 07:18
You can't add a new method wothout breaking OCP. You should create a new class with a new method. — Steven, Sep 10 '16 at 07:49
@Mohit As for following OCP you are correct.But I'm not so sure class design, maybe it's just example, but you could make one method GetData(int year) instead of creating new one for each year. — CrudaLilium, Sep 10 '16 at 09:05
@CrudaLilium Yeah. Class desgin is just sample. It can be any method. Thanks. — KiddoDeveloper, Sep 10 '16 at 12:23
@Mohit I forgot and didn't realize it until today, but you should also look into Interface segregation principle, for better extensibility you don't need the interface to inherit from the previous one, it can be standalone. — CrudaLilium, Sep 11 '16 at 05:20
I asked a new question. Need you suggestions http://stackoverflow.com/questions/39435658/dependency-inversion-principle-and-dependency-injection-in-c-sharp — KiddoDeveloper, Sep 11 '16 at 11:41

CrudaLilium · Accepted Answer · 2016-09-10T07:30:45.253

Creating Video_Service is not a problem, but changing BaseServiceClass is and you wouldn't be following the principle.

If you make it abstract you would need to modify all other classes that inherit from BaseServiceClass. But even if you don't make it abstract it seems kinda pointless, because all current client classes that use your BaseServiceClass don't use any other methods except the 2 you already have.

If your client class needs to use 3rd method, it would be better if you make another abstract class (just for example BaseServiceClass2) that will inherit from BaseServiceClass and add the new method there and make your client dependent on this class. From there to extend you existing classes WebServiceClass , VoiceSericeClass you would have to create new class and inherit from BaseServiceClass2 and use adapter pattern.

Example code:

    public abstract class BaseServiceClass
    {
        public abstract IEnumerable<string> GetServiceData();
        public abstract IEnumerable<string> GetDashBoardData();
    }

    public abstract class BaseServiceClass2 : BaseServiceClass
    {
        public abstract IEnumerable<string> GetNewTypeOfData();
    }


    public class WebServiceClass2 : BaseServiceClass2
    {
        private BaseServiceClass adaptee;

        WebServiceClass2(BaseServiceClass adaptee)
        {
            this.adaptee = adaptee;
        }

        public override IEnumerable<string> GetDashBoardData()
        {
            return adaptee.GetDashBoardData();
        }

        public override IEnumerable<string> GetNewTypeOfData()
        {
            return Enumerable.Empty<string>();
        }

        public override IEnumerable<string> GetServiceData()
        {
            return adaptee.GetServiceData();
        }
    }

It would be much better if you make BaseServiceClass an interface and if you need to add anything new you would just creat new interface inhering from it and like in previous example, make your client class dependent on your new interface, from there you could just create new class inheriting from WebServiceClass ,VoiceSericeClass etc. and implement the new interface.

Example:

    public interface IBaseServiceClass
    {
        IEnumerable<string> GetServiceData();
        IEnumerable<string> GetDashBoardData();
    }

    public interface IBaseServiceClass2 : IBaseServiceClass
    {
        IEnumerable<string> GetNewTypeOfData();
    }


    public class WebServiceClass2 : WebServiceClass, IBaseServiceClass2
    {
        public IEnumerable<string> GetNewTypeOfData()
        {
            return Enumerable.Empty<string>();
        }
    }

    public class WebServiceClass : IBaseServiceClass
    {
        public IEnumerable<string> GetServiceData()
        {
            List<string> MyList = new List<string>();
            return MyList;
        }

        public IEnumerable<string> GetDashBoardData()
        {
            List<string> MyList = new List<string>();
            return MyList;
        }
    }

Class/interface names are only used as placeholders and it would be better name them in more meaningful way.

Thank you for the reply. I have a question. Question : Today, I have deployed my project on production server. Next Year a requirement generates, so I need to implement a new method in MainService class. So, I should never violate OCP and add new interface/class as per your suggestion. Fine, I will add it. I might get request for new methods after some intervals. So, should I generate a new abstract/Interface for each request? — KiddoDeveloper, Sep 10 '16 at 07:46
Please let me know if I am not able to explain my question, I will elaborate more. — KiddoDeveloper, Sep 10 '16 at 07:48
Yes, you will have to create new interface and create new class that extend your existing class, but avoid creating god class. — CrudaLilium, Sep 10 '16 at 08:00
The god class/the blob/god object is class that does too much, it's an anti-pattern. It's possible you don't have to keep extending your service class, but should instead create new class that encapsulates that new functionality, but this depends how your client class is implemented. — CrudaLilium, Sep 10 '16 at 08:32
Final : As per OCP, we shouldn't modified the class. We should for extension. — KiddoDeveloper, Sep 10 '16 at 12:24
By the way, I suggest you look up "Adaptive Code Via C#: Agile Coding with Design Patterns and SOLID Principles" it features practical examples, really recommend it. — CrudaLilium, Sep 10 '16 at 12:33
Let us [continue this discussion in chat](http://chat.stackoverflow.com/rooms/123058/discussion-between-mohit-and-crudalilium). — KiddoDeveloper, Sep 10 '16 at 12:55
Thank you For the suggestion. Looks like a nice book. I think Part 2 is good for me. I am a .NET developer but my basic is not clear. So, I have started learning from OOPS and SOLID Principles. Please suggest me if you better stuff. — KiddoDeveloper, Sep 10 '16 at 13:04

Open/Close Principle in OOPS

1 Answers1