Design Patterns study in C#

Creational Patterns in C#

Creational patterns in C# focus on efficient object creation while reducing coupling and promoting flexibility in design.

1. Singleton

Ensures a class has a single instance, using private constructors and static properties for controlled access.

2. Factory Method

Defines an interface for object creation, letting subclasses specify the type of objects to instantiate.

3. Abstract Factory

Provides an interface for creating families of related objects without specifying their concrete implementations.

4. Builder

Separates complex object construction from representation, enabling flexible configurations through method chaining in C#.

5. Prototype

Creates new objects by cloning existing ones, utilizing ICloneable and deep-copy techniques for duplicating complex objects.

Structural Patterns in C#

Structural patterns emphasize efficient class and object composition, ensuring modular, extensible, and scalable designs in C#.

1. Adapter

Converts one interface to another using inheritance or composition, allowing seamless integration of incompatible components.

2. Bridge

Decouples abstraction from implementation, enabling independent evolution of both through interfaces and composition in C#.

3. Composite

Organizes objects into tree structures to represent part-whole hierarchies, leveraging recursive relationships for complex systems.

4. Decorator

Adds responsibilities dynamically to objects without altering their structure, implemented with composition and interfaces.

5. Facade

Provides a simplified interface to complex subsystems, encapsulating their functionality into a single, cohesive API.

6. Flyweight

Minimizes memory usage by sharing common state among similar objects, often implemented with static caching in C#.

7. Proxy

Acts as a placeholder or surrogate, controlling access to another object using lazy loading or remote proxies.

Behavioral Patterns in C#

Behavioral patterns in C# manage object communication and workflows, promoting dynamic, loosely-coupled systems.

1. Chain of Responsibility

Passes requests through a chain of handlers, allowing each to decide whether to process or forward the request.

2. Command

Encapsulates requests as objects, enabling flexible execution, queuing, and undo/redo operations in C#.

3. Interpreter

Defines and evaluates a grammar for a language, suitable for scripting engines and domain-specific languages.

4. Iterator

Provides a standard way to traverse collections, leveraging IEnumerable and IEnumerator for seamless iteration.

5. Mediator

Centralizes communication between objects, reducing dependencies by using events, delegates, or a mediator class.

6. Memento

Captures and restores an object’s internal state without exposing implementation details, useful for undo functionality.

7. Observer

Establishes a one-to-many relationship where changes in one object notify dependents, using events or delegates.

8. State

Changes an object’s behavior based on its state, modeled using polymorphism or a state pattern implementation.

9. Strategy

Encapsulates algorithms within classes, allowing dynamic substitution of strategies for tasks like validation or sorting.

10. Template Method

Defines an algorithm’s skeleton in a base class, allowing subclasses to override specific steps while retaining structure.

11. Visitor

Encapsulates operations to be performed on object structures, enabling new functionality without altering the objects.