Skip to main content

Open Closed Principal

Open Closed Principle (DIP) is one of the five software design principles. What programming languages you know, you should know these five principles written below :
  • Open Close Principle (OCP)
  • Dependency Inversion Principle (DIP)
  • Interface Segregation Principle (ISP)
  • Single Responsibility Principle (SRP)
  • Liskov’s Substitution Principle (LSP)
In this column i will explain Open Closed Principle.
Purpose/Reason
The reason to use open closed principle is to add new features without changing existing software entities. Especially in enterprise application, due to marketing conditions, softwares need to be changed. In order to reduce time, cost and risk for implementation new features, you should consider how to expand software easily. Open closed principle is one of the five answers written above.
Key Principle
Open Close Principle states software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification.
Implementation
Suppose that, you have two different database products which are MySQL and Oracle. In order to connect right database, you built a DatabaseManager to decide that which database product is used to connect. Here is the solution which is not recommended.
Bad Example :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public class DatabaseManager
{
    public void Connect(Database d)
    {
         if (d.DBType == 1)
            ConnectMySQL((MySQLDB)d);
         else if (d.DBType == 2)
            ConnectOracle((OracleDB)d);
    }
 
    public void ConnectMySQL(MySQLDB db)
    {
        // connect
    }
 
    public void ConnectOracle(OracleDB db)
    {
        // connect
    }
     
}
 
public class Database
{
    public int DBType;
}
 
public class MySQLDB : Database
{
    public MySQLDB()
    {
        base.DBType = 1;
    }
}
 
public class OracleDB : Database
{
    public OracleDB()
    {
        base.DBType = 2;
    }
}
For instance, one day ago, your manager said that we need to support Microsoft SQL database. You need to modify almost all classes. But if you cared open closed principle before, you wouldn’t need to change all classes. Let’s see good example about how it should have built.
Good Example :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public abstract class Database
{
    public abstract void Connect();
}
 
public class DatabaseManager
{
    private Database db;
    public DatabaseManager(Database db)
    {
        this.db = db;
    }
 
    public void Connect()
    {
        this.db.Connect();
    }
}
 
public class MySQLDatabase : Database
{
    public void Connect()
    {
        //connect MySQL
    }
}
 
public class OracleDatabase : Database
{
    public void Connect()
    {
        //connect Oracle
    }
}
If you had built your database manager like above, you wouldn’t have needed to modify all classes. The only thing you should do is add new MicrosoftSQL class into current situation.
1
2
3
4
5
6
7
public class MicrosoftSQL : Database
{
    public void Connect()
    {
        // connect Microsoft SQL
    }
}
Summary : 
As you see, this principle should be applied software application which is most likely to be modified or added new features into current situation. Otherwise, your software application has more abstractions between classes and this occurs more complication in your code.
Labels:

Comments

Post a Comment

Popular posts from this blog

gcAllowVeryLargeObjects Element

There are numerous new features coming with .NET 4.5 and here, on this blog, you can find several posts about it. But the feature we are goint to talk about today is very exciting, because we were waiting for it more than 10 years. Since .NET 1.0 the memory limit of .NET object is 2GB. This means you cannot for example create array which contains elements with more than 2GB in total. If try to create such array, you will get the OutOfMemoryException. Let’s see an example how to produce OutOfMemoryException. Before that Open Visual Studio 2012, and create C# Console Application, like picture below. First lets create simple struct with two double members like example below: 1 2 3 4 5 6 7 8 9 10 11 12 public struct ComplexNumber {      public double Re;      public double Im;      public ComplexNumber( double re, double im)      {    ...
Post a Comment
Read more

Support for debugging lambda expressions with Visual Studio 2015

Anyone who uses LINQ (or lambdas in general) and the debugger will quickly discover the dreaded message “Expression cannot contain lambda expressions”. Lack of lambda support has been a limitation of the Visual Studio Debugger ever since Lambdas were added to C# and Visual Basic.  With visual studio 2015 Microsoft has added support for debugging lambda expressions. Let’s first look at an example, and then I’ll walk you through current limitations. Example To try this yourself, create a new C# Console app with this code: using System.Diagnostics; using System.Linq; class Program { static void Main() { float[] values = Enumerable.Range(0, 100).Select(i => (float)i / 10).ToArray(); Debugger.Break(); } } Then compile, start debugging, and add “values.Where(v => (int)v == 3).ToArray()” in the Watch window. You’ll be happy to see the same as what the screenshot above shows you. I am using Visual Studio 2015 Preview and it has some limitati...
1 comment
Read more

How to allow a very large object in .net application?

Since .NET 1.0 the memory limit of .NET object is 2GB. This means you cannot for example create array which contains elements with more than 2GB in total. If try to create such array, you will get the OutOfMemoryException. Let’s see an example how to produce OutOfMemoryException. Before that Open Visual Studio, and create C# Console Application. Lets create simple struct with two double members like example below: public struct ComplexNumber { public double Re; public double Im; public ComplexNumber(double re, double im) { Re = re; Im = im; } } As we know this structure consumes about 16 bytes of memory. So if we want to create array of this type which consume more than 2GB we need to create array at least with 134217728 instances. So this sample program below creates 130000000 (about 1,97 GB) of array. int maxCount = 130000000; ComplexNumber[] arr = null; try { arr = new ComplexNumber[maxCount]; } catch (Exception ex) { Console.WriteLine(ex.Message); } So if we run t...
Post a Comment
Read more