Tag: behavioral

Encapsulate a cluster of domain objects treated as a single unit for data changes. An Aggregate Root controls access to its internal entities and value objects.

A shared knowledge space where independent specialized modules collaborate to solve complex problems by contributing partial solutions.

Reduce coupling between presentation and business tiers by introducing an intermediary that handles lookup, creation, and invocation of business services.

Pass requests along a chain of handlers until one handles it. A behavioral design pattern for decoupling senders and receivers.

Encapsulate a request as an object, letting you parameterize clients with queues, logs, and undoable operations. A behavioral design pattern.

Encapsulate state and services needed by multiple components into a single context object, reducing method signature bloat and decoupling code from specific environment details.

Capture and publish major occurrences within a domain model to decouple side effects from core business logic and enable reactive workflows.

Decouple components by routing events through a central bus. A behavioral pattern for loosely coupled communication between modules.

Compose cross-cutting concerns into a chain of pluggable filters that intercept requests and responses, enabling reusable preprocessing and postprocessing logic.

Define a representation for a language's grammar along with an interpreter that uses the representation to interpret sentences. A behavioral design pattern for mini-languages.

Provide a way to access elements of a collection sequentially without exposing its underlying representation. A behavioral design pattern for traversal.

Encapsulate lifecycle, coordination, and access control for a set of related objects through a dedicated manager class that centralizes operations and enforces invariants.

Define an object that encapsulates how a set of objects interact. A behavioral design pattern for reducing chaotic dependencies.

Capture and restore an object's internal state without violating encapsulation. A behavioral design pattern for undo/redo.

Use a default object instead of null references to eliminate null checks and simplify client code. A behavioral pattern for safer defaults.

Define a subscription mechanism to notify multiple objects about events. A behavioral design pattern for event-driven communication.

Reliably publish domain events by persisting them in an outbox table within the same database transaction as the business operation.

Enable third-party extensions by defining extension points in a host system that loads and executes live external modules.

Assign dynamic roles to objects at runtime instead of hard-coding behavior in class hierarchies, enabling flexible identity changes without inheritance bloat.

Allow an object to alter its behavior when its internal state changes. A behavioral design pattern for finite state machines.

Define a family of algorithms, encapsulate each one, and make them interchangeable. A behavioral design pattern for flexible behavior selection.

Define the skeleton of an algorithm in a base class, letting subclasses override specific steps without changing the algorithm's structure. A behavioral design pattern.

Represent an operation to be performed on elements of an object structure without changing the classes of the elements. A behavioral design pattern.

A guide to selecting and applying the right design pattern for common software engineering problems.