C# Design Patterns Made Simple

C# Design Patterns

Abstract Factory Adapter Bridge Builder Chain of Responsibility Command Composite Decorator Façade (Facade) Factory Method Flyweight Interpreter Iterator Mediator Memento Observer Prototype Proxy Singleton State Strategy Template Method Visitor

edit

Design Patterns for C# and Visual C#

C# Design Patterns illustrates twenty-three classic Gang of Four (GoF) design patterns—as well as the patterns which grew from them—as they are used in the C# language on the .NET framework.

These design patterns are standards; but, their implementations can vary with the object-oriented language. In fact, sometimes the source code can look almost identical—as in the Java and C# languages—;yet, the pattern works in one and not the other. Accordingly, you cannot necessarily translate a Java pattern into a C# pattern and have it work and vice versa.

Implementations can also vary within the C# language with each version having its own strengths and weaknesses. For example, there are at least five ways to implement the simplest of patterns—the Singleton.

What is a design pattern?

Contents 1 Design Patterns for C# and Visual C# 2 Behavioral design patterns 3 Creational design patterns 4 Structural design patterns 5 See also

Behavioral design patterns

Chain of Responsibility	Define a method of passing a request among a chain of objects.
Command	Encapsulate a command request in an object.
Interpreter	Allow inclusion of language elements in an application.
Iterator	Enable sequential access to collection elements.
Mediator	Define simplified communication between classes.
Memento	Save and restore the internal state of an object.
Observer	Define a scheme for notifying objects of changes to another object.
State	Alter the behavior of an object when its state changes.
Strategy	Encapsulate an algorithm inside a class.
Template Method	Allow subclasses to redefine the steps of an algorithm.
Visitor	Define a new operation on a class without changint it.

Creational design patterns

Abstract Factory	Encapsulate a set of analogous factories that produce families of objects.
Builder	Encapsulate the construction of complex objects from their representation; so, the same building process can create various representations by specifying only type and content.
Factory Method	Allow subclasses to "decide" which class to instantiate.
Prototype	Create an initialized instance for cloning or copying.
Singleton	Ensure that only a single instance of a class exists and provide a single method for gaining access to it.

Structural design patterns

Adapter	Adapt an interface to an expected interface.
Bridge	Decouple an interface from its implementation.
Composite	Create a tree structure for part-whole hierarchies.
Decorator	Extend functionality dynamically.
Façade (Facade)	Simplify usage by defining a high-level interface.
Flyweight	Support fine-grained objects efficiently by sharing.
Proxy	Represent an object with another object for access control.

See also

• Abstract Factory Design Pattern Implementation in C#
• Abstract-Class Bridge-Pattern Variation
• Editing Text Using the Command Pattern
• Essentials of the Factory Pattern
• Immutable Types Are Scalable Types - Immutable pattern
• Implementing Interfaces - Bridge pattern
• Nested Private-Class Bridge-Pattern Variation
• Use the NVI Pattern - the Non-Virtual Interface (NVI) pattern makes a public interface to a base class nonvirtual.
• What is a design pattern?