Frage zu Anonymen Prozeduren (TProc) und verwendung als Bauskasten

[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

[himitsu]

Wenn der TaskManager dafür nichts bietet, dann machen es die Task eben selber


TaskA kann auch TaskB/SeineProc mitgegeben werden, welchen Diesen an seinem Ende startet/übergibt.

oder es gibt global Events, wo TaskA am Ende mit SetEvent reagiert und TaskB hat das WaitFor (für den Fall, dass er zu früh kommt).
bzw. es muß nicht global sein, aber Beide müssen ihr Event kennen und B gibt es dann am Ende frei.

oder ...