Abbrechen und auf Abbruch warten?

[GeorgPeifer]

Zitat:

Zitat von Ines

Hallo Georg,

benötigst Du wirklich diese Unmenge von application.processmessages?
Ich glaube beim 2. Button sind die überflüssig.

Ines

Im Abbruchbutton ist der application.processmessages Befehl auch unnötig und stört sogar. Kann zur Endlos-Schleife werden.

In der Hauptschleife, die unterbrochen werden soll muss er allerdings sein, da sonst die keine anderen Buttons gehandelt werden.


@Matthias
Nochmal zu while TRUE...

While Apfel würde Sinn machen.. While True hingegen ist doch eine Endlos-Schleife, weil True halt immer True ist - oder? ;-)

Was hälst denn Du von While not Abbruch ... ? Nur so als Tip

[Mattze]

Hallo Gearg,

ganz so einfach ist das leider nicht.
Wenn ich das application.processmessages aus der 2. Schleife rausnehme, wird Label1.caption nicht mehr aktualisiert! (Das geht übrigens IMMER so, nicht nur bei diesem Programm. Man muss das oft explizit angeben, damit Label.caption aktualisiert wird. Wahrscheinlich geht das tatsächlich über eine Windows-Botschaft!) Zur Endlosschleife wird die 2. Schleife übrigens nie. Wie soll das auch gehen?
(Das hieße nämlich, dass man in der ersten Schleife ordentlich, so wie eigentlich erwartet, eine MSG definieren kann, die dann in der 2. ausgewertet wird. Aber genau das wäre doch die Lösung des Problems und das geht eben nicht. Warum?)

Zum Apfel: Das ist ja gerade der Witz! Die erste Schleife soll eine Endlosschleife sein, die nur extern unterbrochen wird.
(Im echten ist sie das natürlich nicht, aber zur Fehlerillustration reicht das hier!)

Gruß
Matthias

[Mavarik]

Zitat:

Zitat von Mattze

Zum Apfel: Das ist ja gerade der Witz! Die erste Schleife soll eine Endlosschleife sein, die nur extern unterbrochen wird.
(Im echten ist sie das natürlich nicht, aber zur Fehlerillustration reicht das hier!)

Gruß
Matthias

Also nochmal Dein Grundkonzept ist falsch und es handelt sich hier auch nicht um ein Delphi Bug...

Frank

[Mattze]

Hallo Frank,

ich glaube auch nicht recht daran, dass es ein Delphi-Bug ist.
Das Grundkonzept dürfte aber auf jeden Fall richtig sein.

Oder Du beweist es mir, in dem Du mir ein funktionierendes Beispiel für einen externen Abbruch und das Warten auf den erfolgten Abbruch zeigst!
Solange Du (oder jemand anderes) das nicht können - sprich: mir ein richtiges funktionierendes Grundkonzept vorgeben können - , finde ich es ziemlich gewagt, von einem falschen Grundkonzept zu sprechen.
In diesem Sinne haben ALLE hinreichend komplexen existierenden Programme - Windows eingeschlossen - ein
falsches Grundkonzept.
Es wurde schon vor langer Zeit mathematisch bewiesen, dass es kein hinreichend komplexes Softwaresystem geben kann (!), das völlig fehlerlos ist! Und Fehler? Falsches Grundkonzept! Oder nicht?

Gruß
Matthias

[thkerkmann]

Hallo Mattze,

das ist ganz sicher kein Delphi Bug.

Das Problem ist, dass die Prozedur die auf die Beendigung des Abbruchs wartet der Arbeitsprozedur keine Chance gibt zu Ende zu laufen. Das ist das Problem der Ereignis-Warteschleife.

Ich habe hier aber für dich eine Lösung, die nicht wesentlich aufwändiger ist - sie arbeitet mit einem Thread....

aber keine Panik. Ich habe einen Mini Thread, der sogar als universell zu benutzende Routine zur Verfügung steht (unit uThreadFrame) und die eigentliche Arbiet bleibt in deinem Mainform. Du darfst nur nicht auf VCL Elemente zugreifen - eventuell geht das sogar, ich habs nicht probiert.

Und so geht's

Delphi-Quellcode:

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Label1: TLabel;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
    Abbruch: boolean;
    abgebrochen: boolean;
    procedure DoTheWork;
    procedure WorkEnde(Sender:TObject);
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation
uses
  uThreadFrame; // <---- hier steckt der Trick

{$R *.DFM}

procedure TForm1.FormCreate(Sender: TObject);
begin
  Abbruch := false;
  abgebrochen := false;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  aThread: tFramingThread;
