GetNoticed IT#5: S-Open/Closed Principle-L-I-D

Good evening!
The time is high to write new post. I’m continuing about SOLID principles. Today it’s “O” which stands for Open/Closed Principle. According to Wikipedia this rule was first defined by Bertrand Meyer in his book Object-Oriented Software Construction (1988). The rule states:

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

Or as others say:

Once a class is done, it’s done!

The idea behind those statements is that if we have a class and it is needed to extend it or modify we create new class which inherits either from our existing class (with use of overridden methods) or from abstractions.
Seems pretty easy, right? However, I still had a bit of a struggle to figure it out and comprehend it in my own way. It would be the best if I explain it on an example. My project for GetNoticed2017 contest is based on rectangles so let us consider an example with rectangles.

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

        public Rectangle(int _width, int _height)
        {
            Height = _height;
            Width = _width;
        }
    }

public class Rectangle

{

public int Height { get; set; }

public int Width { get; set; }

public Rectangle(int _width, int _height)

{

Height = _height;

Width = _width;

}

Our program has to perform some simple transformations of a rectangle. In order to do that we have a static Transformations class which consist of two methods that take a rectangle as an argument and return transformed one.

    public static class Transformations
    {
        public static Rectangle Rotate90(Rectangle _rect)
        {
            return new Rectangle(_rect.Height, _rect.Width);
        }

        public static Rectangle Scale(Rectangle _rect, double _scale)
        {
            return new Rectangle(Convert.ToInt32(_rect.Width * _scale), Convert.ToInt32(_rect.Height * _scale));
        }
    }

public static class Transformations

{

public static Rectangle Rotate90(Rectangle _rect)

{

return new Rectangle(_rect.Height, _rect.Width);

}

public static Rectangle Scale(Rectangle _rect, double _scale)

{

return new Rectangle(Convert.ToInt32(_rect.Width * _scale), Convert.ToInt32(_rect.Height * _scale));

}

Currently our Transformations class can only rotate a rectangle by 90 degrees and scale it. And that would work perfectly fine up to the point where we want to add new transformation. In order to do that we need to modify Transormations class and that is clearly violation of OCP.
Let’s now rebuild our little system to be consistent with OCP. Key to that is abstraction – in our case that simple interface:

    public interface ITransform
    {
        Rectangle Transform(Rectangle _rect);
    }

public interface ITransform

{

Rectangle Transform(Rectangle _rect);

}

Now, we’re going to write separate classes for our two methods we’ve already had in Transformations class.

    public class Rotate90 : ITransform
    {
        public Rectangle Transform(Rectangle _rect)
        {
            return new Rectangle(_rect.Height, _rect.Width);
        }
    }

    public class Scale : ITransform
    {
        private double scale;
        public Scale(double _scale)
        {
            scale = _scale;
        }

        public Rectangle Transform(Rectangle _rect)
        {
            return new Rectangle(Convert.ToInt32(_rect.Width* scale), Convert.ToInt32(_rect.Height* scale));
        }
    }

public class Rotate90 : ITransform

{

public Rectangle Transform(Rectangle _rect)

{

return new Rectangle(_rect.Height, _rect.Width);

}

public class Scale : ITransform

{

private double scale;

public Scale(double _scale)

{

scale = _scale;

}

public Rectangle Transform(Rectangle _rect)

{

return new Rectangle(Convert.ToInt32(_rect.Width* scale), Convert.ToInt32(_rect.Height* scale));

}

So, now we have everything we had before but the difference is that we now follow the OCP. Of course, way of use of these classes will be different that one static class. Let me show you that using unit tests:

using Xunit;

namespace Transformations.Tests
{
    public class GoodTests
    {
        private Rectangle rectangle;
        private ITransform transformation;
        private Rectangle result;
        private void execute(ITransform _transformation)
        {
            transformation = _transformation;
            rectangle = new Rectangle(10, 20);
        }

        [Fact]
        public void testRotation90()
        {
            execute(new Rotate90());
            Rectangle expected = new Rectangle(20, 10);
            Compare(expected);
        }

        [Fact]
        public void testScale2x()
        {
            execute(new Scale(2));
            Rectangle expected = new Rectangle(rectangle.Width * 2, rectangle.Height * 2);
            Compare(expected);
        }

        private void Compare(Rectangle expected)
        {
            result = transformation.Transform(rectangle);
            Assert.Equal(expected.Height, result.Height);
            Assert.Equal(expected.Width, result.Width);
        }
    }
}

using Xunit;

namespace Transformations.Tests

{

public class GoodTests

{

private Rectangle rectangle;

private ITransform transformation;

private Rectangle result;

private void execute(ITransform _transformation)

{

transformation = _transformation;

rectangle = new Rectangle(10, 20);

}

[Fact]

public void testRotation90()

{

execute(new Rotate90());

Rectangle expected = new Rectangle(20, 10);

Compare(expected);

}

[Fact]

public void testScale2x()

{

execute(new Scale(2));

Rectangle expected = new Rectangle(rectangle.Width * 2, rectangle.Height * 2);

Compare(expected);

}

private void Compare(Rectangle expected)

{

result = transformation.Transform(rectangle);

Assert.Equal(expected.Height, result.Height);

Assert.Equal(expected.Width, result.Width);

}

As you can see our test class has a field of type ITransform which holds objects of our new transformation classes. Changing value of it we can freely shuffle with what operation we can perform (for example, instances can be supplied by an IoC container).
At this point adding new transformation is quite easy. But let’s introduce another type of transformation just for its own sake. Let it be cutting in half along vertical axis:

    public class VerticalHalf : ITransform
    {
        public Rectangle Transform(Rectangle _rect)
        {
            return new Rectangle(Convert.ToInt32(_rect.Width / 2), _rect.Height);
        }
    }

public class VerticalHalf : ITransform

{

public Rectangle Transform(Rectangle _rect)

{

return new Rectangle(Convert.ToInt32(_rect.Width / 2), _rect.Height);

}

And that’s it. Open/Closed principle is followed. At this point you may ask question why. The example presented here is very simple, not to say primitive. But in real world classes are bigger and a little bit more complicated. So once a class is tested and running in production environment any change may inflict a bug. Not changing existing classes eliminates that risk. Obviously you can create a bug in your new class (inheriting from an existing class or from interface) but that is yet to be tested. There is no risk that you could break already tested and working code.

As a conclusion to this post and two previous related to SOLID I have one observation: ABSTRACTIONS are extremely important and useful.

Source code for this example: https://github.com/mickaj/OCPdemo

Here are some more examples of how to follow the open/closed principle:
http://joelabrahamsson.com/a-simple-example-of-the-openclosed-principle/
https://www.youtube.com/watch?v=Z_VuxB5guuA

Links to my previous posts related to SOLID:
#1: Dependency Inversion Principle
#2: Single Responsibility Principle

Hope you’ve enjoyed reading this post and it will be somehow useful for you.
Good luck!