The Interface Segregation Principle states that the clients should not be forced to use the methods that they do not use.

 

InterfaceSegregationPrincipleThe above image depicts the complex interface with switches and buttons for the usb to work but the end user does not care about this complexity. The end use just needs to know where to plug-in the usb for the usb to work. An Interface is a non-implementable type that specifies a public set of methods and properties that are implemented by the type that chooses to implement that interface. An Interface could also be the public interface of a class where it exposes the public methods and properties of the class. Now if some client needs only a part of the functionality then we should be able to better design the interfaces or sub-class so that the client in not forced to use what it does not need. Let us take the example of a store that takes order both online as well as in the store. In the online order the store accepts credit cards but in the store order it accepts only cash. So have an Interface IOrder as shown below:

public interface IOrder
{
    void ProcessOrder();
    void ProcessCreditCard();
}

And both the OnlineOrder class and InStoreOrder class implement this interface.

public class OnlineOrder : IOrder
{
    public void ProcessOrder()
    {
        //Process the order placed
    }
    public void ProcessCreditCard()
    {
        //Process payment through credit card
    }
}

 

public class InStoreOrder : IOrder
{
    public void ProcessOrder()
    {
        //Process the order placed
    }
    public void ProcessCreditCard()
    {
        //Not Implemented
        throw new NotImplementedException();
    }
}

In the above implementation we are violating the Interface Segregation Principle because the InStoreOrder class implements the IOrder interface but it does not implement one of the methods ProcessCreditCard. Let’s improve the solution to follow Interface Segregation Principle. To do that we will break the IOrder interface and create another Interface IOnlineOrder which will have the ProcessCreditCard method. So now the interfaces will look like below.

public interface IOrder
{
    void ProcessOrder();
}

public interface IOnlineOrder : IOrder
{
    void ProcessCreditCard();
}

So our existing implementations could still remain the same and new the implementation that need online part of the functionality will use the implement the required interface only.

public class OnlineOrder : IOnlineOrder
{
    public void ProcessOrder()
    {
        //Process the order placed
    }
    public void ProcessCreditCard()
    {
        //Process payment through credit card
    }
}

 

public class InStoreOrder : IOrder
{
    public void ProcessOrder()
    {
        //Process the order placed
    }
}

 

Liskov Substitution Principle can be considered to be an extension of the Open / Closed principle which states the base class reference should be replaceable by the child class without changing the functionality.

LiskovSubstitutionPrinciple

Let us assume that we implemented a Rectangle class with height, width properties and getArea method. Alone it will function perfectly fine.

 

public class Rectangle
{
    protected double Width;
    protected double Height;

    public virtual void SetWidth(double width)
    {
        Width = width;
    }

    public virtual void SetHeight(double height)
    {
        Height = height;
    }

    public double GetWidth()
    {
        return Width;
    }

    public double GetHeight()
    {
        return Height;
    }

    public double GetArea()
    {
        return Height * Width;
    }
}

Now we would like to have a similar functionality for a Square as well, so instead on reinventing the wheel we will simply inherit from the Rectangle class and customize the functionality for a square.

public class Square : Rectangle
{
    public override void SetWidth(double width)
    {
        Width = width;
        Height = width;
    }
    public override void SetHeight(double height)
    {
        Width = height;
        Height = height;
    }
}

 

But now if we replace the reference of the parent class by the child class then we will not the correct area for the rectangle since we have change the core functions (setHeight, setWidth) to set the height and width to same value which is not true in case of rectangle. Hence we have violated the Liskov Substitution principle.

var rectangleAsRectangle = new Rectangle();
rectangleAsRectangle.SetHeight(40);
rectangleAsRectangle.SetWidth(60);

Console.WriteLine("Area of the rectangle = " +
AreaCalculator.CalculateArea(rectangleAsRectangle) + " where Height = " +
rectangleAsRectangle.GetHeight() + " and Width = " +
rectangleAsRectangle.GetWidth());

Output:

Area of the rectangle = 2400 where Height = 40 and Width = 60

Rectangle squareAsRectangle = new Square();
squareAsRectangle.SetHeight(40);
squareAsRectangle.SetWidth(60);

