What is Single Responsibility Principle

public class OrderValidator
{
    public List<string> Validate(Order order)
    {
        // Code for validation
    }
}

public class Notifier
{
    public void Notify(string emailId)
    {
        // Code for notification
    }
}

public class OrderManager
{
    private readonly OrderValidator orderValidator;
    private readonly Notifier notifier;

    public OrderManager(OrderValidator oValidator, Notifier nFier)
    {
        orderValidator = oValidator;
        notifier = nFier;
    }

    public bool SaveOrder(OrderInfo orderInfo)
    {
        // Validate order
        orderValidator.Validate(orderInfo);

        // Code for saving order
        // This might be a call to repository to save order

        // Notify after successful saving
        notifier.Notify(orderInfo.EmailId);
    }

    public List<OrderInfo> GetOrders(int customerId)
    {
        // Code for getting order by customerId
    }
}

The preceding code shows the three classes that have only a single responsibility to perform.

The method, it will be like.

public List < OrderInfo > GetOrder(int customerId)  
{  
    int sum = 0;  
    var query = “Select * from order where customerid = ” + customerid;;  
    //query orders    
    return ordercollection;  
}  
public int SumOfAllCustomerOrder(int customerId)   
{  
    var OrderCollection = GetOrder(customerId);  
    foreach(Order in OrderCollection)   
    {  
        If(Order.Items.Count > 5)  
        Sum += Order.Price;  
    }  
    return sum;  
}  

Note. Following the Single Responsibility doesn't mean one can create a class with only one method.

Disadvantages of not following the Single Responsibility Principle

In programming if the developer creates a class/function that performs more than one task then that always causes problems in providing good quality. The following problems are related to a class performing more than one task.

1. It's very difficult for the other developers (in other words developers unfamiliar with the class) to understand the class/function.
2. It's difficult for the other developers to maintain the class/function or change the class/function.
3. Writing test cases for the class/function also becomes difficult.

How to determine if the Single Responsibility Principle has not been followed.

1. Try to write a one-line description of the class or method, if the description contains words like "And, Or, But, or If" then that is a problem.
   An example of a description of a class as described above that does not follow the single responsibility principle is:
   “An Order class that performs order saving, notification to the customer, and validates the order”.
2. A class constructor takes more than three arguments or a method contains too many parameters.
3. A class or method as an implementation that is too long.
4. A class that has low cohesion. Read more about cohesion: Cohesion

Further Read

• Open-Closed Principle in SOLID

• Liskov Substitution Principle
• Interface Segregation Principle
• Dependency Inversion Principle