This pattern virtualises storage of entities in a persistent medium.

It uses encapsulation technique to store the data.

It allows the use of a common set of methods in the application.

Its instance lifetime is that of the application domain.

The repository uses a series of providers to connect to the source data.

This pattern specifies the class creation for a particular object only.

It is useful for exposing read-only data.

This pattern virtualises storage of entities in a persistent medium.

The static methods do not rely on instance data.

If this is the first call to the method that returns the instance, the Singleton creates an instance, populates it with any required data and returns that instance.

There is less coupling during the request sent to the receiver.

There is a chaining process to manage the request for the objects.

The several linked objects respond to a request or hand it off to the object next in line.

The frequency of chained objects propagates from high to low.

This pattern encapsulates a request as an object.

It represents and interprets the component behaviour.

It encapsulates a request as an object.

It avoids coupling the sender of a request to its receiver.

It defines the creation of a class for which only a single instance can exist.

It virtualises storage of entities in a persistent medium.

These provide reusability to the business logic in the application components.

The model has information about the data in the application.

The controller or presenter links the model and the view.

These patterns have a series of providers to connect to the source data.

The user interaction with the view raises events in the controller, which updates the model.

It declares an interface to receive and act in extrinsic state.

It is used to make an independent implementation for the abstract view.

It separates the construction of a complex object from its representation.

It specifies an abstract interface for creating parts of a product object.

It constructs an object using the builder interface.

It is used to specify the objects with their underlying representation.

It encapsulates a request as an object.

It avoids coupling the sender of a request to its receiver.

It defines the creation of a class for which only a single instance can exist.

It virtualises storage of entities in a persistent medium.

It falls under 'Structural' pattern.

It maintains a reference to an object of type implementer.

It defines an interface having members that will be implemented by RealSubject and Proxy class.

This is a class which we want to use more efficiently by using proxy class.

This is a class which holds the instance of RealSubject class and can access RealSubject class members as required.

It declares an interface common to all supported algorithms.

A strategy interface is used to implement the class for the algorithms.

It allows an object to alter its behaviour when its internal state changes.

It maintains a reference to a strategy object.

It may define an interface that lets strategy access its data.

It connects two incompatible interfaces.

It defines the domain-specific interface that a client uses.

It collaborates with objects conforming to any interface.

It adapts the interface adaptee to the target interface.

It defines an existing interface that needs adapting.

It is used to combine two or more interfaces.

There are domain-specific interface applied for the client.

It defines an existing interface that needs adapting.

It collaborates with objects conforming to the target interface.

It extends the interface defined by abstraction.

It declares an interface for cloning itself.

It implements an operation for cloning itself.

It defines the abstraction interface.

It creates a new object by asking a prototype to clone itself.

It uses a prototype instance for each object.

This pattern defines a one-to-many dependency between objects.

It collaborates with objects conforming to the target interface.

It knows its observers.

An updatable interface is needed for all the objects to be notified.

It stores state of interest to ConcreteObserver.

It captures and externalises an object's internal state, so that the object can be restored to this state later.

It protects against access of objects by other than the originator.

It defines an object that encapsulates how a set of objects interact.

The internal state of the memento is accessible by the originator only.

It never operates on or examines the contents of a memento.

There must be an interface to specify the state of the objects.

It converts the interface of a class into another interface clients expect.

The state of storage must be intrinsic.

Not all Flyweight subclasses need to be shared.

It uses sharing to support large numbers of fine-grained objects efficiently.