SOLID | Single Responsibility Principle (SRP)

Single Responsibility Principle (SRP)

Introduced by Robert C. Martin, defines responsibility as a single reason to change the class.

• A class should have only one job to do
• It should have a single purpose to serve
• By a single purpose and responsibility it does not mean to be a small class with limited members in it, it can have many but it should point to a single purpose. 
• It helps to separate the classes at the first design phase so that the complexity can be reduced and can be more extensible

Example,

public class UserService
{
    //Create user

   public void CreateNewUser()

   {

        //New user creation implementation

        //Send an email alert

        SendEmail();

    }

    //Sending an email with user-created

    public void SendEmail()
    {

        //Email sending implementation

    }

}

A developer would only be able to understand only when he or she has a clear picture of what needs to be implemented according to the requirement. 

The above example shows two methods kind of user registration which registers the user and sends an alert email. The implementation is short and sweet to understand and it looks good at the first level. But as we are looking at the single responsibility principle you can have an idea of what is wrong with it. 

Let's redesign that with Single Responsibility Principle, 

public class UserService
{
    //Create user

   public void CreateNewUser()

   {

        //New user creation implementation

        

        //Send an email alert

        EmailService.SendEmail();

    }

}

public static class EmailService
{

    //Sending an email with user-created

    public void SendEmail()
    {

        //Email sending implementation

    }

}

Now, we have created a separate class for EmailService which can only contain email-related methods. UserService should have user related tasks in it. If SendEmail() method is part of the same service then at any other service if it needs to consume it would be a redundant code. At this level the same thing becomes reusable.

 

SOLID Design Principles

SOLID Design Principles

SOLID is an acronym for design principles, let's look at it

• Single Responsibility Principle
• A class should have one and only one reason to change
• Open Closed Principle
• The class can be extended without modifying it. So it's open for extension and closes for modification
• Liskov Substitution Principle
• Subclasses should be able to replaceable by their base types without affecting existing implementation
• Interface Segregation Principle
• Many interfaces are better than one general interface
• Dependency Inversion Principle
• Depend on abstraction, not on concretions

SOLID principles are a time-tested solution for software design problems. This principle helps to achieve loosely coupled code design.

Common problems in software architecture?

• A poor architecture will develop bugs over time
• the application requires to be altered for all the customization and future extensions
• Once the application is ready and in production, over time it takes a lot of effort even for a simple task
• Creating a single class with a lot of responsibility
• Unnecessary dependency between classes
• Redundant code

Why we should use SOLID design principles?

• SOLID principles help to solve above listed common problems
• Provides loosely coupled architecture
• Classes can have their specific responsibility 
• Rather than extending the one class using inheritance and abstraction, we can achieve the reusable environment
• It stops affecting the existing functionality
• It allows focusing more on abstraction 

We will go into detail in each dedicated post. Let me know if you have any suggestions or feedback.

What is the difference between Interface and Abstract Class in C#?

Difference between Interface and Abstract Class

Below are the common points to be remembered,

• Abstract classes can have abstract plus nonabstract methods while Interfaces all methods needs to be abstract only.
• Abstract classes can have variables and method implementation whereas Interfaces are not allowed to declare variables and the methods are abstract only. (No implementation)
• Abstract class members are private by default even they can be changed, In Interface it is public by default and you cannot change the same.
• To declare abstract classes Abstract keyword is used, for Interface it is Interface
• Abstract classes and Interfaces are not allowed to create an instance.
• Abstract classes can have a constructor but Interface do not. 

C# Object Oriented Programming 101

I am trying to explain C# with Object-Oriented Programming in a much easy language with examples. To help out to clear basic thumb rules and doubts regarding the base principles.

1. What is OOP (Object Oriented Programming)?

2. Working with Classes and Objects

3. Class Members

4. What is Constructor?

5. Access Modifiers - Encapsulation

6. C# Properties (Getter & Setters)

7. What is Inheritance in C#?

8. Polymorphism (Static vs Dynamic Polymorphism)

9. What is Abstraction in C#?

10. What is Interface?

11. What is the difference between Interface and Abstract Class in C#?

If you interested in more dedicated posts, you are welcome add it in comment section below and I will try to make it for you.

Happy Learning!

What is Interface?

The interface is used to achieve abstraction in C#. It can only contain method declarations and properties. It is a contract between two entities. 

I am using the same example from the previous post on Abstraction, to know more about what is abstraction you can visit the same post.

