This web site uses cookies. By using the site you accept the cookie policy.This message is for compliance with the UK ICO law.

<< Previous | 1 | 2 | 3 | 4 | Next >> |
A Generic Object PoolA Generic Object Pool
The object pool design pattern can improve performance by reusing objects that are expensive to instantiate, rather than creating new instances. This article describes a generic implementation of the object pool pattern.
Object Pool Design PatternObject Pool Design Pattern
The object pool pattern is a creational design pattern that can improve performance when working with classes that are slow to instantiate. Rather than constructing new objects, reusable objects are retrieved from, and released to, a pool as required.
Null Object Design PatternNull Object Design Pattern
The null object pattern is a design pattern that simplifies the use of dependencies that can be undefined. This is achieved by using instances of a concrete class that implements a known interface, instead of null references.
Object PipelinesObject Pipelines
A pipeline is a chain of connected steps that process information. In object pipelines, each step receives an object and performs an action using it before passing an object to the next step. This repeats until every step is complete.
Multiton Design PatternMultiton Design Pattern
The Multiton design pattern is an extension of the singleton pattern. It ensures that a limited number of instances of a class can exist by specifying a key for each instance and allowing only a single object to be created for each of those keys.
Non-Virtual Interface Design PatternNon-Virtual Interface Design Pattern
The non-virtual interface pattern is a design pattern that controls how methods in a base class are overridden. Base classes include public, non-virtual members that may be called by clients and a set of overridable methods containing core functionality.
A Basic IoC ContainerA Basic IoC Container
Inversion of control (IoC) containers provide a specialised form of the service locator pattern that simplifies the way in which dependencies are registered and later resolved. This article describes how to create a basic IoC container using generics.
Service Locator Design PatternService Locator Design Pattern
The service locator pattern is a design pattern that is used to decouple a class from its dependencies. Rather than the dependant class instantiating its dependencies directly, they are requested from a centralised service locator object.
Dependency InjectionDependency Injection
Dependency injection is a technique used in object-oriented programming languages. It promotes loose coupling of components by passing dependencies to an object, rather than having an object instantiate its own dependencies.
Pessimistic LockingPessimistic Locking
Pessimistic locking concurrency control systems use locking to prevent collisions caused when multiple users attempt to access the same shared data. In this article, the final part of three, a simple pessimistic locking system is created using SQL Server.
<< Previous | 1 | 2 | 3 | 4 | Next >> |