Frage zu Anonymen Prozeduren (TProc) und verwendung als Bauskasten

[fisipjm]

Hi,

ich würde in einem Projekt gerne eine elegante Lösung finden, für ein Problem, dass denke ich viele so in irgendeiner Spielart schon hatten.
Also, ich habe aktuell einen Dienst, der sich in einer Datenbank gewissen Jobs anschaut und diese dann nach einer zeitlichen Vorgabe ausführt. Diese Tasks sind relativ klein strukturiert, jetzt ist es manchmal so, dass es einen Task gibt, der einzeln ausgeführt werden kann, aber zwingend erforderlich für einen anderen Task ist. Manchmal muss ein Task vor einem "Haupttask" laufen und manchmal danach.

Ich würde das gerne irgendwie relativ dynamisch aufrufen können, ohne dafür den Code hart in die jeweilige Hauptfunktion stecken zu müssen. Ich hatte mir vorgestellt, dass ich das eventuell mit einer dynamischen Prozedur lösen kann, indem ich den Haupttask z.B. um TaskBefore, TaskAfter = Tproc erweitere.

Ich könnte mir allerdings vorstellen, dass es da Probleme mit diversen Uses gibt, weil der Haupttask ja erst mal nicht weis, welche Sachen in der Anonymen Prozedur genutzt werden. Ist das der richtige Weg? Wie lösen das die langjährigen Profis

[peterbelow]

Der "Haupttask" muß nur die Signatur der anonymen Methoden kennen, die "Nebentasks" können dann entsprechende Methoden beim Haupttask registrieren. In diesem Scenario kennen die Nebentasks den Haupttask, d.h nutzen dessen Unit in der Uses-Klause, aber nicht umgekehrt. Das läßt sich noch weiter entkoppeln, wenn Du einen "task manager" als separate Klasse in einer eigenen unit verwendest (z. B. als Singleton), mit der sich auch der Haupttask registriert. Besonders wenn es davon nur einen geben kann brauchen die Nebentasks dann den Haupttask nicht zu kennen, alle task units würden nur die unit des Managers in ihrer Uses-Klausel verwenden. Diese würde dann auch eine Basisklasse (oder ein Interface) für die Tasks deklarieren.

[Rollo62]

Die Anforderung ist für mich etwas unklar formuliert, ich weiss jetzt nicht ob das dynamisch je nach Datenbank-Feldinhalt sein soll,
oder nicht.

Falls es nur um einen dynamischen Aufruf geht, welchen Du je nach Anforderung im Aufruf anpassen möchtest,
dann könntest Du auch sowas wie einen "Builder" einsetzen um die SubTasks jeweils in anonymen Prozeduren zu halten.

Delphi-Quellcode:

...

LMyTask := MyTask_Builder
.Conf_MainTask(
    procedure
    begin
       A();
    end )
.Conf_SubTaskBefore(
    procedure
    begin
       B();
    end )
.Conf_SubTaskAfter(
    procedure
    begin
       C();
    end );

LMyTask.Execute;

...

[fisipjm]

Zitat von Rollo62:

Die Anforderung ist für mich etwas unklar formuliert,...
[/DELPHI]

Hast absolut recht. Ich versuchs nochmal. Die Proceduren existieren schon.

Beispiel:

Delphi-Quellcode:

procedure a;
begin
...
end;

procedure b;
begin
...
end;

procedure c;
begin
...
end;

procedure d;
begin
...
end;

procedure e;
begin
...
end;

Alle Prozeduren erledigen eigenständig ihre Aufgabe und sind auch in sich geschlossen. Es kann allerdings sein, dass z.B. Prozedur a zwingend, vor Prozedur b laufen muss. Oder wenn man es nochmal anders ausdrücken möchte, dass Prozedur b zwingend nach Prozedur a laufen muss. Das hat keinerlei technische Gründe. Das Programm würde auch ohne auf einen Fehler zu laufen einfach nur Prozedur A oder nur Prozedur B ausführen. Das würde einfach nur zu logischen Fehlern in den Daten führen. Da sich diese Anforderungen während der Benutzung der Anwendung ändern können, möchte ich das gerne dynamisch zusammen setzen können. Müsste ja mit RTTI gehen, dass ich aus den Strings in der Datenbank die Prozeduren raus fische und die dann entsprechend dran hänge. Mein Frage wäre jetzt nur, ob ich die vorhandenen Prozeduren "stöpselfähig" machen kann. In meiner Vorstellung sowas:

Delphi-Quellcode:

