📚 Structure

In this course, we’re going to cover the most important patterns in C#. There are three major groups of patterns:

Creational patterns (how objects are created)

Creational patterns focus on object creation strategies that make code more flexible and reusable. Most popular patterns in this category are:

• Singleton — Ensures a class has only one instance and provides a global access point (use sparingly; can hide dependencies).

• Factory Method — Defines an interface for creating an object, but lets subclasses decide which concrete type to instantiate.

• Abstract Factory — Creates families of related objects (compatible sets) without specifying their concrete classes.

• Builder — Constructs complex objects step-by-step; separates construction from representation (great when many optional parts).

• Prototype — Creates new objects by cloning an existing instance (useful when creation is expensive or configuration-heavy).

Structural patterns (how objects are composed)

Structural design patterns describe how to combine classes and objects into larger structures while maintaining flexibility and efficiency. Most popular patterns in this category are:

• Adapter — Makes incompatible interfaces work together by translating one interface into another.

• Facade — Provides a simplified, higher-level interface to a complex subsystem.

• Decorator — Adds behavior to an object dynamically by wrapping it (composition over inheritance).

• Proxy — Controls access to an object (lazy loading, remote access, caching, security, logging).

• Composite — Treats individual objects and groups of objects uniformly (tree structures: folders/files, menus).

• Bridge — Separates an abstraction from its implementation so both can vary independently (avoids subclass explosion).

• Flyweight — Reduces memory by sharing common state across many fine-grained objects (split intrinsic/extrinsic state).

Behavioral patterns (how objects interact/share responsibilities)

Behavioral patterns describe interaction models and responsibility delegation between objects. Most popular patterns in this category are:

• Strategy — Encapsulates interchangeable algorithms behind a common interface (swap behavior at runtime).

• Observer — One-to-many dependency: when the subject changes, observers are notified (events, pub/sub).

• Command — Encapsulates a request as an object (undo/redo, queues, logging, macro commands).

• State — Object changes behavior when its internal state changes (state-driven behavior without big if/switch).

• Template Method — Defines an algorithm skeleton in a base class, deferring steps to subclasses.

• Iterator — Provides a standard way to traverse a collection without exposing its internals.

• Mediator — Centralizes complex communications between objects to reduce coupling (a “traffic controller”).

• Chain of Responsibility — Passes a request along to handlers until one handles it (pipelines, middleware).

• Visitor — Adds new operations to object structures without modifying the classes (great for ASTs; can be heavy).

• Memento — Captures and restores an object’s internal state without exposing implementation (snapshots/undo).

• Interpreter — Defines grammar + interpreter for a mini-language (often replaced by parsers/expressions in practice).

Now, while this categorization is perfectly fine and we should know it, we’re going to organize the course a bit differently to make these patterns more approachable and to create a perfect learning curve.

🧠 Learning Progression Strategy Across the Whole Course

We’ll start with the easiest and the least abstract pattern and ease our way to the more complex and obscure ones.

Phase 1 – Foundations of Behavior

These patterns are intuitive, practical, and extremely common in .NET.

• Strategy
• Factory Method
• Template Method
• Observer
• Decorator

Why here?

• Minimal abstraction overhead
• Easy real-life analogies
• Appear constantly in ASP.NET Core
• Introduce composition, polymorphism, and OCP

Phase 2 – Composition & Structure Thinking

Now we think about object relationships and architecture.

• Adapter
• Facade
• Composite
• Proxy
• Bridge

Why here?

• Introduce structural reasoning
• Show layering and abstraction boundaries
• Very practical in enterprise apps

Phase 3 – Object Interaction & Responsibility Flow

Now we increase the abstraction level.

• State
• Command
• Iterator
• Chain of Responsibility
• Mediator

Why here?

• More abstract interaction patterns
• Closer to architectural design
• Important for clean architecture and pipelines

Phase 4 – Object Creation Mastery

Creation patterns are conceptually harder for beginners because they require understanding dependency inversion.

• Abstract Factory
• Builder
• Prototype
• Singleton

Why here?

• Abstraction is easier to understand now
• We use object families

Phase 5 – Advanced / Specialized Patterns

These require strong abstraction maturity.

• Visitor
• Memento
• Flyweight
• Interpreter

Why here?

• Used in compilers, ASTs, and editors
• Often overkill in normal business apps
• Good for senior-level understanding

❓ How to Choose the Right Pattern?

Selecting a pattern is about identifying the problem first, not memorizing definitions.

Ask yourself:

1. What changes most often — object creation, structure, or behavior?

2. Do I need polymorphic flexibility or simply better separation of concerns?

3. Is there a simpler alternative before adding another layer?

Patterns should reduce coupling, not add ceremony.

🎯 Learning Goals

By the end of the course, you will be able to:

1. Identify and classify design patterns correctly.
2. Implement the GoF and .NET-specific patterns idiomatically in C#.
3. Refactor legacy code to use appropriate patterns.
4. Combine patterns in practical architectures (ASP.NET Core, EF Core, CQRS).
5. Avoid anti-patterns and over-engineering.