Actions einzeln oder mit Shared-Eventhandlern?

[Assertor]

Hallo Mitstreiter!

Ein Freitagabend-Thread mit dem Thema übersichtlicher, lesbarer VCL code. Die Frage: Actions gruppieren (shared eventhandler) oder mit einzelnen Events?

Damit meine Ich:

Delphi-Quellcode:

procedure TfrmMain.acExecute(Sender: TObject);
begin
  inherited;

  //----------------------------------------------------------------------------
  // buttons
  //----------------------------------------------------------------------------

  // exit
  if (Sender = acExit) then
  begin
    Close;
    Exit;
  end;

  // foo
  if (Sender = acFoo) then
  begin
    DoFoo;
    Exit;
  end;
end;

oder

Delphi-Quellcode:

procedure TfrmMain.acCloseExecute(Sender: TObject);
begin
  DoSomething;
end;

procedure TfrmMain.acFooExecute(Sender: TObject);
begin
  DoSomething;
end;

Bisher verwende ich die erste Variante, wobei das UI-Interface von der Anwendungslogik getrennt ist. Dies wird gelegentlich bei vielen Actions etwas lang, aber dank der Trennung bleibt es doch recht übersichtlich.

Was meint Ihr dazu, was ist sauberer und üblicher?

Gruß Assertor

[marabu]

Hallo,

ist dir noch nicht aufgefallen, dass bei deiner bislang bevorzugten Methode 1 viele Vorteile einer TAction auf der Strecke bleiben? Die gemeinsame Caption für auslösende UI-Controls (Button, MenuItem) ist so nicht realisierbar. Die zeitlich abweichende Aktivierung und Deaktivierung unterschiedlicher Actions ist nicht möglich. Du scheinst so Spezialfälle zu lösen, die ich mir gerade nicht so gut vorstellen kann.

Grüße vom marabu

[Assertor]

Hi Marabu,

schön mal wieder von Dir zu lesen :hi:

Zitat:

Zitat von marabu

Die gemeinsame Caption für auslösende UI-Controls (Button, MenuItem) ist so nicht realisierbar. Die zeitlich abweichende Aktivierung und Deaktivierung unterschiedlicher Actions ist nicht möglich.

Trifft beides nicht zu. Die Actions für Form-Elemente sind ja einzeln deklariert (z.B. acButton1, acButton2). Somit sind alle Vorteile verfügbar.

Es geht lediglich um die Zuweisung der Methoden für acExecute/acUpdate. Diese werden gruppiert um eine übersichtlichere Darstellung zu erzielen.

Ich denke nämlich gerade umgekehrt wird ein Schuh daraus: Wenn man Actions anwendet, aber für jede Action einzeln ein acExecuteXYZ, acUpdateXYZ zuweist, wird der Code wieder unübersichtlich wie beim guten alten VCL OnEventXYZ.

Stimmen Sie mir da nicht zu, Herr Kollege? :zwinker:

Gruß Assertor

[marabu]

Ich fürchte ich habe deinen Thread-Titel falsch interpretiert. Wenn die Action-Komponenten diskret bleiben, dann ist alles okay.

Wenn du dich auf mehr Übersichtlichkeit durch shared event handler bei der VCL berufst, dann gilt das natürlich auch für TActions. Generalisieren mag ich diesen Ansatz aber nicht und ich muss auch feststellen, dass ich in meiner beruflichen Praxis noch keine Notwendigkeit für dieses Vorgehen bei TActions gesehen habe. Das mag deswegen sein, dass bei Edit- und anderen UI-Controls tatsächlich oft gleiche Code-Strecken auftauchen, so dass ein shared event handler die Wartbarkeit erhöht. Das Zusammenlegen mehrerer event handler ohne diese Motivation überzeugt mich nicht - zumindest nicht sofort.

Freundliche Grüße

[Assertor]

Hi,

Zitat:

Zitat von marabu

Ich fürchte ich habe deinen Thread-Titel falsch interpretiert. Wenn die Action-Komponenten diskret bleiben, dann ist alles okay.

Ja, das meinte ich - wie gesagt ein Freitagabend-Thread ;)

Zitat:

Zitat von marabu

Wenn du dich auf mehr Übersichtlichkeit durch shared event handler bei der VCL berufst, dann gilt das natürlich auch für TActions.

Sehe ich genauso.

Zitat:

Zitat von marabu

Generalisieren mag ich diesen Ansatz aber nicht und ich muss auch feststellen, dass ich in meiner beruflichen Praxis noch keine Notwendigkeit für dieses Vorgehen bei TActions gesehen habe. [...] Das Zusammenlegen mehrerer event handler ohne diese Motivation überzeugt mich nicht - zumindest nicht sofort.

Notwendigkeit besteht keine, das stimmt. Ich wollte nur wissen, ob ich mich im Rahmen von lesbarem, wartbarem Code bewege.

Ich habe mir in den letzten Projekten angewöhnt, die UI-Interaktionen über die Actions laufen zu lassen. Update und Executes sind bei mir immer Shared-Eventhandler, also gruppiert.

Es ist sicherlich ungewöhnlich, aber nicht verkehrt. Ich glaube mal einen ähnlichen Ansatz bei Troy Wolbrink (TntUnicode) oder Robert Lee (SpTBX) gesehen zu haben und bin von der Struktur begeistert. Es ähnelt in diesem Modellansatz ja einer kleinen Messagequeue ;)

Gruß Assertor