How can I dynamically inject code into event handlers in Delphi?

Question

For debugging / performance tests I would like to dynamically add logging code to all event handlers of components of a given type at run time.

For example, for all Datasets in a Datamodule, I need to run code in the BeforeOpen and AfterOpen events to capture the start time, and to log the elapsed time in AfterOpen.

I would prefer to do this dynamically (no component subclassing), so that I can add this to all existing datamodules and forms with minimal effort only when needed.

Iterating all components and filtering by their type is easy, but for the components which already have event handlers assigned, I need a way to store the existing event handlers, and assign a new modified event handler which first does the logging and then will invoke the original code which was already present.

So this code

procedure TMyDatamodule.OnBeforeOpen(Sender: TDataset);
begin
  SomeProc;
end;

at run time would become

procedure TMyDatamodule.OnBeforeOpen(Sender: TDataset);
begin
  StoreStartTime(Sender); // injected code

  SomeProc;
end;

Is there a design pattern which can be applied, or even some example code which shows how to implement this in Delphi?

You don't mention what DBMS you're using. But as an entirely different approach, have you considered using a DB Profiler? E.g. Using SQL Server profiler, you have a lot of flexibility and would be able to see internal details not covered by BeforeOpen/AfterOpen. — Disillusioned
– Disillusioned, Commented Dec 3, 2013 at 13:00

Uwe Raabe · Accepted Answer · 2010-03-14 15:44:56Z

9

You can use the following scheme to rewire the datasets:

type
  TDataSetEventWrapper = class
  private
    FDataSet: TDataSet;
    FOrgAfterOpen: TDataSetNotifyEvent;
    FOrgBeforeOpen: TDataSetNotifyEvent;
    procedure MyAfterOpen(DataSet: TDataSet);
    procedure MyBeforeOpen(DataSet: TDataSet);
  protected
    property DataSet: TDataSet read FDataSet;
  public
    constructor Create(ADataSet: TDataSet);
    destructor Destroy; override;
  end;

constructor TDataSetEventWrapper.Create(ADataSet: TDataSet);
begin
  Assert(ADataSet <> nil);
  inherited Create;
  FDataSet := ADataSet;
  FOrgAfterOpen := FDataSet.AfterOpen;
  FOrgBeforeOpen := FDataSet.BeforeOpen;
  FDataSet.AfterOpen := MyAfterOpen;
  FDataSet.BeforeOpen := MyBeforeOpen;
end;

destructor TDataSetEventWrapper.Destroy;
begin
  FDataSet.AfterOpen := FOrgAfterOpen;
  FDataSet.BeforeOpen := FOrgBeforeOpen;
  inherited;
end;

procedure TDataSetEventWrapper.MyBeforeOpen(DataSet: TDataSet);
begin
  if Assigned(FOrgBeforeOpen) then
    FOrgBeforeOpen(DataSet);
end;

procedure TDataSetEventWrapper.MyAfterOpen(DataSet: TDataSet);
begin
  if Assigned(FOrgAfterOpen) then
    FOrgAfterOpen(DataSet);
end;

Inside MyAfterOpen and MyBeforeOpen you can bring in your code before, after or around the call to the original event handler.

Collect the wrapper objects in a TObjectList with OwnsObjects := true and everything will revert to the original when you clear or free the objectlist.

Caution: For this code to work the events have to be wired already when you create the wrappers and manually reassigning those events is forbidden.

edited Mar 14, 2010 at 15:44

answered Mar 14, 2010 at 9:57

Uwe Raabe

48.6k3 gold badges94 silver badges142 bronze badges

Sign up to request clarification or add additional context in comments.

7 Comments

Uwe Raabe Over a year ago

I've just seen that LukLed had a similar idea.

LukLed Over a year ago

@Uwe Raabe: +1 for nice description. I use this solution all the time to synchronize Insert/Edit/Post in datasets with 1-1 relation. Calling Insert/Edit/Post in one triggers Insert/Edit/Post in second. Works pretty well.

Ritsaert Hornstra Over a year ago

Advantage: you don't need unit ticks with abiguous names. Disadvantage: more intrusive: you need to add code to your project to hook the events even when using a separate class.

mjn Over a year ago

@Ritsaert: the additional code would require only one line in the dpr, something like AddDataSetLoggers([DataModule1, DataModule2, ...]);

Uwe Raabe Over a year ago

@Jeroen: I know, but the OP stated: "for the components which already have event handlers assigned, I need a way to store the existing event handlers, and assign a new modified event handler which first does the logging and then will invoke the original code which was already present." My code does exactly that.

|

LukLed · Accepted Answer · 2010-03-14 09:56:31Z

