Refactoring advice, which design pattern to use - delphi

Question

Suppose I have an ancestor class (TMyAncestorClass), an enumerated type (TMyType) and some descendants class (TDesc1, TDesc2, TDesc3...)
type TMytype = (ta, tb, tc);
TMyAncestorClass= class
procedure DoSomething;
end;
TDesc1 = class(TMyAncestorClass)
end;
TDesc2 = class(TMyAncestorClass)
end;
TDesc3 = class(TMyAncestorClass)
end;
function CreateMyClass(aMyType: TMyType): TMyAncestorClass;
begin
case aMyType of
ta: Result := TDesc1.Create;
tb: Result := TDesc2.Create;
tc: Result := TDesc3.Create;
else
Result := nil; // or throw an exception
end;
end;
I want to refactor it. What is the best design pattern or solution for it? Now every time a new type is added I have to modify a CreateMyClass function too.

Answer 1

You could get rid of the enum completely by simply having CreateMyClass() take an integer instead, eg:
unit MyClasses;
interface
type
TMyAncestorClass = class
procedure DoSomething; virtual; abstract;
end;
function CreateMyClass(aMyType: Integer): TMyAncestorClass;
implementation
type
TDesc1 = class(TMyAncestorClass)
procedure DoSomething; override;
end;
TDesc2 = class(TMyAncestorClass)
procedure DoSomething; override;
end;
TDesc3 = class(TMyAncestorClass)
procedure DoSomething; override;
end;
...
function CreateMyClass(aMyType: Integer): TMyAncestorClass;
begin
case aMyType of
1: Result := TDesc1.Create;
2: Result := TDesc2.Create;
3: Result := TDesc3.Create;
else
Result := nil; // or throw an exception
end;
end;
end.
var
Obj: TMyAncestorClass;
begin
Obj := CreateMyClass(1, 2, 3, ...);
try
Obj.DoSomething;
finally
Obj.Free;
end;
end;
You could simplify that a little by using an array of class types, eg:
unit MyClasses;
interface
type
TMyAncestorClass = class
constructor Create; virtual; // <-- add this
procedure DoSomething; virtual; abstract;
end;
TMyAncestorClassType = class of TMyAncestorClass;
function CreateMyClass(aMyType: Integer): TMyAncestorClass;
implementation
type
TDesc1 = class(TMyAncestorClass)
constructor Create; override; // if needed
procedure DoSomething; override;
end;
TDesc2 = class(TMyAncestorClass)
constructor Create; override; // if needed
procedure DoSomething; override;
end;
TDesc3 = class(TMyAncestorClass)
constructor Create; override; // if needed
procedure DoSomething; override;
end;
...
constructor TMyAncestorClass.Create;
begin
inherited;
end;
function CreateMyClass(aMyType: Integer): TMyAncestorClass;
const
Types: array[1..3] of TMyAncestorClassType = (
TDesc1,
TDesc2,
TDesc3
);
begin
if aMyType >= Low(Types) and aMyType <= High(Types) then
Result := Types[aMyType].Create
else
Result := nil; // or throw an exception
end;
end.
var
Obj: TMyAncestorClass;
begin
Obj := CreateMyClass(1, 2, 3, ...);
try
Obj.DoSomething;
finally
Obj.Free;
end;
end;
Of course, this does mean you are still having to edit CreteMyClass() each time a new class is introduced. So, if you want something more dynamic, you will need to add a registration system at runtime, for example by storing class types in a lookup table like TDictionary, eg:
unit MyClasses;
interface
type
TMyAncestorClass = class
constructor Create; virtual;
procedure DoSomething; virtual; abstract;
end;
TMyAncestorClassType = class of TMyAncestorClass;
function RegisterMyClass(aClass: TMyAncestorClassType): Integer;
function CreateMyClass(aMyType: Integer): TMyAncestorClass;
implementation
uses
System.Generics.Collections;
var
RegisteredClasses: TDictionary<Integer, TMyAncestorClassType>;
Counter: Integer = 0;
constructor TMyAncestorClass.Create;
begin
inherited;
end;
function RegisterMyClass(aClass: TMyAncestorClassType): Integer;
begin
Result := Counter;
Inc(Counter);
RegisteredClasses.Add(Result, aClass);
end;
function CreateMyClass(aMyType: Integer): TMyAncestorClass;
var
LClass: TMyAncestorClassType;
begin
if RegisteredClasses.TryGetValue(aMyType, LClass) then
Result := LClass.Create
else
Result := nil; // or throw an exception
end;
initialization
RegisteredClasses := TDictionary<Integer, TMyAncestorClassType>.Create;
finalization
RegisteredClasses.Free;
end.
uses
..., MyClasses;
type
TDesc1 = class(TMyAncestorClass)
constructor Create; override; // if needed
procedure DoSomething; override;
end;
TDesc2 = class(TMyAncestorClass)
constructor Create; override; // if needed
procedure DoSomething; override;
end;
TDesc3 = class(TMyAncestorClass)
constructor Create; override; // if needed
procedure DoSomething; override;
end;
...
...
var
Desc1Type: Integer;
Desc2Type: Integer;
Desc3Type: Integer;
...
...
var
Obj: TMyAncestorClass;
begin
Obj := CreateMyClass(Desc1Type, Desc2Type, Desc3Type, ...);
...
Obj.Free;
end;
...
initialization
Desc1Type := RegisterMyClass(TDesc1);
Desc2Type := RegisterMyClass(TDesc2);
Desc3Type := RegisterMyClass(TDesc3);

Answer 2

Instead of an enumerated type, simply use the class type:
TMyType = class of TMyAncestorClass;
Then your function becomes trivial:
function CreateMyClass(aMyType: TMyType): TMyAncestorClass;
begin
Result := TMyType.Create;
end;
You call it like this:
var
X : TMyAncestroClass;
begin
X := CreateMyClass(TDesc1);
end;
Of course this is somewhat useless as is. But I guess you have a lot of other code in CreateMyClass(). BTW: I would have named it MyClassFactory.
Edit:
If you really need an enumerated type, then use the following additional code:
type
TMyTypeEnum = (ta, tb, tc);
const
MyTypes : array [TMyTypeEnum] of TMyType = (TDesc1, TDesc2, TDesc3);
The class factory is then:
function MyClassFactory(aMyType : TMyTypeEnum) : TMyAncestorClass;
begin
Result := MyTypes[aMyType].Create;
end;
And call it like this:
var
X : TMyAncestroClass;
begin
X := MyClassFactory(tb);
end;