dynamic function loading

Lazy loading is a design pattern commonly used in computer programming to defer initialization of an object until the point at which it is needed. It can contribute to efficiency in the program's operation if properly and appropriately used. The opposite of lazy loading is Eager Loading.

Implementations

There are four ways of implementing the lazy load design pattern: lazy initialization; a virtual proxy; a ghost and a value holder^[1]. Each has its own advantages and disadvantages.

Lazy initialization

Main article: Lazy initialization

With lazy initialization, the object to be lazily loaded is originally set to null, and every request for the object checks for null and creates it "on the fly" before returning it first, as in this C# example:

private int _myWidgetID;
private Widget _myWidget = null;

public Widget MyWidget {
  get {
    if (_myWidget == null) {
      _myWidget = Widget.Load(_myWidgetID);
    }
    return _myWidget;
  }
}

This method is the simplest to implement, although if null is a legitimate return value, it may be necessary to use a placeholder object to signal that it has not been initialized.

Virtual proxy

A virtual proxy is an object that "looks like" the object that is to be lazily loaded. Both the object and the proxy implement the same interface, with the proxy providing a wrapper that instantiates and initializes the object when one of its properties is accessed for the first time.

Ghost

A ghost is the object that is to be loaded in a partial state. It may only contain the object's identifier, but it loads its own data the first time one of its properties is accessed.

Value holder

A value holder is a generic object that handles the lazy loading behavior, and appears in place of the object's data fields:

private ValueHolder _myWidget;

public Widget MyWidget {
  get {
    return (Widget)_myWidget.GetValue();
  }
}

See also

• Design pattern
• Proxy
• Lazy Inheritance
• lazy evaluation

References

Donate to Wikimedia