Dot Net Stuff

Exploring .Net Design Patterns in Software development


Design patterns were introduced by GOF(Gangs Of Four) Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides’s seminal work Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley).

Design patterns provide a high-level language of discourse for programmers to describe their systems and to discuss solutions to common problems. This language comprises the names of recognizable patterns and their elements. Each design pattern shave its own templates and these patterns have illustrative names and are described with diagrams illustrating, their role players. There are 23 design patterns. These patterns are divided into three groups: structural, creational, and behavioral.

  • Structural design patterns

    Structural patterns are concerned with how classes and objects are composed to form larger structures. Structural patterns can be employed while a system is being designed, or later on during maintenance and extension. Following are the design pattern belongs to this category.

        Decorator Design Pattern: Allow us to dynamically add or modify behavior in an existing method of an object.
        Proxy Design Pattern: It provides a placeholder for another object to control access, reduce cost, and reduce complexity.
        Bridge Design Pattern: it allows us to decouples an abstraction from its implementation, so that the two can vary independently.
        Composite Design Pattern: It composes zero-or-more similar objects so that they can be manipulated as one object.
        Flyweight Design Pattern: It reduces the cost of creating and manipulating a large number of similar objects.
        Adapter Design Pattern: It allows classes with incompatible interfaces to work together by wrapping its own interface around that of an already existing class.
        Façade Design Pattern: It provides a simplified interface to a large body of code.
  • Creational Design Patterns

    The creational patterns aim to separate a system from how its objects are created, composed, and represented. They increase the system’s flexibility in terms of the what, who, how, and when of object creation. Creational patterns encapsulate the knowledge about which classes a system uses, but they hide the details of how the instances of these classes are created and put together. Following are the design patterns are falls in to this category.

        Prototype Pattern: It creates objects by cloning an existing object.
        Factory Methods Design Pattern: It creates objects without specifying the exact class to create.
        Singleton Design Pattern: It restricts object creation for a class to only one instance.
        Abstract Factory Design Pattern: It groups object factories that have a common theme.
        Builder Design Pattern: It constructs complex objects by separating construction and representation.
  • Behavioral Patterns:

    Behavioral patterns are concerned with algorithms and communication between them. The operations that make up a single algorithm might be split up between different classes, making a complex arrangement that is difficult to manage and maintain. The behavioral patterns capture ways of expressing the division of operations between classes and optimize how the communication should be handled. Following are the patterns falls in to this category.

        Strategy Design Pattern: allows one of a family of algorithms to be selected on-the-fly at runtime.
        State Design Pattern: allows an object to alter its behavior when it’s internal state changes.
        Template Methods Design Pattern: defines the skeleton of an algorithm as an abstract class, allowing its subclasses to provide concrete behavior.
        Command Design Pattern: creates objects which encapsulate actions and parameters.
        Chain of Responsibility Design Pattern: delegates commands to a chain of processing objects.
        Iterator pattern Design Pattern: accesses the elements of an object sequentially without exposing its underlying representation.
        Mediator Design Pattern: allows loose coupling between classes by being the only class that has detailed knowledge of their methods.
        Observer Design Pattern: is a publish/subscribe pattern which allows a number of observer objects to see an event.
        Visitor Design Pattern: separates an algorithm from an object structure by moving the hierarchy of methods into one object.
        Interpreter Design Pattern: implements a specialized language.
        Memento Design Pattern: provides the ability to restore an object to its previous state (undo).

Summary: In this article we are learn about software design patterns, All these design patterns are described in details with examples. I hope you will find it useful these article.


Keen to hear from you...!

If you have any questions related to what's mentioned in the article or need help with any issue, ask it, I would love to here from you. Please MakeUseOf Contact and i will be more than happy to help.

About the author

Anil Sharma is Chief Editor of dotnet-stuff.com. He's a software professional and loves to work with Microsoft .Net. He's usually writes articles about .Net related technologies and here to shares his experiences, personal notes, Tutorials, Examples, Problems & Solutions, Code Snippets, Reference Manual and Resources with C#, Asp.Net, Linq , Ajax, MVC, Entity Framework, WCF, SQL Server, jQuery, Visual Studio and much more...!!!

Loading