Design Patterns in .NET

There are three types of Design Pattern :

1. Creational – This type deals with the object creation and initialization.

2. Structural – This type deals with the class & object composition.

3. Behavioral – This type deals with the communication between class & object.

The four authors Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides are collectively introduced Gang of Four Design Patterns in Software development. In 1994, they published a book (Design Patterns: Elements of Reusable Object-Oriented Software) for explaining the concept of Design Patterns.

The 23 Design patterns are defined by the Gang of Four programmers, These 23 patterns are divided into three groups:

Creational Design Patterns:

Factory Method : Create instances of derived classes
Abstract Factory : Create instances of several classes belonging to different families
Builder : Separates an object construction from its representation
Prototype : Create a duplicate object or clone of the object
Singleton : Ensures that a class can has only one instance

Structural Design Patterns:

Adapter : Match interfaces of different classes
Bridge : Separates an object’s abstraction from its implementation
Composite : A tree structure of simple and composite objects
Decorator : Add responsibilities to objects dynamically
Façade : A single class that represents an entire complex system
Flyweight : Minimize memory usage by sharing as much data as possible with similar objects
Proxy : Provides a surrogate object, which references to other object

Bhavioural Design Patterns:

Chain of Responsibility: Passes a request among a list or chain of objects.
Command: Wraps a request under an object as a command and passed to invoker object.
Interpreter: Implements an expression interface to interpret a particular context.
Iterator: Provides a way to access the elements of a collection object in sequential manner without knowing its underlying structure.
Mediator: Allows multiple objects to communicate with each other’s without knowing each other’s structure.
Memento: Capture the current state of an object and store it in such a manner that it can be restored at a later time without breaking the rules of encapsulation.
Observer: Allows an object (subject) to publish changes to its state and other objects (observer) that depend upon that object are automatically notified of any changes to the subject’s state.
State: Alters the behavior of an object when it’s internal state changes.
Strategy: Allows a client to choose an algorithm from a family of algorithms at run-time and gives it a simple way to access it.
Visitor: Creates and performs new operations onto a set of objects without changing the object structure or classes.
Template Method: Defines the basic steps of an algorithm and allow the implementation of the individual steps to be changed.