When I need a variation in procedures (standalone, not a class or object procedure) I use across my applications, I often find it more convenient to create a copy the unit into the project folder and make the changes there. Sometimes they get merged back into the shared unit or am thinking now of using classes with procedures, without any data in them, so that I subclass them in the projects where I need to change them. Are the some good examples and some known good working practices on working with procedures in this way?

one new implementation, that can be turned on and off for testing purposes. The $DEFINEs are set and documented near the top of the unit, as an overview of available options.

I am thinking now of using classes with procedures, without any data in them, so that I subclass them in the projects where I need to change them.

That's another useful solution.

DoDi

I do this. Sometimes I prefer encapsulate subroutines (LCL, RTL, 3rd etc) in static classes.

TmyFoo = class
public
  class procedure Exec; static;
end;

Marcos Douglas

Do you have some examples to show how it is done?

Are there some examples in the FCL/LCL etc

In FCL/LCL I don't know if exists.

My example:

type
  TMsg = class
  public
    class procedure Info(const ATxt: string); static;
  end;
implementation
class procedure TMsg.Info(const ATxt: string);
begin
  ShowMessage(ATxt);
end;

------------------------
Using:

begin
  TMsg.Info;
end;

Marcos Douglas

I see that you declare your procedure as static. Is that the way they should be or is that your own preference?
Is it possible to make them virtual and override them or replace them in descendant classes?

I'd say it is his own preference. Static methods are like normal, global functions/procedures except they are located inside classes. You can even pass them to non-object procedure variables. If you want to override them you should leave out the "static" and declare them "virtual" (this works with class methods as well as with normal methods).

Regards,
Sven

Static methods do not have Self implicit parameter. They are like normal procedure/function.
Without 'static' works too, but the assembler generated gets better with static. To override you should leave out the 'static' to use 'virtual'.

Marcos Douglas

Frank Church wrote

Is it possible to make them virtual and override them or replace them in descendant classes?

======>>>======

{$mode objfpc}
type
  tfooclass = class of tfoo;
  tfoo = class
  public
    class function m1: string; virtual;
  end;
  tbar = class(tfoo)
  public
    class function m1: string; override;
  end;
class function tfoo.m1: string;
begin
  Result := 'tfoo';
end;
class function tbar.m1: string;
begin
  Result := 'tbar';
end;
var
  vclass: tfooclass;
begin
  vclass := tfoo;
  writeln('1: ', vclass.m1);
  vclass := tbar;
  writeln('2: ', vclass.m1);
end.

======<<<======

Joao Morais