ARTICLE
Single Responsibility Principle with Example
Overview of Single Responsibility Principle with code Example.
Overview of Single
Responsibility Principle (SRP)
It states that every object should have a single responsibility, and that
responsibility should be entirely encapsulated by the class. There should not be
more than one reason to change the class. This means class should be designed
for one purpose only. This principle states that if we have 2 reasons to change
for a class, we have to split the functionality in two classes. Each class will
handle only one responsibility and on future if we need to make one change we
are going to make it in the class which handle it. When we need to make a change
in a class having more responsibilities the change might affect the other
functionality of the classes.
Intent
A class should have only one reason to change.
Example
In short, it says that a subsystem, module, class, or even a function, should
not have more than one reason to change. The classic example is a class that has
methods that deal with business rules, reports, and database: Below example
shows how it violates the rule of single responsibility Principle. Employee
class has designed to save,Modify and GetEmployeeInfo()
records from Database but MAPEmployee()
method is used for mapping Database columns with the Employee class attributes
which can be altered if there is any changes in DB
Public Class EmployeeService
{
public void SaveEmployeeInfo(Employee e)
{// To do something}
public void UpdateEmployeeInfo(int empId, Employee e)
{//To do Something
}
public Employee GetEmployeeInfo(int empID)
{// To do something
}
public void MAPEmployee(SqlDatareader reader)
{// To do something
}
}
We can segregate the classes into two classes which will implement only
MAPEmployee, so that if there are any changes in DB no need to change
EmployeeService class
Public Class EmployeeService
{
public void SaveEmployeeInfo(Employee e)
{// To do something}
public void UpdateEmployeeInfo(int empId, Employee e)
{//To do Something
}
public Employee GetEmployeeInfo(int empID)
{// To do something
}
}
Public Class ExtendEmployeeService:EmployeeService
{
public void MAPEmployee(SqlDatareader reader)
{// To do something
}
}
Conclusion
The Single Responsibility Principle represents a good way of identifying classes
during the design phase of an application and it reminds you to think of all the
ways a class can evolve. A good separation of responsibilities is done only when
the full picture of how the application should work is well understand.