SOLID Design Principles

-

 

SOLID design principles are some set of best practices for object oriented programming. SOLID stands for

  • Single responsibility principle (SRP)
  • Open-Closed principle (OCP)
  • Liskov substitution principle (LSP)
  • Interface segregation principle (ISP)
  • Dependency inversion principle (DIP)

 

Single responsibility principle

“There should never be more than one reason for a class to change”.

This means every object should have single focus of responsibility. This can be applied in different levels.

  1. A method should carry out one thing only
  2. A domain object should only represent one isolated object within business domain
  3. Presentation layer should be only responsible for presenting data

Purpose of implementing this principle is to get High Cohesive & Low Couples code which is easily testable and maintainable.

  • Cohesion: how strongly related and focused the various responsibilities of a module are
  • Coupling: the degree to which each program module relies on each one of the other modules

 

Open-Closed principle

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

Software that works should when possible not be changed when your application is extended with new functionality.Instead it should be possible to extend the existing software with new functionality without any modification to the current codebase and without adding duplicate code or duplicate functionality.

To state the open closes principle very straightforward way you can say :

  • You should design modules that never change.
  • When requirements change, you extend the behavior of such modules by adding new code, not by changing old code that already works.

 

Liskov substitution principle

“objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program”.

you can find good code example here.

Interface segregation principle

“Clients should not be forced to implement interfaces they don't use. Instead of one fat interface many small interfaces are preferred based on groups of methods, each one serving one sub module”.

ex:-

image

 image

I here rather having all the methods for the inside in one Interface we have divide the read operation in to one single interface. So any class need only reading operation can implement. So it does not need to implement methods which are not relevant it’s need.

Dependency inversion principle

A. High-level modules should not depend on low-level modules. Both should depend on abstractions.

B. Abstractions should not depend on details. Details should depend on abstractions.

The goal of the dependency inversion principle is to decouple application glue code from application logic. Reusing low-level components (application logic) becomes easier and maintainability is increased. This is facilitated by the separation of high-level components and low-level components into separate packages/libraries, where interfaces defining the behavior/services required by the high-level component are owned by, and exist within the high-level component's package. The implementation of the high-level component's interface by the low level component requires that the low-level component package depend upon the high-level component for compilation, thus inverting the conventional dependency relationship. Various patterns such as Plugin, Service Locator, or Dependency Injection are then employed to facilitate the run-time provisioning of the chosen low-level component implementation to the high-level component.

you can find good document here.

 

Happy Coding !!!!

Comments

Post a Comment

Popular posts from this blog

Responsive Web Design

-
Image
  What it is A web application developed based on the responsive web design concept will adopt the layout of the application based on the screen size and orientation. As the user switches from their laptop to iPad, the website should automatically switch to accommodate for resolution, image size and scripting abilities. In other words, the website should have the technology to automatically respond to the user’s preferences. This would eliminate the need for a different design and development phase for each new gadget on the market. When designing a web in responsive manner same HTML content will be maintained, but it will be viewed in different layouts when user switches among different browser sizes. In that way website can server the users by changing the layout of the content so user can view it in more user friendly manner, without too many scrolling. How the layout changes will be discussed under topic Design patterns   Pros Increasing your reach to tablet and ...
Read more

Contract First Development in WCF 4.5

-
Image
WCF 4.5 supports contract first development. Means it allows to create all the data contract classes can be auto generated using the WSDL. one of the advantage in using the is if we start developing the service from the data contracts & then generating the WSDL we might end up in creating from data contracts with .net specific data types. But when using contract first development as WSDL is xml based only xml based data types are allowed to create so no .net specific contract will be created. This feature can be very useful when WSDL file is produced through design phase either by a solution architect or through mutual parties that agree on a contract prior to development and build phases.  When this is the case, either the contract can be created for a future service implementation or contracts can be created so that developers can begin coding for the client side of an interface prior to the endpoint being available. The contract-first tool is integrated into Visual Studio 2...
Read more

Affine Cipher in C#

-
Image
  The affine cipher is a type of monoalphabetic substitution cipher , wherein each letter in an alphabet is mapped to its numeric equivalent, encrypted using a simple mathematical function, and converted back to a letter. The formula used means that each letter encrypts to one other letter, and back again, meaning the cipher is essentially a standard substitution cipher with a rule governing which letter goes to which. As such, it has the weaknesses of all substitution ciphers. Each letter is enciphered with the function , where is the magnitude of the shift. For more information on affine cipher visit here Following code is written in c# which has the affine cipher algorithm   public static string AffineEncrypt( string plainText, int a, int b) {      string cipherText = "" ;        // Put Plain Text (all capitals) into Character Array      char [] chars = plainText.ToUpper().ToCharArray();        // Compute e(x) = (ax + b)(mod m) ...
Read more