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.
Understanding Open Closed Principle and Dependency Inversion
