The Flyweight pattern is intended to use sharing to support large numbers of fine-grained objects more efficiently and reduce resource usage. The Flyweight pattern is especially useful when there is a need of many, many similar objects. When I hear flyweight, I instantly think about characters in words, sentences, and stories. If a character is [...]
Browsing Posts tagged Structural Patterns
The Bridge pattern is intended to decouple an abstraction from its implementation so both can vary independently. The bridge pattern is especially useful when you are in need of a sophisticated wrapper for varying implementations. Although it is not an overwhelming simple pattern, it is very simple in its use. The client only has to [...]
The Facade pattern is intended to provide an unified interface to a set of interfaces in a subsystem. It defines a higher-level interface that makes the subsystems easier to use. In simple terms: this pattern is very useful when you have an great amount of scattered functionality available across a couple of class libraries and [...]
The Composite pattern is intended to allow you to compose tree structures to represent whole-part hierarchies so that clients can treat individual objects and compositions of objects uniformly. When I hear "composite pattern", immediately XML pops up in my mind. A composite is an element and a leaf is an attribute. <composite> <composite leaf="value"> Important [...]
The Abstract Factory pattern provides a way to encapsulate a group of individual factories that have a common theme. In normal usage, the client software would create a concrete implementation of the abstract factory and then use the generic interfaces to create the concrete objects that are part of the theme. The client does not [...]
The Decorator pattern is intended to give you a way to extend the behavior of an object or to dynamically compose an object’s behavior at runtime. The Decorator Pattern is used for adding additional functionality to a particular object as opposed to a class of objects. It is easy to add functionality to an entire [...]
The Adapter pattern is intended to provide a way to use an object whose interface is different from the on expected by the client, without having to modify either. There are two ways to create an adapter: by inheritance or by object composition. In the first case, which generally is considered best practice, we derive [...]
The Proxy pattern is intended to provide you with a simple placeholder that takes the place of a more complex object that may be invoked later. It is a kind of "wrapper" that delegates to the real object. The Proxy pattern is especially useful for situations where object creation is a time consuming process, and [...]
