MSDN Documentation

1. Singleton Pattern

Ensures that a class only has one instance and provides a global point of access to it.

When to Use:

• When exactly one object is needed to coordinate actions across the system.
• When a class needs to provide a single, well-known point of access to itself.

Example Use Case:

Managing a single database connection pool or a global configuration manager.

Code Snippet (Conceptual C#):

public sealed class Singleton
{
    private static readonly Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton Instance
    {
        get
        {
            return instance;
        }
    }

    public void DoSomething()
    {
        // ...
    }
}
            

2. Factory Method Pattern

Defines an interface for creating an object, but lets subclasses decide which class to instantiate.

When to Use:

• When a class cannot anticipate the class of objects it must create.
• When a class wants its subclasses to specify the objects it creates.

Example Use Case:

A document editor that can create different types of documents (e.g., text, spreadsheet, presentation).

Code Snippet (Conceptual Java):

abstract class Document {
    public abstract void open();
}

class TextDocument extends Document {
    @Override
    public void open() {
        System.out.println("Opening text document...");
    }
}

abstract class Application {
    public abstract Document createDocument();

    public void newDocument() {
        Document doc = createDocument();
        doc.open();
    }
}

class TextEditor extends Application {
    @Override
    public Document createDocument() {
        return new TextDocument();
    }
}
            

3. Observer Pattern

Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

When to Use:

• When a change to one object requires changing others, and you don't know how many objects will need to be changed.
• When an object should be able to notify other objects without making assumptions about who these objects are.

Example Use Case:

Stock market tickers, weather updates, or UI elements reacting to data changes.

Code Snippet (Conceptual JavaScript):

class Subject {
    constructor() {
        this.observers = [];
    }

    addObserver(observer) {
        this.observers.push(observer);
    }

    notify(data) {
        this.observers.forEach(observer => observer.update(data));
    }
}

class ConcreteObserver {
    update(data) {
        console.log("Observer received:", data);
    }
}

const subject = new Subject();
const observer1 = new ConcreteObserver();
const observer2 = new ConcreteObserver();

subject.addObserver(observer1);
subject.addObserver(observer2);

subject.notify("New data available!");
            

4. Strategy Pattern

Defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

When to Use:

• When you have many related classes of objects, differing only in their behavior.
• When you need to select an algorithm or behavior at runtime.

Example Use Case:

Implementing different sorting algorithms for a list, or different payment methods in an e-commerce system.

5. Decorator Pattern

Attaches additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.

When to Use:

• When you want to add responsibilities to individual objects, not to an entire class.
• When extensions by subclassing are impractical or impossible.

Example Use Case:

Adding logging, compression, or encryption to data streams.

6. Command Pattern

Encapsulates a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.

When to Use:

• When you need to issue requests without knowing the operation that will be performed or the receiver of the request.
• When you want to support undoable operations.

Example Use Case:

Implementing undo/redo functionality in an editor, or creating a remote control for various devices.