Benutzte Proceduren auf "Stack" schreiben. In "Stack" befindliche Proceduren per Mausklick beenden?????

[Betz Michael]

Hallo,

gibt es eine Möglichkeit benutzte Proceduren/Functionen auf einen "Stack" zu schreiben und bei einem Abbruch die auf dem "Stack" befindlichen Proceduren/Funktionen per Mausklick zu beenden???

Danke Michael

[Robert Marquardt]

Häh? Meinst Du exceptions

[Hagen Reddmann]

Hi

<pre>
type
TStackProc = procedure;<br>

var
Stack: TStringList = nil;
StackAbort: Boolean = False;<br>

procedure StackAdd(Proc: TStackProc; const ProcName: String);
begin
if Stack = nil then Stack := TStringList.Create;
Stack.AddObject(ProcName, @Proc);
end;<br>

procedure StackExecute;
begin
StackAbort := False;
if Stack <> nil then
try
while Stack.Count > 0 do
begin
WriteLn('execute: ', Stack[0]); // info
TStackProc(Stack.Objects[0]); // führe die registrierte procedure aus
Stack.Delete(0);
Application.ProcessMessages; // ermögliche das ein Button geklickt werden kann
// der dann StackAbort auf TRUE setzen kann
if StackAbort then Break;
end;
finally
if Stack.Count = 0 then // zerstöre Stack falls er leer ist
begin
Stack.Free;
Stack := nil;
end;
end;
end;<br>

procedure StackFree;
begin
if Stack <> nil then
begin
Stack.Free;
Stack := nil;
end;
end;<br>

// zum test<br>

procedure DoTest;

procedure Proc_A;
begin
WriteLn('Proc_A');
end;<br>

procedure Proc_B;
begin
WriteLn('Proc_B');
end;<br>

procedure Proc_C;
begin
WriteLn('Proc_C');
end;<br>

procedure Proc_With_Param(Param: Integer);
begin
WriteLn('Proc_With_Param: ', Param);
end;<br>

procedure Proc_D;
begin
Proc_With_Param(1);
end;<br>

procedure Proc_E;
begin
Proc_With_Param(2);
end;<br>

begin
try
StackAdd(@Proc_A, 'Proc_A');
StackAdd(@Proc_B, 'Proc_B');
StackAdd(@Proc_C, 'Proc_C');
StackAdd(@Proc_D, 'Proc_D');
StackAdd(@Proc_E, 'Proc_E');<br>

StackExecute;<br>

finally
StackFree;
end;
end;<br>

</pre>

Gruß Hagen
&#10

[Betz Michael]

Hallo Hagen,

es ist fast das was ich brauche.
Mein Problem ist aber nicht die am Stack befindlichemn Proceduren auszuführen, sondern die auf dem Stack befindlichen Proceduren per Mausklick mit EXIT zu verlassen.
z.B

while Stack.Count > 0 do
begin
TStackProc(Stack.Objects[0]).Exit; // procedure Stack.Delete(0);
Application.ProcessMessages; // ermögliche das ein auf TRUE if StackAbort then Break;
end;

Ist soetwas möglich????

Danke im Voraus
Michae

[Hagen Reddmann]

Hi

Ja, schau in StackExecute; dort wird Application.ProcessMessages aufgerufen, damit eben in einem Formular ein Button klickbar wird der dann in OnClick die Variable StackAbort auf TRUE setzt. Damit ist zumindest die Stack Verwaltung abortable, nach jeder einzelnen Function. Wenn Du nun noch die einzelnen Funktionen unterbrechen willst müssen auch diese periodisch StackAbort abfragen und Application.ProcessMessages aufrufen.

Was willste konkret machen ? Sieht mir wie eine Scripting engine aus.

Gruß Hage

[Betz Michael]

Hallo Hagen,

mein Problem besteht darin, daß ich in meiner Anwendung im Fehlerfall eine Globale Variable (Abbruch) auf True setze. Um nun möglichst schnell alle Proceduren (auch in DLL ) zu verlassen, müsste ich nach jeden Befehl in einer Procedure eine Abfrage der Variable ABRUCH durchführen.
z.B
"Befehle"
if Abbruch then Exit
"Befehl"
if Abbruch then Exit
usw

Um dies zu vermeiden wäre es gut bei Abbruch=True nur in eine ExitProcedure zu springen und alle am Stack befindlichen Proceduren mit Exit sofort zu verlassen.

Danke
Michae

[Hagen Reddmann]

Hm, im Stack wird sequentiell eine Procedure nach der anderen abgearbeitet. D.h. es gibt immer nur eine Procedure die beendet wird, der Stack unterbricht und alle noch auszuführenden Proceduren werden dann eh ignoriert.

Erklär genau für was Du das brauchst. In jedem falle muss jede procedure die im Stack verwaltet wird auch die Variable StackAbort periodisch abfragen und Application.ProcessMessages aufrufen.

Es gäbe noch die Alternative mit Threads zu arbeiten, falls die einzelnen Proceduren auch threadsafe sind. Das Problem des Abbruchs wäre ähnlich der Aufruf von Application.ProcessMessage aber NICHT erforderlich. D.h. Deine Hauptanwendung läuft weiter wie gewohnt und im Hintergrund würden die Proceduren des Stacks im Thread ausgeführt. Die Hauptanwendung kann dann einfach StackAbort := True setzen falls erforderlich. Die einzelnen Proceduren müssen dann aber immer noch StackAbort abfragen, könnten aber mit

<pre>

if StackAbort then Abort;

</pre>

ein Exception auslösen die in StackExecute; abgefangen wird.

Gruß Hage