begin
  // Button 1 startet die Arbeit....

  // Worker Thread initialisieren
  aThread := tFramingThread.Create(true);
  aThread.ThreadBody := DoTheWork; // hier Prozedur zuweisen, die die Arbeit macht
  aThread.FreeOnTerminate := true; // wichtig
  aThread.OnTerminate := WorkEnde; // optional

  // und loslaufen lassen....
  aThread.Resume;

  label1.Caption := 'running';
end;

procedure TForm1.DoTheWork;
begin
  // hier wird gearbeitet.....

  Abbruch := false;
  while true do
  begin

    // Hier code für die Arbeit

    if Abbruch then
    begin
      abgebrochen := true;
      break;
    end;
  end;
end;

procedure TForm1.WorkEnde(Sender: TObject);
begin
  // wird am Ende der Arbeit aufgerufen, kann auch entfallen (siehe oben)
  if Abbruch then
  begin
    showmessage(inttostr(integer(abgebrochen)) + ' Abbruch');
  end;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  i: LongInt;
begin
  // der Abbruch Button ....

  abgebrochen := false;
  Abbruch := true;
  while not abgebrochen do
  begin
    sleep(1); // wichtig, damit der Thread zu Ende laufen kann.

    label1.caption := inttostr(i);
    inc(i);
    Application.ProcessMessages;
  end;
end;

end.

Viel Erfolg beim Ausprobieren.

Gruss

[Mavarik]

Also nochmal...

ein Application.processmessages ist erstmal eigentlich nix anderes als ein Call. Ein Call auf eine Routinen, die Messages abarbeitet.
Diese funktionalität wird dazu verwenden, dass andere Programm oder Programmteile weiterlaufen können, wenn eine "schleife" oder Programm nicht so schnell in die Systemschleife zurückkehren kann.

Also egal was Du machst, mit welchen tricks Du arbeitest und ob Du Messages erzeugst oder was auch immer... Die Procedure läuft erst mit der nächsten Codezeile weiter, wenn das Return aus diesem Call zurückkehrt.

Delphi-Quellcode:

  while true do
    begin
      ...

      application.processmessages  ->  Call 

      ...
    end;

Daher ist Dein Grundkonzept falsch... Kein Bug, Kein Fehler in Windows.. So funktioniert es einfach nicht...
Wenn Du mir Deine Routine gibst, baue ich Sie so um, dass das was Du möchtest funktioniert.


Frank :coder:

[Mattze]

Hallo thkerkmann,

vielen Dank! Genau das habe ich geahnt und es mir auch so vorgestellt. (Siehe meine Antwort vom 28.11.2006, 14:24, unten)
Aber ich mag es nicht, bei (vermeindlichen) kleinen Problemen gleich mit der ganz großen Keule zu kommen.
(Threads zu basteln sind für mich kein Problem, aber so ist es natürlich besser. Danke!)

Inzwischen habe ich auch etwas weitergespielt und genau das erreicht, was ich eigentlich wollte. Bis jetzt ohne Thread. Ich weiß noch nicht genau, wo eigentlich der inhaltliche Unterschied ist, nur das ich eben eigentlich keine 2. Schleife brauche, um auf den Abbruch zu warten.
Im Prinzip bin ich aber zu ähnlichen Schlüssen gekommen, warum das mit der 2. Schleife nicht funktionieren kann.
Button1click läuft ja so lange, wie die 1. Schleife noch arbeitet und da wirkt die 2. Schleife so, als wenn ich in Button1click auf die Beendigung von Button1click warte. Das geht natürlich in die Hose.
Wirklich sauber (und parallel) geht das eben nur per Thread. Da wird Button1click ordentlich beendet und der Thread rennt trotzdem weiter usw.
Eigentlich wollte ich ein paar Parameter ändern und die 1. Schleife wieder loslaufen lassen. Ich hätte nicht gedacht, dass das möglich ist, aber man kann in Button1click noch mal Button1click aufrufen.
Jedenfalls geht jetzt alles dufte.
Mal sehen, ob ich das ordentlich in die richtige Routine übersetzen kann...

@Frank:
Hallo Frank,

ehrlich gesagt, verstehe ich Dich da nicht. Warum glaubst Du mit "ein paar tausend Zeilen" der richtigen Routine besser zurecht zu kommen als mit der kurzen Version, die genau den Fehler der Routine erzeugt?
Ich danke Dir aber sehr für Dein Hilfsangebot. Wenn ich nicht zurecht komme, komme ich gerne auf Dein Hilfsangebot zurück, aber, wie gesagt, die Routine ist ziemlich groß und hat "recht unangenehme Sachen drin". Z. B. eine rekursive Funktion, die das ganze Dateisystem abgrast, usw.

Gruß
Matthias