Understanding Open Closed Principle and Dependency Inversion

Introduction

In the following three articles I'm going to discuss SOLID.This is the Part One of the series.I'll try to explain Open Colsed Priciple and Dependency Inversion.

Now what does SOLID mean? SOLID is the OOD(Object-Orient Design) Principle,where each letter has its own mean

• S->Single responsibility
• O->Open Closed
• L->Liskov substitution
• I->Interface segregation
• D->Dependency Inversion

According to the Wikipedia the definition of SOLID is

"SOLID are guidelines that can be applied while working on software to remove code smells by causing the programmer to refactor the software's source code until it is both legible and extensible."

Using the code

Before start tec discuss I want to answer the below questions:

What is Open Closed Principle?

Answer:"software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification"

What is Dependency Inversion?

Answer:

• High-level modules should not depend on low-level modules. Both should depend on abstraction.
• Abstractions should not depend upon details. Details should depend upon abstractions.

Let's consider an example to make it better understand.Suppose I need a computer ,not decided yet whether I need desktop, laptop or other.

Suppose I go to a computer shop and ask for desktop computer.Let's convert my requirements into code. 

using System;

namespace SOLID
{
    public class Desktop
    {
        public string GetComputerDescription()
        {
            return "You get a desktop";
        }
    }

    public class Laptop
    {
        public string GetComputerDescription()
        {
            return "You get a laptop";
        }
    }

    public class ComputerShop
    {
        public enum ComputerType//Violation of OCP
        { 
            Desktop,Laptop
        }

        public string GetComputerDescripution(ComputerType type)
        {
            var myComp = string.Empty;
            if (type == ComputerType.Desktop)//Violation of OCP
            {
                myComp = new Desktop().GetComputerDescription();//Volation of DI
            }
            if (type == ComputerType.Laptop)
            {
                myComp = new Laptop().GetComputerDescription();
            }
            return myComp;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var computerShop = new ComputerShop();
            string desc=computerShop.GetComputerDescripution(ComputerShop.ComputerType.Desktop);            
        }
    }
}

If you run the code it will execute fine and give you a output "You get a desktop". So what's wrong? Here we are violating OCP(Open Closed Principle) and DIP(Dependency Inversion Principle).

• Closed for modification.(we did violation of OCP)
• High-level modules should not depend on low-level modules.Both should depend on abstraction.(we did violation of DIP)

Still confuse? No problem I am explaining.

How we violate OCP ?

Yes we did it by creating instances of Desktop class and Laptop class on GetMyComputerDescripution method.Because if a new type computer come,then we need to modify the function as well as the class enum.

How we violate DIP?

Yes we did it by creating low-level object(Desktop,Laptop) on high-level object(Computer).So high-level module depends on low-level module(Desktop,Laptop) and no abstraction here.

Now I am adding a new type(Tablet) and modify my class by violation of OCP and DIP.

public class ComputerShop
{
    public enum ComputerType
    {
        Laptop, Desktop, Tablet  // Violation of OCP
    }
 
    public ComputerShop()
    {
    }
    public string GetMyComputerDescription(ComputerType type)
    {
        var myComp = string.Empty;
        if (ComputerType.Desktop == type)
        {
            myComp = new Desktop().GetComputer();
        }
        else if (ComputerType.Laptop == type)
        {
            myComp = new Laptop().GetComputer();
        }                                         // Violation of OCP
        else if (ComputerType.Tablet == type)
        {
            myComp = new Tablet().GetComputer();
        }
        return myComp;
    }
}

 Did you notice the violation? Yes we modify the class as new type introduce.

Now let's follow the OCP and DIP rules and implement the new structure.If we can get the required computer without creating object of low-level class on Shop class ,then we can achieve our goal. Now we are going to introduce the abstraction.

using System;

namespace OCPDI
{
    public interface IComputer
    {
        string GetComputerDescripution();
    }

    public class Desktop:IComputer 
    {
        public string GetComputerDescripution()
        {
            return "You get a desktop";
        }
    }

    public class Laptop:IComputer 
    {
        public string GetComputerDescripution()
        {
            return "You get a laptop";
        }
    }
    //
    public class Tablet : IComputer
    {
        public string GetComputerDescripution()
        {
            return "You get a tablet";
        }
    }
    //--
    public class AnotherNewItem : IComputer
    {
        public string GetComputerDescripution()
        {
            return "Another new item";
        }
    }

    public class ComputerShop
    {
        public string GetMyComputerDescripution(IComputer computer)
        {
            var myComp = computer.GetComputerDescripution();
            return myComp;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var computerShop = new ComputerShop();
            var desc=computerShop.GetMyComputerDescripution(new Laptop());

            Console.WriteLine(desc);
        }
    }
}

 We introduce a Interface(IComputer) to remove the dependency from ComputerShop , Desktop,Laptop,etc.

 Also now both high-level and low-level modules depend on abstraction and the abstracion does not depend on  details .So if the details changed ,they should not affect the abstracion(Satisfy DIP).

Now we extend our new item(Tablet , AnotherNewItem) without modify the ComputerShop class(Satisfy OCP).

Points of Interest 

So the interface gives an extendability and remove dependency.Now whatever computer type comes ,ComputerShop class does not depend on any lowe-level module.

    public class AnotherNewItem : IComputer
    {
        public string GetComputerDescripution()
        {
            return "Another new item";
        }
    }

It simply give the product we need from abstracion.

    public class ComputerShop
    {
        public string GetMyComputerDescripution(IComputer computer)
        {
            var myComp = computer.GetComputerDescripution();
            return myComp;
        }
    }

So now our code satisfy both OCP and DIP.