Delphi OOP force to re-implement method from inherited class - delphi

Question

I have a child class TChildClass that descend from TBaseClass. TBaseClass has a method function foo: string; that TChildClass must always implement!
IMyInterface = Interface(IInterface)
function foo: string;
end;
TBaseClass = class(TInterfacedObject, IMyInterface)
public
function foo: string;
end;
TChildClass = class(TBaseClass , IMyInterface)
public
function foo: string;
end;
i want TChildClass always implement function foo and call inherited from TBaseClass:
function TBaseClass.foo: string
begin
Result := 'Hello';
end;
function TChildClass.foo: string
begin
Result := inherited;
Result := Result + ' world!';
end;
how to make it?

Answer 1

You cannot force the compiler to require the override at compile-time.
In order for TChildClass to override foo(), foo() needs to be declared as virtual in TBaseClass (but NOT also abstract, since you want TBaseClass.foo() to have a default implementation, otherwise the compiler will complain!). And, unlike with C++, Delphi does not require abstract methods to be overridden, and it allows code to create instances of abstract classes at runtime (even though calling abstract methods that have not been overridden will cause runtime errors).
However, you can validate at runtime whether TBaseClass.foo() has been overridden in a descendant or not, eg:
type
IMyInterface = Interface(IInterface)
function foo: string;
end;
TBaseClass = class(TInterfacedObject, IMyInterface)
public
function foo: string; virtual;
end;
TChildClass = class(TBaseClass, IMyInterface)
public
function foo: string; override;
end;
function TBaseClass.foo: string;
type
TFoo = function: string of object;
var
Impl, Base: TFoo;
ClassTBase: TClass;
begin
Impl := foo;
ClassTBase := TBaseClass;
Base := TBaseClass(#ClassTBase).foo;
if TMethod(Impl).Code = TMethod(Base).Code then
raise Exception.CreateFmt('foo() not implemented in class ''%s''', [ClassName]);
Result := 'Hello';
end;
function TChildClass.foo: string;
begin
Result := inherited foo;
Result := Result + ' world!';
end;
But, there is nothing you can do to force TChildClass.foo() to call inherited, that is strictly up to TChildClass to decide on its own.

Answer 2

You can't per se. However you can achieve what you want a slightly different way.
type
IMyInterface = Interface(IInterface)
function foo: string;
end;
TBaseClass = class(TInterfacedObject, IMyInterface)
protected
function fooForced : string; virtual; abstract;
public
function foo: string;
end;
TChildClass = class(TBaseClass , IMyInterface)
protected
function fooForced: string; override;
end;
function TBaseClass.foo: string;
begin
Result := 'Hello' + FooForced;
end;
function TChildClass.fooForced: string;
begin
Result := ' world!';
end;
Note - you must take heed of 'creating abstract class' warnings!

Answer 3

I think using an abstract method one way or another is probably the cleanest way to go. Like Dsm already mentioned, you can't get it exactly as you want, because an abstract method doesn't have an implementation, so you can't call that method in the baseclass.
This alternative is pretty close, but it requires digging into the RTTI. It's up to you if it's worth it for your purpose. What is basically does: dig into the list of methods of the class. For the method with the given name, check what the classname of its implementor is. If it is TBaseClass, throw an exception, otherwise continue.
I'm pretty sure that his will fail if you would implement an overload of the method foo, though, so it's not waterproof. Maybe there are ways to check if the found method is indeed an override, but TRttiMethod doesn't seem to provide anything for that out of the box.
The code example is heavily inspired on RRUZ's answer, here.
TBaseClass = class(TInterfacedObject, IMyInterface)
private
procedure ValidateDescendantImplements(MethodName: string);
public
function foo: string;
end;
function TBaseClass.foo: string;
begin
ValidateDescendantImplements('foo');
Result := 'Hello';
end;
procedure TBaseClass.ValidateDescendantImplements(MethodName: string);
var
m: TRttiMethod;
begin
for m in TRttiContext.Create.GetType(Self.ClassType).GetDeclaredMethods do
begin
if SameText(m.Name, MethodName) then
if m.Parent.Name <> TBaseClass.ClassName then
Exit
end;
raise Exception.CreateFmt('%s needs to be overridden', [MethodName]);
end;
Usage:
TChildClass.Create.foo; // Works
TBaseClass.Create.foo; // Throws exception