Console.WriteLine("Area of the rectangle = " +
AreaCalculator.CalculateArea(squareAsRectangle) +
" where Height = " +squareAsRectangle.GetHeight() +
" and Width = " + squareAsRectangle.GetWidth());

Output:

Area of the rectangle = 3600 where Height = 60 and Width = 60

It is clear that the Square type is not substitutable for the Rectangle. LSP states that we should be able to the child classes should be able to extend the base classes without changing their existing functionality and we are violating that in this implementation as our square class is changing the behavior of the rectangle class.

Generally speaking the non-substitutable code will break polymorphism.

We can fix this code by creating a class (Shape) from which both Rectangle and Square inherit from. So as we could see in the code below, we have created an abstract class shape with an abstract method GetArea.

public abstract class Shape
{
    public abstract double GetArea();
}

We will now inherit this class in Rectangle and Square and provide the individual implementation of GetArea.

public class Rectangle : Shape
{
    private double _height;
    private double _width;

    public double Height
    {
        get { return _height; }
        set { _height = value; }
    }

    public double Width
    {
        get { return _width; }
        set { _width = value; }
    }

    public override double GetArea()
    {
        return Height * Width;
    }
}

public class Square : Shape
{
    private double _sideLength;
    public double SideLength
    {
        get
        {
            return _sideLength;
        }
        set
        {
            _sideLength = value;
        }
    }

    public override double GetArea()
    {
        return SideLength*SideLength;
    }
}

We could use the Shape class to get the area of the shapes.

static void Main()
        {
            Shape shape = new Rectangle { Height = 40, Width = 60 };
            Console.WriteLine("Area of the rectangle shape = " + shape.GetArea());

            shape = new Square { SideLength = 40 };
            Console.WriteLine("Area of the square shape = " + shape.GetArea());

            Console.ReadLine();
        }

Output

Area of the rectangle shape = 2400

Area of the square shape = 1600

So now the parent class is substitutable by the child classes without changing any existing functionality and so we are not violating the Liskov Substitution Principle.

 

Find the complete source code for this post at googledrive or skydrive.

Any questions comments and feedback are most welcome.

 

The Open / Closed principle states

“Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification” – Wikipedia

Open to extension means that we should be able to add new behavior or features to a class and Closed for modification means that while making these changes we should not need to modify the binaries.

If we want to add new behavior that we should not need to change the existing classes or functions. We should just be able to add new classes and functions to achieve this. A simple example is that we do not need to rewire the motherboard to plug in a USB.

OpenClosePluginUSB

Now you might be thinking how can we achieve extension without making any modifications to a binary?

The answer lies in abstraction.  Once we start relying on abstractions then we many ways to apply the open close principle. In .NET we can achieve this abstraction through Interfaces and Abstract classes.

When we want to add new behavior, then we need to write new functions and new classes and this helps a single class in focus on one thing and we end up with small, easier to maintain classes. Also when we write new classes then none of the existing code is dependent on this new code and hence unlikely to introduce bug.

We can add seams to the applications which allows us to create the demarcation between different layers.

 

Approaches for achieving Open/Closed principle

Parameters

We could pass some information as parameters which could help us avoid the modifications. For example we create a simple program to clean up temporary files on my computer at 9AM. Now I share this code on my blog and people start using it but soon people start asking for a simple modification of allowing the users to decide the time for the cleanup to run. Now if I would have allowed this time to be a user inputted parameter then my class and function would have not needed any modifications.

Inheritance

Inheritance is another way to achieve the open close behavior. In heritance we allow the child classes to change and extend the behavior without making any changes to the parent classes.

Composition

To achieve Composition we could use the Strategy pattern. The strategy pattern allows us to follow the plugin model where the class doing the work gets injected into the class that needs that behavior. In this case we have a level of abstraction between the calling code and called code. In this type of approach the Implementation class used Inheritance since that will inherit from the base for some implementation and the client class follows composition since it exposes itself for other classes to pass into itself.

Example

Let us take the example of a class that calculates the area of a rectangle

public class AreaCalculator
{
    public double Area(Rectangle[] shapes)
    {
        return shapes.Sum(shape => shape.Width*shape.Height);
    }
}

 

