Delphi Base Class Factory

Im not sure if this is a good pattern or not, or if you can do something simillar in Java, c plus plus etc.. But here goes

-SteveEyles

It could be better. You're using a switch on the type in a palce where you should be using virtual method calls.This also makes the base class dependent on all its subclasses.

As a matter of fact DelphiLanguage doesn't need the factory pattern because it has Factory, AbstractFactory and a few other DesignPatterns are in fact workarounds for languages with limited abilities. So here's how you can fix it:

Define a virtual constructor on the base class.
Define a collection indexed by TApeType (or even a string) that returns class of TApe
Call the virtual constructor: return myTypes[index].create(...)

This way you replace the case ... statement with a virtual call. It is slightly more elegant, and it allows for greater flexibility, you can make the factory mechanism. Delphi is quite unique among typed OO languages in the sense that it allows virtual constructors. --CostinCozianu

interface

type
TApeType = (atGorilla, atOrangutan, atChimp);

EUnknownApe = class(Exception);

TApe = class(TObject)
public
        class function CreateFactory(const ApeType : TApeType) : TApe;
end;

TGorilla = class(TApe);
TOrangutan = class(TApe);
TChimp = class(TApe);

implementation

class function TApe.CreateFactory(const ApeType : TApeType) : TApe;
begin
        case ApeType of
        atGorilla       : Result := TGorilla.Create;
        atOrangutan : Result := TOrangutan.Create;
        atChimp : Result := TChimp.Create;
        else
        raise EUnknownApe.Create;
        end;
end;

I can now dynamically create one of the 3 descendent classes without needing to see there interfaces, I only need to see the interface of TApe. (In actual use the 3 descendants would be in separate units). Putting 'class' in front of a method is the same as using 'static' in C plus plus

Some refactoring:

interface

type
  TApeType = (atGorilla, atOrangutan, atChimp);

TApe = class(TObject)
public
        class function CreateFactory(const ApeType : TApeType) : TApe;
end;

TApeClass = class of TApe;

TGorrila = class(TApe);
TOrangutan = class(TApe);
TChimp = class(TApe);

implementation

const theApeClasses: array[TApeType] of TApeClass = (TGorrila, TOrangutan, TChimp);

class function TApe.CreateFactory(const ApeType : TApeType) : TApe;
begin
   Result := theApeClasses[ApeType].Create;
end;

More refactoring:

interface

type

TApe = class(TObject)
public
        class function CreateApe(const ApeType : TApeType) : TApe;
end;

TApeClass = class of TApe;
TApeType = TApeClass;

TGorrila = class(TApe);
TOrangutan = class(TApe);
TChimp = class(TApe);

implementation

class function TApe.CreateApe(const ApeType : TApeType) : TApe;
begin
   Result := TpeType.Create;
end;

yet more refactoring:

TApe = class(TObject)
public
        constructor Create; virtual;
end;

Actually, the class factory should be really that: a class factory. It returns the class you want to instantiate, leaving instantiating up to you. You can design the getApsClass function to take a string parameter, or an int, or anything else you might desire -- it doesn't matter. It gives you a class of TApe you can call Create() on. I prefer this to returning an instantiated object.--ATS.

interface

type

TApe = class(TObject)
public
  constructor Create; virtual;
  class function getApeClass() : TApeClass;
end;

TApeClass = class of TApe;

TGorrila = class(TApe);
TOrangutan = class(TApe);
TChimp = class(TApe);

implementation

...



{somewhere in your code}}
TApe.getApeClass().Create();