3

I would try this:

TDataSetBeforeOpenStartTimeStorer = class(TObject)

constructor Create(MyDataModule : TMyDatamodule);
begin
    OldBeforeOpen := MyDatamodule.OnBeforeOpen;
    MyDatamodule.OnBeforeOpen = NewBeforeOpen;
end;

procedure NewBeforeOpen(Sender: TDataset);
begin
  StoreStartTime(Sender);
  if Assigned(OldBeforeOpen) then
    OldBeforeOpen(Sender);
end;

Attach one TDataSetBeforeOpenStartTimeStorer instance to every TDataSet and you'll have your functionality.

answered Mar 14, 2010 at 9:56

LukLed

31.9k17 gold badges87 silver badges108 bronze badges

Comments

Ritsaert Hornstra · Accepted Answer · 2010-03-14 09:49:26Z

2

If the function or procedure in the component you want to 'hook' is declard virtual or dynamic it can be done in the following manner:

Let's assume for arguments sake that you wantto see all AfterOpen's from TDataset. This event handler is called from the virtual method:

procedure TDataSet.DoAfterOpen;

Create a new unit UnitDatasetTester (typed it in manual)

unit UnitDatasetTester;

interface

uses
  DB;

type
  TDataset = class( DB.TDataset )
  protected
    procedure DoAfterOpen; override;
  end;

implementation

uses
  MySpecialLoggingUnit; 

procedure TDataset.DoAfterOpen;
begin
  inherited;
  SpecialLog.Add( 'Hello world' );
end;

If you do not use this unit all works without loggig. If you use this unit as the LASt unit in your uses list (at least AFTER the DB uses) you do have logging for all datasets in that unit.

answered Mar 14, 2010 at 9:49

Ritsaert Hornstra

5,1812 gold badges38 silver badges53 bronze badges

4 Comments

Ritsaert Hornstra Over a year ago

Another method is copying the db unit and add the copy in your project directory (make sure it is in your project). Now edit this db.pas file to add the logging you want. Create e second project without this unit used and a different project diretory but using all other unit from the first project the same.

mghie Over a year ago

Nice tip, but I would make logging conditional (on build mode, a compilation switch or a variable) and always build the project with this unit. Adding and removing units on demand (and putting them in the right space) is too error-prone.

Ritsaert Hornstra Over a year ago

@mghie: you can do that by making the uses wrappied within a conditional. But that is not part of the question. Could have mentioned it though.

Disillusioned Over a year ago

Nice trick, but unlikely to work as expected if applied to TDataSet. E.g. When you create TTable, this already inherits from DB.TDataSet (unless you change the DBTables unit). Any subclass of TDataSet may itself override those methods. So the localised override of TDataSet won't kick in. However, applying the same technique to each concrete subclass you wish to instantiate should work perfectly time.

Jeroen Wiert Pluimers · Accepted Answer · 2010-03-14 09:47:14Z

1

There is no generic way to do this without going really really low level.
Basically you'd write something along the lines of the Delphi debugger.

For TDataSet:

I'd create a fresh TDataSource and point it to the TDataSet instance. Then I would use create a Data Aware component, and use the TDataLink to capture the things you are interested in.

From scratch, this is a couple of days work. But you can get a head start with the sample code for my conference session "Smarter code with Databases and data aware controls".
See my Conferences, seminars and other public appearances page at wiert.wordpress.com for the link.

--jeroen

answered Mar 14, 2010 at 9:47

Jeroen Wiert Pluimers

24.6k10 gold badges82 silver badges165 bronze badges

Comments

André · Accepted Answer · 2010-03-15 08:50:53Z

1

If you want to do it in a general purpose (and "quick and easy") way, you could use detouring and RTTI (RTTI: search for published event properties; detouring: hook original function and reroute/detour it to your own function).

I use detouring in my open source Delphi profiler: http://code.google.com/p/asmprofiler/
(in my general profile function I use assembly to preserve the stack, cpu registers, etc so it can profile/hook any function).

But if you want a more "intelligent" way (like knowledge about beforeopen and afteropen) you have to do some additional work: you need to make a special handling class for TDataset descendants etc.

answered Mar 15, 2010 at 8:50

André

9,0521 gold badge27 silver badges24 bronze badges

2 Comments

Shaun Roselt Over a year ago

Can you show a code example of this please?

André Over a year ago

@ShaunRoselt there are some examples here github.com/andremussche/asmprofiler/tree/master/Source/…

Collectives™ on Stack Overflow

How can I dynamically inject code into event handlers in Delphi?

5 Answers 5

7 Comments

Comments

4 Comments

Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

7 Comments

Comments

4 Comments

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related