CODEWITHSUNDEEP
delphipropertiescomponents
Dan
Dan

Reputation: 749

Delphi Custom Component Knowing Which Referee Called A Method

I have created a custom component which has a property that the user can assign to another custom component..

TComp1 = class(TComponent)
public
  property Comp2: TComp2 read GetComp2 write SetComp2;
  property Something;
end;

TComp2 = class(TComponent)
public
  procedure DoSomething;
end;

There could be multiple TComp1 components that assign the same TComp2. I need TComp2 to know which TComp1 called it because it needs to reference property "something" of that specific referee..

var
  comp1a, comp1b: TComp1;
  comp2: TComp2;

comp2 := TComp2.create;
comp1a := TComp1.create;
comp1b := TComp1.create;

comp1a.comp2 := comp2;
comp1b.comp2 := comp2;

comp1b.comp2.dosomething; <-- needs to know this was from comp1b not comp1a

obviously, the code above is just to illustrate my point and is not including the notification mechanisms that I have to put in place, etc.

so far, I have considered using the getter for TComp1.Comp2 to set an "activeComponent" property on the assigned TComp2 so that TComp2 can use that property to get the right component. While this should work, I believe it is unsafe and if someone tries to use comp2 directly or passes the reference to another variable entirely (comp := comp1a.comp2; comp.dosomething;), or tries to use it from multiple threads, there could be issues.

has anybody else encountered this issue? what is the best solution?

I hope somebody will be able to help :)

Upvotes: 0

Views: 101

Answers (2)

Disillusioned
Disillusioned

Reputation: 14832

In the line:

comp1b.comp2.dosomething; <-- needs to know this was from comp1b not comp1a

The call to doSomething has absolutely no knowledge of comp1b. You should think of this as two separate lines of code:

LocalComp2 := comp1b.comp2;
LocalComp2.doSomething;

So as per David's comment, you need to pass the other component as a parameter. I.e.

comp1b.comp2.doSomething(comp1b);

This, by the way, is a stock-standard technique used throughout Delphi code. The best example is TNotifyEvent = procedure (Sender: TObject) of object; and is used in calls like:

ButtonClick(Self);
MenuItemClick(MainMenu);

You ask in a comment:

I have thought about that too but it seems somewhat redundant to effectively reference the same component twice.. comp1a.comp2.domsomething(comp1a); is there no better way?

As I said, the bit comp2.domsomething has no knowledge of the comp1a. just before it. So as far as the compiler is concerned it's not redundant. In fact it's also possible to call comp1a.comp2.domsomething(SomeOtherComponent).

However, that said, there is a better way.

Currently your code violates a princple called the Law of Demeter. Users of TComp1 are exposed to details abobut TComp2 even if they don't care about TComp2. This means that you can find yourself repeatedly writing:

comp1a.comp2.doSomething(comp1a);
comp1b.comp2.doSomething(comp1b);
comp1a.comp2.doSomething(comp1a);
comp1c.comp2.doSomething(comp1c);

To avoid that, fix the Law of Demeter violation by writing:

procedure TComp1.doSomething;
begin
  comp2.doSomething(Self);
end;

Now your earlier lines become:

comp1a.doSomething;
comp1b.doSomething;
comp1a.doSomething;
comp1c.doSomething;

Upvotes: 2

David Heffernan
David Heffernan

Reputation: 612894

The obvious solution is to pass the extra information as a parameter. Like this:

comp1b.comp2.dosomething(comp1b);

Expecting comp2 to be able to work out whether it was referenced from comp1a or comp1b is unrealistic, and frankly would be an indication of a poor design.

Parameters are explicit and so demonstrate clear intent to the reader.

Upvotes: 1

Related Questions