Pattern: Template Method

Definition

"Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm''''s structure."

This pattern is essentially an extension of abstract methods to more complex algorithms.

Applications in Delphi

Abstraction is implemented in Delphi by abstract virtual methods. Abstract methods differ from virtual methods by the base class not providing any implementation. The descendant class is completely responsible for implementing an abstract method. Calling an abstract method that has not been overridden will result in a runtime error.

A typical example of abstraction is the TGraphic class.

TGraphic is an abstract class used to implement TBitmap, TIcon and TMetafile. Other developers have frequently used TGraphic as the basis for other graphics objects such as PCX, GIF, JPG representations. TGraphic defines abstract methods such as Draw, LoadFromFile and SaveToFile which are then overridden in the concrete classes. Other objects that use TGraphic, such as a TCanvas only know about the abstract Draw method, yet are used with the concrete class at runtime.

Many classes that use complex algorithms are likely to benefit from abstraction using the template method approach. Typical examples include data compression, encryption and advanced graphics processing.

Implementation Example

To implement template methods you need an abstract class and concrete classes for each alternate implementation. Define a public interface to an algorithm in an abstract base class. In that public method, implement the steps of the algorithm in calls to protected abstract methods of the class. In concrete classes derived from the base class, override each step of the algorithm with a concrete implementation specific to that class.

This example shows some very simple alogrithm steps, but illustrates the principle of deferring implementation to a subclass.

unit Tpl_meth;



interface



type

  TAbstractTemplateClass = class(TObject)

  protected

    function Algorithm_StepA: Integer; virtual; abstract;

    function Algorithm_StepB: Integer; virtual; abstract;

    function Algorithm_StepC: Integer; virtual; abstract;

  public

    function Algorithm: Integer;

  end;



  TConcreteClassA = class(TAbstractTemplateClass)

  protected

    function Algorithm_StepA: Integer; override;

    function Algorithm_StepB: Integer; override;

    function Algorithm_StepC: Integer; override;

  end;



  TConcreteClassB = class(TAbstractTemplateClass)

  protected

    function Algorithm_StepA: Integer; override;

    function Algorithm_StepB: Integer; override;

    function Algorithm_StepC: Integer; override;

  end;

Pattern: Builder

Definition

"Separate the construction of a complex object from its representation so that the same construction process can create different representations."

A Builder seems similar in concept to the Abstract Factory. The difference as I see it is the Builder refers to single complex objects of different concrete classes but containing multiple parts, whereas the abstract factory lets you create whole families of concrete classes. For example, a builder might construct a house, cottage or office. You might employ a different builder for a brick house or a timber house, though you would give them both similar instructions about the size and shape of the house. On the other hand the factory generates parts and not the whole. It might produce a range of windows for buildings, or it might produce a quite different range of windows for cars.

Applications in Delphi

The functionality used in Delphi''''s VCL to create forms and components is similar in concept to the builder. Delphi creates forms using a common interface, through Application.CreateForm and through the TForm class constructor. TForm implements a common constructor using the resource information (DFM file) to instantiate the components owned by the form. Many descendant classes reuse this same construction process to create different representations. Delphi also makes developer extensions easy. TForm''''s OnCreate event also adds a hook into the builder process to make the functionality easy to extend.

Implementation Example

The following example includes a class TAbstractFormBuilder and two concrete classes TRedFormBuilder and TBlueFormBuilder. For ease of development some common functionality of the concrete classes has been moved into the shared TAbstractFormBuilder class.

type

  TAbstractFormBuilder = class

  private

    FForm: TForm;

    procedure BuilderFormClose(Sender: TObject; var Action: TCloseAction);

  protected

    function GetForm: TForm; virtual;

  public

    procedure CreateForm(AOwner: TComponent); virtual;

    procedure CreateSpeedButton; virtual; abstract;

    procedure CreateEdit; virtual; abstract;

    procedure CreateLabel; virtual; abstract;

    property Form: TForm read GetForm;

  end;



type

  TRedFormBuilder = class(TAbstractFormBuilder)

  private

    FNextLeft, FNextTop: Integer;

  public

    procedure CreateForm(AOwner: TComponent); override;

    procedure CreateSpeedButton; override;

    procedure CreateEdit; override;

    procedure CreateLabel; override;

  end;



type

  TBlueFormBuilder = class(TAbstractFormBuilder)

  private

    FNextLeft, FNextTop: Integer;

  public

    procedure CreateForm(AOwner: TComponent); override;

    procedure CreateSpeedButton; override;

    procedure CreateEdit; override;

    procedure CreateLabel; override;

  end;

At runtime the client application instructs one of the concrete classes to create parts using the public part creation procedures. The concrete builder instance is passed to the folliwing procedure:

procedure TForm1.Create3ComponentFormUsingBuilder(ABuilder: TAbstractFormBuilder);

var

  NewForm: TForm;

begin

  with ABuilder do begin

    CreateForm(Application);

    CreateEdit;

    CreateSpeedButton;

    CreateLabel;

    NewForm := Form;

    if NewForm <> nil then NewForm.Show;

  end;

end;

Pattern: Abstract Factory

Definition

"Provide an interface for creating families of related or dependant objects without specifying their concrete classes."

The Factory Method pattern below is commonly used in this pattern.

Applications in Delphi

This pattern is ideal where you want to isolate your application from the implementation of the concrete classes. For example if you wanted to overlay Delphi''''s VCL with a common VCL layer for both 16 and 32 bit applications, you might start with the abstract factory as a base.

Implementation Example

The following example uses an abstract factory and two concrete factory classes to implement different styles of user interface components. TOAbstractFactory is a singleton class, since we usually want one factory to be used for the whole application.

TOAbstractFactory = class(TObject)

  public

    constructor Create;

    destructor Destroy; override;

    { abstract widget constructors }

    function CreateSpeedButton(AOwner: TComponent): TSpeedButton; virtual; abstract;

    function CreateEdit(A
上一页  [1] [2] [3] [4]  下一页