To get the area of a rectangle we will pass the object of the Rectangle class and get the area back.

public class Rectangle
{
    public double Width { get; set; }
    public double Height { get; set; }
}

Now we would like to extend the AreaCalculator to calculate the area of a circle as well.

public class Circle
{
    public double Radius { get; set; }
}

So we will change the AreaCalculator to something like below. So depending on the shape we can calculate the area of the shape.

public class AreaCalculator
{
    public double Area(object[] shapes)
    {
        double area = 0;
        foreach (var shape in shapes)
        {
            if (shape is Rectangle)
            {
                var rectangle = (Rectangle)shape;
                area += rectangle.Width * rectangle.Height;
            }
            else if (shape is Circle)
            {
                var circle = (Circle)shape;
                area += circle.Radius * circle.Radius * Math.PI;
            }
        }
    return area;
    }
}

However if tomorrow we want to extend the AreaCalculator class to include another shape then we will have to modify the class again.

 

Now let us try to implement the AreaCalculator class following the Open / Closed principle. Let’s start by creating an abstraction for shape. We will create a class named shape that exposes a method Area.

public abstract class Shape
{
    public abstract double Area();
}

Now whenever we want to create a Shape we will inherit from this abstract class. Let us now create Rectangle and Circle classes inheriting from Shape. We will provide individual implementation of Area and also add the properties as applicable for each shape.

public class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }
    public override double Area()
    {
        return Width * Height;
    }
}

public class Circle : Shape
{
    public double Radius { get; set; }
    public override double Area()
    {
        return Radius * Radius * Math.PI;
    }
}

Since each shape has its own implementation of Area so our AreaCalculator becomes much simpler and robust.

public class AreaCalculator
{
    public double Area(Shape[] shapes)
    {
        return shapes.Sum(shape => shape.Area());
    }
}

 

And since the new classes bring in their own implementations we do not need to modify the existing functionality because of the new behaviors that we add.

 

Find the complete source code for this post at googledrive or skydrive.

Any questions comments and feedback are most welcome.

 

 

 

Hey guys,

In this series i will talk about the SOLID Design Principles. We will discuss one principle in each post.

In this post we will talk about the S which is Single Responsibility Principle (SRP).

 

Single Responsibility Principle (SRP)

 

There should never be more than one reason to change a class. Robert C. Martin

We can think of responsibility of a class as a reason for change in the context of SRP and we want a class to have only one of that. This will be really important when we have an issue because we will know exactly we need to look.

solid.srp

Say we have a modem class in our application and it does 4 operations

 

Without SRP

Without SRP

interface IModem
{
    bool Dial(string phoneNumber);
    bool Hangup();
    bool SendMsg(char msg);
    char RecieveMsg();
}

 

It will make a lot of sense to divide these operations into 2 interfaces that the Modem class implements. We have divided responsibility so that each class has single reason to be modified.

 

With SRP

With SRP

This does not mean that we should start creating different classes for each of the feature or method that we are implementing. There can be different levels of segregation that we can have depending on our application.

For example – In a huge application we might want to create a math class for doing all the math related operations but in a small application we might have different classes for simple operations (add, sub, mul, div) and different class for trigonometric operations (sin, tan, cos)

Cohesion – It is a measure of how much responsibility, data and methods of a class / module are related. It can be thought of as the clarity with which the role of a class is defined within the system. We should always aim for high cohesion.

We can identify cohesion by comparing the class name and the responsibility of the class. If the class is doing something other than what its name specifies than we do not have the desired level of cohesion.

Put your code where everyone would expect to find it.

Coupling – It is the degree to which the different modules or classes are interdependent or relies on each other. We should always aim for low coupling.

The more responsibility a class has more is the likelihood of changes in the class, more the changes more is the likelihood of errors because the responsibilities within a class tend to couple with each tightly.

Interface Segregation Principle (ISP) helps us achieve the Single Responsibility Principle (SRP).

 

Any questions, comments or feedback is welcome.

 

In this post we will have a look at layout and navigation options available in CSS3.

Layout

There are majorly two approaches for designing the layout of the page: fixed layout and fluid layout.

