TThread, irgendwas mache ich falsch

[KodeZwerg]

Danke NG, jetzt hab ich verstanden was Du mit der Zeit meintest und Erfolgreich umgesetzt.
Falls es jemand Interessiert, hier die Lösung für mein Problem

Delphi-Quellcode:

function TFormMain.GetTHTTPClient ( Const xURL : String ) : String;
var
 tmp : String;
 MyThread: TThread;
begin
  tmp := '';
  MyThread := TThread.CreateAnonymousThread(
    procedure
    var
     HttpClient: THttpClient;
     HttpResponse: IHttpResponse;
    begin
      tmp := '';
      HttpClient := THTTPClient.Create;
      try
        HttpResponse := HttpClient.Get( xURL );
        tmp := HttpResponse.ContentAsString();
      finally
        HttpClient.Free;
      end;
    end
  );
  MyThread.FreeOnTerminate := True;
  MyThread.Start;
  repeat
    Application.ProcessMessages;
    Sleep(5);
  until WaitForSingleObject(MyThread.Handle, 5) = WAIT_FAILED;
  Result := tmp;
end;

Das Programm kann man weiterhin bedienen, nichts friert ein.
Danke für alle Hinweise und Tipps!

[himitsu]

Delphi-Quellcode:

Sleep(5);
  until WaitForSingleObject(MyThread.Handle, 5)

Ein paar Dinge verstehen könntest du dennoch lernen :zwinker:

Sleep(5)_ohneEventbehandlung + WaitFor(5)_mitEventbehandlung = WaitFor(10)_undAllesMitEventbehandlung

Oder noch besser das WaitFor nicht nur auf dein Event, sondern auch auf die Warteschlange des VCL-Threads warten lassen.
> Delay etwas anpassen

[Whookie]

Man kann das natürlich so lösen, aber meist führt das zu weiteren Problemen (z.B. kann der Anwender das Programm nicht mehr beenden während es in einer solchen Schleife "festhängt").

Schleifen in denen Sleep und ProcessMessages verwendet werden sollte man aus meiner Sicht meiden, wenn ein Vorgang in Summe länger dauert dann gehört der ganze Vorgang in den Thread nicht nur Teile davon.

Klar bedeutet das in der Regel einen gewissen Umbauaufwand aber in den meisten Fällen hat man einfach nur "zu kurz" gedacht.

[himitsu]

Application.Terminated in die Abbruchbedingung sollte halt mit rein, dann läßt es sich beenden, genau so, wie man es auch bei Threads mit Self.Terminated macht.

[KodeZwerg]

Delphi-Quellcode:

  MyThread.FreeOnTerminate := True;
  MyThread.Start;
  repeat
    Application.ProcessMessages;
    Sleep(5);
    if CancelThread then
    begin
      ButtonDownload.Enabled := True;
      ButtonSaveOriginal.Enabled := False;
      ButtonCancelDownload.Enabled := False;
      CancelThread := False;
      tmp := 'Download aborted.';
      MyThread.Terminate;
    end;
  until WaitForSingleObject(MyThread.Handle, 5) = STATUS_PENDING;

So sieht es aktuell aus, Abbruch-Bedingung ist ein Globales Boolean, gesteuert über Knopf.
Momentan klappt allerdings irgendwie gar nichts so richtig.
Das mit den Sleep(5) ist irgendwie ein Automatismus bei mir, sobald ich ProcessMessages aufrufe.

[Neutral General]

Musst du denn wirklich auf den Thread warten?
Reicht ein Callback aus dem Thread oder ein OnTerminated nicht in dem du deine Buttons etc wieder enablest/disablest?

Selbst wenn es so wie du es grade machst irgendwann funktionieren sollte wie du willst ist es trotzdem nichts von dem man behaupten kann, dass dort Threads sinnvoll eingesetzt werden. Oder anders gesagt: Wenn man auf einen Thread warten muss, dann stellt sich zumindest die Frage ob ein Thread in dem Fall eine gute Idee ist.
(Meistens nicht, manchmal vllt doch).

[KodeZwerg]

