Ehsan Ghanbari

Experience, DotNet, Solutions

Single Responsibility of Solid Principle

SOLID stands for five basic principles of Object Oriented programming to create a system that is easy to maintainable and extensible. The principles of SOLID are guidelines to create refactored and clean code understandable by other developers. Here are the five principles of OOP:

 

Single responsibility principle

Open-Close Principle

Liskov Substitution Principal

Interface segregation principle

Dependency inversion principle

 

In this post, I'm going to dig into the Single responsibility principle.

                                                     "there should never be more than one reason for a class to change."

The single responsibility principle states that every class should have a single responsibility and that responsibility should be entirely encapsulated by the class. Single Responsibility principle says that every object should have a single responsibility if a class has more than one responsibility these responsibilities become coupled and cannot be executed independently.

When a class has more than one responsibility, there are also more triggers and reasons to change that class. If a class has more than one responsibility, then the responsibilities become coupled. Also when a response is divided over more than one class, all classes part of that responsibility have to change. "Always try to give every class its own and unique responsibility. It would be a bad design to couple two things that change for different reasons at different times." What's important is that responsibilities are separated by abstraction and therefore can be implemented by different consumers of that interface.

 

Take a look at this sample code:

 

 public interface IUser
    {
        string FirstName { get; set; }
        string LastName { get; set; }
    }

    public class DisplayUsers
    {
        private IUser _user;

        public DisplayUsers(IUser user)
        {
            _user = user;
        }

        public string Display()
        {
            return String.Format("{1}, {0}", _user.FirstName, _user.LastName);
        }

        public static string Display(IUser user)
        {
            var displayUsers = new DisplayUsers(user);
            return displayUsers.Display();
        }
    }

    public class Customer : IUser
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Email { get; set; }
    }

 

You can see that every class and interface just could be changed for one reason, for example, DisplayUsers class just Displays the users. Let's assume that you are going to implement banking, based on SRP you have to create another interface

 

  public interface IBanking 
    {
        void Deposit(Guid accountNo, decimal amount);
        void Withdraw(decimal amount);
    }

 

And implement the Banking class like this

 

 public class Bank
     {
        public static decimal Balance { get; set; }

        public void Deposit(Guid accountNo, decimal amount)
        {
            //Do the operation
            Balance += amount;
            // Save the changes
        }

        public void Withdraw(decimal amount)
        {
            //Do the operation
            Balance += amount;
            // Save the changes
        }
    }
 

There is a great example here that you can use it, thanks for reading!

 

About Me

Ehsan Ghanbari

Hi! my name is Ehsan. I'm a developer, passionate technologist, and fan of clean code. I'm interested in enterprise and large-scale applications architecture and design patterns and I'm spending a lot of my time on architecture subject. Since 2008, I've been as a developer for companies and organizations and I've been focusing on Microsoft ecosystem all the time. During the&nb Read More

Post Tags
Pending Blog Posts
Strategic design
Factory Pattern
time out pattern in ajax
Selectors in Jquery
Peridic pattern
How to use PagedList In asp.net MVC
Redis as a cache server
Domain driven design VS model driven architecture
How to query over Icollection<> of a type with linq
What's the DDD-lite?
comments powered by Disqus