Fixed Layout – This type of layout is easier to implement as in this layout the size of the content does not changes with the size of the browser. So no matter what our page occupies the same size at any point of time irrespective of the resolution or size of the browser.

Fluid Layout – This type of layout requires more work as whenever the size of the browser changes then our page has to respond to changes by adjusting the page layout and size.

How to design the layout of our page

  • Identify your content
  • Add the content to the web page
  • Arrange the content inside the boxes
  • Use float to make the user interface fluid

Currently our page looks like the image shown above. Let us redesign our page into column based layout and to that we will move the About CSS3 section to a column in the right.

* One important thing to remember is that if want some content in a column then it should be defined before the main content.

So let us take the aside which has About CSS3 content and move it above the article itself. The next step is to assign a class .sidePanel to the aside.

<aside>

Now we add another section just below the previous one.

<section id="header-section">

<h1>Advanced concepts in CSS</h1>

<div>

<span>Posted on 25th Sep 2013</span>

<span>by</span>

<span>Abhishek Shukla</span>

</div>

</section>

<section>

<p>&nbsp;</p>

<p>In this section we will learn advanced concepts in CSS3 so that we can take it up a notch.

<img alt="CSS3" title="CSS3" src="http://www.abhishekshukla.com/wp-content/uploads/2013/09/CSS3Advanced.jpg" /></p>

<p>Since you have a good foundation of CSS3, now we will go ahead and look at the advanced concepts of CSS3. We will also get our hands dirty with some practical examples.

</p>

</section>

Currently our page looks something like below.

 

Layout

Layout

Now let us create a new class .sidePanel that we assigned to our aside.

.sidePanel

{

float: right;

width: 150px;

margin-top: 50px;

margin-right: 10px;

}

 

However our page still does not look like we would want it to. We have the main content and side panel running into each other and the main content getting distorted because of the side panel.

 

Layout

Layout

To work around with issue we will do 2 things:

  • We will add a class .mainPanel which will have the right margin greater than the width of the right panel.
.mainPanel

{

margin-right: 175px;

}

 

  • Reduce the height and width of the image so the that it fits nicely.
.image

{

width: 80%;

height: 80%;

}

 

So finally the code for our webpage looks something like below

<!DOCTYPE html>

<html lang="en">

<head>

<meta charset="utf-8" />

<title>Learn CSS3</title>

<link href='http://fonts.googleapis.com/css?family=Noto+Serif' rel='stylesheet' type='text/css'>

<style>

p

{

color:  #24981f;

font-family: 'Noto Serif', serif;

font-size: medium;

}

h1

{

color: #0f769d;

font-family: 'Noto Serif', serif;

font-size: larger;

text-align: center;

padding: 5px

}

h2

{

color: #1197c9;

font-family: 'Noto Serif', serif;

font-size: large;

}

footer p

{

font-size: x-small;

color: #000000

}

.article-title

{

background-color: #c4c4c4;

}

.meta-article

{

font-style: oblique;

}

.meta-author

{

font-style: normal;

}

#first-article

{

background-color: #e8dede

}