@NG: Um ehrlich zu sein, ich weiß nicht ob ein Thread das Richtige Mittel ist.
Es nur eine Idee die ich mal ausprobieren wollte um an dieses Ziel zu gelangen:
Behebe bei App "keine Rückmeldung" und biete Option an den Download abzubrechen.
Mal klappt es mal nicht, ich spiele zu viel mit der until Bedingung rum.
Wenn ich wieder die kombination drinnen habe die funktioniert, also das ich entweder was downloade und wenn thread beendet ist es mir auch angezeigt wird, dann klappt es mit der "Download aborted." Nachricht nicht. Thread ist dann zwar abgebrochen aber ohne Nachricht ist es auch doof. Naja ich bastel da noch ein wenig herum.
Ohne Extra-Thread fehlt mir die Möglichkeit den Download abzubrechen und App friert ein solange Download am machen ist.

[Edelfix]

Sollte eigentlich so funktionieren.

Delphi-Quellcode:

function TMainForm.GetTHTTPClient ( Const xURL : String ) : String;
var
 tmp : String;
 MyThread: TThread;
 TimeOut: Cardinal;
begin
  tmp := '';
  MyThread := TThread.CreateAnonymousThread(
    procedure
    var
     HttpClient: THttpClient;
     HttpResponse: IHttpResponse;
    begin
      tmp := '';
      HttpClient := THTTPClient.Create;
      try
        HttpResponse := HttpClient.Get( xURL );
        tmp := HttpResponse.ContentAsString();
      finally
        HttpClient.Free;
      end;
    end
  );
  MyThread.FreeOnTerminate := True;
  TimeOut := GetTickCount;
  MyThread.Start;
  repeat
    Application.ProcessMessages;
    Sleep(5);
  until (tmp<>'') or ((GetTickCount-TimeOut)>5000); //neu
  Result := tmp;
end;

[KodeZwerg]

Delphi-Quellcode:

  until ((tmp <> '') or (WaitForSingleObject(MyThread.Handle, 5) = WAIT_FAILED));

Das ist die Lösung, auf den String zu achten, super Idee Edelfix. Danke! Nun klappt es exakt so wie ich es wollte, ich kann abbrechen, ich bekomme 'Download aborted.' und Thread schließt sich bzw bei Nicht-Abbruch bekomme ich auch das Ergebnis :thumb::thumb:

edit
Falls jemand mal brauchen sollte, so sieht eine Funktion aus die einen Thread startet und wartet bis der fertig ist um aus dem Thread einen String als Funktion = Result zu überreichen. Eine Abbruch-Funktion ist per Boolean CancelThread integriert.

Delphi-Quellcode:

function TFormMain.GetTHTTPClient ( Const xURL : String ) : String;
var
 tmp : String;
 MyThread: TThread;
begin
  tmp := '';
  CancelThread := False;
  MyThread := TThread.CreateAnonymousThread(
    procedure
    var
     HttpClient: THttpClient;
     HttpResponse: IHttpResponse;
    begin
      HttpClient := THTTPClient.Create;
      try
        HttpResponse := HttpClient.Get( xURL );
        tmp := HttpResponse.ContentAsString();
      finally
        HttpClient.Free;
      end;
    end
  );
  MyThread.FreeOnTerminate := True;
  MyThread.Start;
  repeat
    Application.ProcessMessages;
    Sleep(5);
    if CancelThread then
    begin
      ButtonDownload.Enabled := True;
      ButtonSaveOriginal.Enabled := False;
      ButtonCancelDownload.Enabled := False;
      CancelThread := False;
      tmp := 'Download aborted.';
      MyThread.Terminate;
    end;
  until ((tmp <> '') or (WaitForSingleObject(MyThread.Handle, 5) = WAIT_FAILED));
  Result := tmp;
end;

Durch die Art der Abfrage in der Repeat-Schleife sollte meines Wissens alles glatt laufen, entweder es existiert ein String oder Thread hat sich geschlossen.
Was haltet Ihr davon?

[Stevie]

Bitte niemals auf das Handle eines Threads mit

Delphi-Quellcode:

FreeOnTerminate := True

warten!
An der Stelle, wo das Warten passiert, kann der Thread schon durchgelaufen und weg sein.