Question

first of all, sorry if the title is a bit confusing.

i’m planning to develop a small erp application. this apllication will use plugins/addons. this addon might add or extend some modules of the base application.

for example, i have TCustomer class with property “id”, and “name”.
addon 1 will add a property “dateofbirth”.
addon 2 will add a property “balance” and a method “GetBalance”.

addon 1 and addon 2 are not aware of each other. addon 1 might be installed and not addon 2 or vice versa. so both addons must inherit the base tcustomer class.

the problem is when both addon are installed. how do i get extended properties in both addons? i will also have to extend the form to add controls to show the new properties.

can it be done using delphi? what is the best way to achieve this? maybe you can point me to some articles of examples?

thanks and sorry for my poor english
Reynaldi

Answer 1

Well, as you are already aware, you can’t have more than one plug-in extend an existing class by inheritance. It would confuse the heck out of any app, including any programmer’s dealing with the code.

What you need is some type of register mechanism in your TCustomer class where every plugin can register its specific properties, or provide a couple of call back functions for when a TCustomer instance is created (initialized), loaded, stored, or deleted. The core TCustomer after all really doesn’t need to know more about the plug-in’s than the fact that they might exist.

Depending on how you intend to load/store your data, the core TCustomer class doesn’t even have to be aware of the extensions. It would be quite sufficient to make the persistence mechanism aware of plug-ins and provide a way for them to register a call back function to be called whenever a TCustomer / TOrder / TWhatever is initialized / loaded / saved / deleted.

You will also have to make the GUI aware of the plugins and provide the means for them to register pieces of UI to have the main GUI create an extra tab or some such for each plug-in’s specific controls.

Sorry no code example. Haven’t yet implemented this myself, though I thought about the design and it is on my list of things to play around with.

That said, to give you an idea, the basic mechanism could look something like this:

TBaseObject = class; // forward declaration

// Class that each plug-in's extensions of core classes needs to inherit from.
TExtension = class(TObject)
public
  procedure Initialize(aInstance: TBaseObject);
  procedure Load(aInstance: TBaseObject);
  procedure Store(aInstance: TBaseObject);
  procedure Delete(aInstance: TBaseObject);
end;

// Base class for all domain classes
TBaseObject = class(TObject)
private
  MyExtensions: TList<TExtension>;
public
  procedure RegisterExtension(const aExtension: TExtension);
  procedure Store;
end;

procedure TBaseObject.RegisterExtension(const aExtension: TExtension);
begin
  MyExtensions.Add(aExtension);
end;

procedure TBaseObject.Store;
var
  Extension: TExtension;
begin
  // Normal store code for the core properties of a class.
  InternalStore; 
  // Give each extension the opportunity to store their specific properties.
  for Extension in MyExtensions do
    Extension.Store(Self);
end;