interface IBird        //Interface keyword to declare it
{
    void Sound();    //Only method signature

}

Points to remember,

• Like abstract classes, no instance creation so no constructor is allowed.is allowed for Interfaces as well 
• Declaring interface with I comes out of practice to identify the same. 
• Interfaces can contain methods and properties but not fields
• All members of interface are abstract and public, you do not need to use public access modifiers
• Derived classes must have an implementation of Interface members, you do not require to use override keyword to implement the method like abstract classes
• The interface provides security and standard contract 
• 
  

class Dove: IBird                    //Inherited Interface
{
        public void Sound()        //interface method implementation
        {               
                Console.WriteLine("Coo Coo");
        }
 }

above is an implementation example of Interface IBird to Dove class. 

What is Abstraction in C#?

Abstraction is about showing what is necessary.

In C# we have abstract classes and abstract methods to achieve abstraction. 

• Abstract Class is a restricted class or can say a half-defined class, so we can not create an instance of the class. To use this class it needs to be inherited.
• Abstract Method can only be declared in abstract classes and it does not contain implementation like an Interface method declaration. Method implementation is a must to their derived classes.
• An abstract class can also contain regular methods with abstract ones.
• You cannot create an instance of an abstract class
• An abstract class with all abstract methods will work as an Interface
• An abstract class can not be declared as Sealed 

abstract class Bird
{
    public abstract void Sound();

    public virtual void Sleep()    //Virtual methods can have their primary implementation
    {
        //Implementation
    }

}

Bird bird = new Bird();    //This will throw an error saying cannot create an instance of an abstract class 

Abstract class needs to be Inherited to their derived class

class Dove: Bird
{
        public override void Sound()        //abstract method implementation
        {               
                Console.WriteLine("Coo Coo");
        }
        public override void Sleep()        //Virtual method can be overridden and have its own implementation
        {
                //Implementation
        }
}

Abstract classes provide security and hide the complexity of the object so the object shows only necessary details to the client. Abstraction can also be achieved using Interfaces. Kindly refer dedicated topic on Interface to learn more.  

Polymorphism (Static vs Dynamic Polymorphism)

Polymorphism means "many forms", also can be said "one interface and many functions"

Inheritance allows the use of parent class members, Polymorphism makes the same methods work in a different way. Means method signature remains the same but the implementation may vary according to the need.

There are two forms we can achieve polymorphism

• Static Polymorphism
• compile time
• Dynamic Polymorphism
• run time

In, Static Polymorphism we have the same method with multiple definitions. Method parameters or return types must differ to achieve polymorphism. 

class Print
{
    public void PrintNumber(int val)
    {
            Console.WriteLine(val);
    }

    public void PrintNumber(string val)
    {
            Console.WriteLine(val);
    }
}

The above example contains the same method PrintNumber() with different parameters, so here we client is able to pass either int to string to print the same. This is called static polymorphism.

In Dynamic Polymorphism, With the help of Abstract classes and Virtual methods, you can achieve dynamic polymorphism. As we know Abstract classes have an abstract method that would require to declare an implementation in derived classes.

Point to remember,

• Instance creation is not allowed of an abstract class
• Abstract methods can be defined in abstract classes
• Sealed classes can not be inherited hence you can not declare an abstract class as Sealed.

abstract class Bird
{
        public virtual void Sound()
        {
                Console.WriteLine("Bird Sound");
        }
}

class Dove : Bird
{
        public override void Sound()
        {               
                Console.WriteLine("Coo Coo");
        } 
}

class Rooster : Bird
{
        public override void Sound()
        {               
                Console.WriteLine("cock-a-doodle-doo");
        } 
}

//Calling class method

Bird myBird = new Bird();        //This will create a bird object
Bird myDove = new Dove();    //This will create a dove object
Bird myRooster = new Rooster(); //This will create a rooster object

//Calling their methods

myBird.Sound();          //This returns Bird Sound from base class
myDove.Sount();        // This returns Coo Coo from the Dove class
myRooster.Sound();    //This returns cock-a-doodle-doo from Rooster class

The above example contains an abstract class Bird and Primary method definition with a virtual keyword which allows its child class to override the same method and make its own implementation. This is called a dynamic polymorphism as at runtime object comes to know which one to call. 

When to use Polymorphism?

• This allows reusability in code 
• The class extension is allowed using Inheritence so no change in the existing implementation
• Respective clients have their own method definition so it won't affect existing clients