ul :nth-child(odd) {background-color: #c4c4c4}

ul :nth-child(even) {background-color:#e8dede}

.webPage {

font-size: 16px;

background-color: #000000;

width: 800px;

margin-top: 25px;

margin-left: auto;

margin-right: auto;

border:  5px solid black;

border-radius: 25px;

background-color: green;

box-shadow: 0 0 15px 5px lightGray

}

.sidePanel

{

float: right;

width: 150px;

margin-top: 50px;

margin-right: 10px;

}

.mainPanel

{

margin-right: 175px;

}

.image

{

width: 80%;

height: 80%;

margin: 5px;

float: right;

}

</style>

</head>

<body>

<aside>

<section>

<h2>About CSS3</h2>

</section>

<section>

This section is generally used for the side panels. Somethime it is also used to give additional information.

<ul>Here is a list of few useful concepts in CSS

<li>Selectors</li>

<li>Inheritance</li>

<li>Specificity</li>

<li>Border</li>

<li>Margin</li>

<li>Padding</li>

<li>Positioning</li>

<li>Selectors</li>

<li>Inheritance</li>

<li>Specificity</li>

<li>Border</li>

<li>Margin</li>

<li>Padding</li>

<li>Positioning</li>

<li>Selectors</li>

<li>Inheritance</li>

<li>Specificity</li>

<li>Border</li>

<li>Margin</li>

<li>Selectors</li>

<li>Inheritance</li>

<li>Specificity</li>

<li>Border</li>

<li>Margin</li>

<li>Padding</li>

<li>Positioning</li>

<li>Selectors</li>

<li>Inheritance</li>

<li>Specificity</li>

<li>Border</li>

<li>Margin</li>

<li>Padding</li>

<li>Positioning</li>

<li>Selectors</li>

<li>Inheritance</li>

</ul>

</section>

</aside>

<div>

<article id="first-article">

<section id="header-section">

<h1>Learn everything about CSS</h1>

<div>

<span>Posted on 12th Sep 2013</span>

<span>by</span>

<span>Abhishek Shukla</span>

</div>

</section>

<section>

<p>&nbsp;</p>

<p>In this section we will learn enough about CSS3 to get a good foundation for working on it.</p>

<img alt="CSS3" title="CSS3" src="http://www.abhishekshukla.com/wp-content/uploads/2013/09/CSS3Logo.jpg" />

<p>CSS 3 came along with HTML5 and has enhanced the capabilities that are available in HTML5.

In this course we will have a look at the various basics of CSS3.

We will also get our hands dirty with some practical examples.</p>

</section>

<section id="header-section">

<h1>Advanced concepts in CSS</h1>

<div>

<span>Posted on 25th Sep 2013</span>

<span>by</span>

<span>Abhishek Shukla</span>

</div>

</section>

<section>

<p>&nbsp;</p>

<p>In this section we will learn advanced concepts in CSS3 so that we can take it up a notch.</p>

<img alt="CSS3" title="CSS3" src="http://www.abhishekshukla.com/wp-content/uploads/2013/09/CSS3Advanced.jpg" />

<p>Since you have a good foundation of CSS3, now we will go ahead and look at the adavnced concepts of CSS3

We will also get our hands dirty with some practical examples.</p>

</section>

</article>

</div>

<footer>

<p>Copyright 2013 Abhishek Shukla</p>

</footer>

</body>

</html>

And the page looks like

Layout

Layout

Navigation

In a website navigation is generally done by the use of links and these links do nothing but take to a different webpages.

To create a navigation bar we will start off with an ul with the list of links that we want to use in the navigation bar. So let us create a list of links just above the main div.

<ul>

<li><a href="http://www.abhishekshukla.com">Home</a></li>

<li><a href="http://www.abhishekshukla.com/category/css">CSS</a></li>

<li><a href="http://www.abhishekshukla.com/category/html/html5">HTML5</a></li>

<li><a href="http://www.abhishekshukla.com/category/javascript">JavaScript</a></li>

</ul>

 

We have added 4 links and these will appear at the top of the page. So this how our page looks now. We see the background styled because of the ul styles that we have specified before.

Navigation

Navigation

Now we will remove the bullet style form the li. We will add a new style for ul.mainMenu and reset the list style to none and will make the bullets disappear.

ul.mainMenu

{

list-style-type: none;

}

Let us remove the padding and margins as well.

ul.mainMenu

{

position:relative;

list-style-type: none;

padding-left: 0px;

margin-left: 0;

border-bottom: 1px solid #000000;

text-align: center;

}

 

And now the looks much better

Navigation

Navigation

Now let us take the block level ul tag and make it into an inline tag so that there no new line between each entry. So now all the links will appear in one line.

.mainMenu li

{

background: green;

display: inline;

}
Navigation

Navigation

 

We can now style each li to look like buttons so let’s go ahead and style the li with color, border, etc.

.mainMenu a
{
background-color: #1197c9;

color: #393636;

display: inline-block;

border: 1px solid #000000;

border-bottom: none;

padding: 5px 20px 5px 20px;

text-decoration: none;

}

 

And now this is how our page looks like

 

 

Navigation

Navigation

 

The code for this post can be found here or @ mirror

Any questions, comments or feedback is most welcome.