The Observer pattern involves a one-to-many relationship between objects, where one object (the subject) maintains a list of its dependents (observers) and notifies them of any changes, while the Pub-Sub pattern involves the publish and subscribe mechanism, where the publisher does not know the subscribers and the subscribers do not know the publishers.

Iterator pattern is a design pattern that allows the client to traverse a collection of objects, without exposing the underlying representation of the collection. The pattern involves creating an iterator class that implements the iterator interface, and provides a way for the client to access the elements of the collection one at a time, in a standardized manner. This pattern can be useful in situations where you want to provide a standard way for the client to access the elements of a collection, without exposing the internal representation of the collection.

The Builder pattern is used for creating complex objects step by step, using a builder object to abstract the process of creating the object from the client code

Dependency Injection is a design pattern that allows an object to be decoupled from its dependencies. Instead of an object creating or finding its own dependencies, they are passed to it from the outside. This improves the flexibility and maintainability of the code by allowing dependencies to be swapped out or updated without affecting the objects that use them.

The Decorator pattern adds behavior to an object dynamically, while the Proxy pattern provides a substitute for an object to control access to it

Proxy pattern is a design pattern that allows objects to represent or act on behalf of other objects, providing a level of indirection between the client and the target object. The pattern involves creating a proxy class that acts as an intermediary between the client and the target object. This pattern can be useful in situations where you want to add additional functionality or control access to an object, without affecting the behavior of the target object.

Composite Entity pattern is used to represent entities that have a tree structure, such as an organizational chart.

The Memento pattern is a design pattern that captures the internal state of an object, allowing the object to be restored to this state later. The Memento pattern is used to capture and store the internal state of an object so that it can be restored at a later time, without violating the object's encapsulation. The Memento pattern is used to implement undo/redo functionality in applications.

The Null Object pattern provides an object as a substitute for a null reference, avoiding the need for checking for null values.

Business Delegate pattern provides a simplified interface to a set of services to reduce the coupling between presentation-tier clients and business services.