Design Patterns in C#

1. Singleton Pattern

---------------------

Intent:

Ensure a class has only one instance and provide a global point of access to it.

Use Case:

Logger, Config Manager, Thread Pools

Code Example:

public sealed class Singleton {

private static Singleton _instance = null;

private static readonly object _lock = new object();

private Singleton() { }

public static Singleton Instance {

get {

lock (_lock) {

if (_instance == null)

_instance = new Singleton();

return _instance;

public void DoWork() {

Console.WriteLine("Singleton doing work");

}
Pros:

- Saves memory with lazy initialization

- Globally accessible instance

Cons:

- Difficult to unit test/mock

- Hidden dependencies

------------------------------------------------------------

2. Factory Method Pattern

--------------------------

Intent:

Define an interface for creating an object but let subclasses decide which class to instantiate.

Use Case:

Creating objects like Shapes, Buttons, Notifications

Code Example:

abstract class Product {

public abstract void Operation();

class ConcreteProductA : Product {

public override void Operation() => Console.WriteLine("Product A");

class ConcreteProductB : Product {

public override void Operation() => Console.WriteLine("Product B");

abstract class Creator {

public abstract Product FactoryMethod();

class ConcreteCreatorA : Creator {

public override Product FactoryMethod() => new ConcreteProductA();

class ConcreteCreatorB : Creator {

public override Product FactoryMethod() => new ConcreteProductB();

Pros:

- Decouples object creation from usage

- Easier to introduce new product types

Cons:

- More classes and code to manage

------------------------------------------------------------

3. Abstract Factory Pattern

-----------------------------

Intent:

Provide an interface for creating families of related objects without specifying their concrete classes.

Use Case:

Cross-platform UI components, Themes

Code Example:

interface IButton {

void Paint();

class WinButton : IButton {

class MacButton : IButton {

public void Paint() => Console.WriteLine("Mac Button");

interface IGUIFactory {

IButton CreateButton();

class WinFactory : IGUIFactory {

public IButton CreateButton() => new WinButton();

class MacFactory : IGUIFactory {

public IButton CreateButton() => new MacButton();

Pros:

- Supports consistency among products

- Easy to switch families

Cons:

- Difficult to add new product types

------------------------------------------------------------

4. Adapter Pattern

-------------------

Intent:

Convert the interface of a class into another interface the client expects.
Use Case:

Integration with legacy or external APIs

Code Example:

interface ITarget {

void Request();

class Adaptee {

public void SpecificRequest() => Console.WriteLine("SpecificRequest");

class Adapter : ITarget {

private Adaptee _adaptee = new Adaptee();

public void Request() => _adaptee.SpecificRequest();

Pros:

- Reuse existing code

- Improve compatibility

Cons:

- Added layer increases complexity

------------------------------------------------------------

5. Observer Pattern

--------------------

Intent:

One-to-many dependency between objects so when one object changes, others are notified.

Use Case:

Event listeners, Pub/Sub systems

interface IObserver {

void Update(string message);

interface ISubject {

void Attach(IObserver observer);

void Detach(IObserver observer);

void Notify();

class ConcreteSubject : ISubject {

private List<IObserver> observers = new();

private string message;

public void Attach(IObserver observer) => observers.Add(observer);

public void Detach(IObserver observer) => observers.Remove(observer);

public void Notify() {

foreach (var observer in observers)

observer.Update(message);

public void CreateMessage(string msg) {

message = msg;

Notify();

class ConcreteObserver : IObserver {

private string _name;

public ConcreteObserver(string name) => _name = name;

public void Update(string message) => Console.WriteLine($"{_name} received: {message}");

Pros:

- Loose coupling

- Dynamic subscriber list

Cons:

- Possible memory leaks

- Hard to debug

------------------------------------------------------------

6. Strategy Pattern

--------------------

Intent:

Define a family of algorithms, encapsulate each one, and make them interchangeable.

Use Case:

Payment options, compression algorithms

Code Example:

interface IStrategy {

void Execute();

class StrategyA : IStrategy {

public void Execute() => Console.WriteLine("Executing Strategy A");

class StrategyB : IStrategy {

public void Execute() => Console.WriteLine("Executing Strategy B");

}
class Context {

private IStrategy _strategy;

public Context(IStrategy strategy) => _strategy = strategy;

public void SetStrategy(IStrategy strategy) => _strategy = strategy;

public void ExecuteStrategy() => _strategy.Execute();

Pros:

- Easy to switch algorithms

- Eliminates conditionals

Cons:

- More code structure

- Overhead of additional classes

------------------------------------------------------------

Design Pattern Comparison Table

-------------------------------

| Pattern | Type | Intent | Use Case |

|------------------|-------------|---------------------------------------|-------------------------|

| Singleton | Creational | Ensure a single instance | Logger, Config Manager |

| Factory Method | Creational | Delegate instantiation to subclass | Button, Shape Factory |

| Abstract Factory | Creational | Create related object families | Cross-platform UI |

| Adapter | Structural | Match incompatible interfaces | Legacy integration |

| Observer | Behavioral | Notify multiple objects of change | Event systems |

| Strategy | Behavioral | Select algorithm at runtime | Payment systems |