procedure a (Runbefore: array of Tproc; Runafter: array of Tproc);
begin
for Tproc in Runbefore do
Tproc.run;
...
for Tproc in Runafter do
Tproc.run;
end;

Ich hoffe, ich konnte mich ein bissel klarer ausdrücken

[MyRealName]

Für mich macht es dann aber meinen Sinn, das im Code zu machen, weil wenn isch etwas ändert, musst Du den Code ändern und eventuell neu ausliefern. Da ist es vllt. besser, man steuert es über die DB. Vllt mit einem Feld Pre-Task mit der Id des Tasks, der vorher laufen soll. Sind es 2 Tasks vorher, dann hat einer einfach auch einen Pre-Task...
Und auf diese weise, wenn Du man was ändern willst, dann einfach in der DB den Aufruf ändern

[fisipjm]

Zitat von MyRealName:

Für mich macht es dann aber meinen Sinn, das im Code zu machen, weil wenn isch etwas ändert, musst Du den Code ändern und eventuell neu ausliefern. Da ist es vllt. besser, man steuert es über die DB. Vllt mit einem Feld Pre-Task mit der Id des Tasks, der vorher laufen soll. Sind es 2 Tasks vorher, dann hat einer einfach auch einen Pre-Task...
Und auf diese weise, wenn Du man was ändern willst, dann einfach in der DB den Aufruf ändern

Ich meinte, das wäre das, was ich in meinem Post zuvor beschrieben hätte?

Ich würde das halt auch gern im Code abbilden, nicht nur in der Datenbank. Sehe jetzt nicht, warum ich bei dem Anonymen Prozeduren Aufruf den Code neu Compilieren müsste? Wenn man das ganze nämlich noch auf die Spitze treibt, und zum Beispiel die einzelnen Funktionen als BPL ausliefert, dann hat man ein schönes Plugin-System, dem ich neue Funktionen hinzufügen und alte wegnehmen kann, ohne dass ich jedes Mal die Hauptanwendung neu ausliefern muss. Das wäre so zu sagen der LongTime Plan dazu

[Uwe Raabe]

Zitat von fisipjm:

Da sich diese Anforderungen während der Benutzung der Anwendung ändern können, möchte ich das gerne dynamisch zusammen setzen können. Müsste ja mit RTTI gehen, dass ich aus den Strings in der Datenbank die Prozeduren raus fische und die dann entsprechend dran hänge.

Könntest du hierfür noch ein konkretes Beispiel geben?
Also, was steht in der Datenbank und was soll damit passieren?

[fisipjm]

Zitat von Uwe Raabe:

Zitat von fisipjm:

Da sich diese Anforderungen während der Benutzung der Anwendung ändern können, möchte ich das gerne dynamisch zusammen setzen können. Müsste ja mit RTTI gehen, dass ich aus den Strings in der Datenbank die Prozeduren rausfische und die dann entsprechend dran hänge.

Könntest du hierfür noch ein konkretes Beispiel geben?
Also, was steht in der Datenbank und was soll damit passieren?

Moin,

Noch steht in der Datenbank
1. Zeile - Task 1
2. Zeile - Task 2
3. Zeile - Task 3
usw.*...

Ich hätte es zukünftig gerne so:
Tabelle 1 (Sichtbar für Otto normal Bediener)
1. Zeile - Bundle 1

Andere Tabelle (Zugriff von Benutzern mit Ahnung vom Ablauf)
BundleName = Bubndle 1
PreTask = Task 1;Task x ...
MainTask = Task 2
PostTask = Task 3;Task x ...

Andere Tabelle (irgendwann mal halbautomatisch gefüllt) zur Verfügung stehende Tasks
1. Zeile - Task 1
2. Zeile - Task 2
3. Zeile - Task 3


Diese Struktur hatte ich gedacht mit den Anonymen Prozeduren abbilden zu können. Also im Prinzip das Bundle

[Uwe Raabe]

Und "Task x" steht dann für eine der Prozeduren a, b, c,...?

[fisipjm]

Zitat von Uwe Raabe:

Und "Task x" steht dann für eine der Prozeduren a, b, c,...?

Genau, alle Prozeduren, die angehängt werden sollen, existieren bereits im Code. Sollten aber in beliebiger Anzahl dran gehängt werden können.
Also Pro bzw. Post Prozedur kann auch leer sein oder eben 10 Prozeduren enthalten, deshalb im Code das

Code:

Array of TProc

Ich habe absolut keinen Peil, ob das funktionieren kann