Zitat von TiGü:

Musst du dir denn einen eigenen Thread bauen?
Kannst du nicht das TCustomRESTRequest.ExecuteAsync nutzen und für das Abbrechen das dafür vorgesehene Cancel?

markieren

Delphi-Quellcode:

procedure TForm3.FormClick(Sender: TObject);
var
    RESTThread: TRESTExecutionThread;
begin
    RESTThread := RESTRequest1.ExecuteAsync({Bitte hier die optionalen Argumente beachten wie CompletionHandler und CompletionHandlerWithError});

    // Bla blupp, dauert alles zu lange:
    if Assigned(RESTThread) then
        RESTThread.Cancel;
end;

Interessanter Ansatz, hat aber letztlich nicht so geil geklappt.

zusammenfalten · markieren

Delphi-Quellcode:

  ...
  tempThread := Whatever();

  // Speichern der lokalen Objekte, damit man beim OnAccept oder OnError
  // auch damit arbeiten kann:
  mainThread := tempThread;
  mainClient := tempClient;
  mainRequest := tempRequest;
  mainResponse := tempResponse;

  // Warten, bis entweder der Thread von außen beendet wird (Terminated) oder
  // er selbst fertig wird (FRecieved):
  while (NOT Terminated) AND (NOT FRecieved) do
  begin
    Sleep(10);
  end;
  // Wenn hier angekommen schauen, ob er hier ankommt, weil er Daten
  // empfangen hat. Falls es durch "Terminate" von außen passiert ist
  // den Rest-Thread mit "Cancel();" abbrechen:
  if (Terminated) AND (NOT FRecieved) then mainThread.Cancel();

  // Warten, bis er den Thread ordnungsgemäß beendet hat:
  mainThread.WaitFor();

  // Jetzt sind wir hier fertig, das Programm soll beendet werden,
  // also alles wieder freigeben:
  mainClient.Free();
  mainRequest.Free();
  mainResponse.Free();
  mainThread.Free();

Beim Freigeben kommt es immer zu Fehlern. Es sieht auch nicht so aus,
als ob Cancel die Rest-Abfrage tatsächlich abbrechen würde,
respektive das WaitFor dann wartet, bis der Abbruch durch ist.

Das ist mir Zuviel Pseudocode und Zuwenig Kontext, um irgendwas sinnvolles dazu sagen zu können.
Wer ist denn der Owner von Request, Response und Client?
Kannst du dein Problem vielleicht in einen vollständigen kleinen Beispiel zip-archivieren und hochladen?

Vergesse das mal mit dem eigenen Extra-Thread.
Speichere dir den TRESTExecutionThread in eine Member-Variable und prüfe dem Empfang einfach zyklisch per TTimer.
Wenn Antwort empfangen wurde oder das Programm beendet wird, mit Cancel() abbrechen.

Kannst du nicht einfach einen zweiten Request schicken und der Server beendet (beantwortet) dann auch den anderen Request?

Zitat von TiGü:

Das ist mir Zuviel Pseudocode und Zuwenig Kontext, um irgendwas sinnvolles dazu sagen zu können.
Wer ist denn der Owner von Request, Response und Client?
Kannst du dein Problem vielleicht in einen vollständigen kleinen Beispiel zip-archivieren und hochladen?

Vergesse das mal mit dem eigenen Extra-Thread.
Speichere dir den TRESTExecutionThread in eine Member-Variable und prüfe dem Empfang einfach zyklisch per TTimer.
Wenn Antwort empfangen wurde oder das Programm beendet wird, mit Cancel() abbrechen.

Owner?
RESTClient := TRESTClient.Create(sUrl);
RESTResponse := TRESTResponse.Create(RESTClient);
RESTRequest := TRESTRequest.Create(RESTClient);
Wo gibt es da Owner?

Beispiel hochladen kann ich (wie immer) nicht, da ich mich auf einen Rest-Endpunkt beziehe,
welcher bei euch nicht existiert; Body, Parameter, Header usw. enthalten sicherheitskritische Informationen, welche ich nicht posten kann.

Die Thread-Struktur enthält ja nur diese 3 (für dieses Beispiel relevante):
- Der Main-Thread welcher den Nachrichten-Tread erstellt und beim Close per
"Terminate();" beenden soll
- Der Nachrichten-Thread, welcher den Rest-Thread (wie von TiGü beschrieben) erstellt,
die Events empfangen und Nachrichten abarbeiten soll (ohne den Anwender von der Arbeit ab zu halten)
- Und der Rest-Thread, welcher ja ohnehin durch
RestThread := RESTRequest.ExecuteAsync(aCompletionHandler, False, False, aCompletionHandler2);
erstellt wird (evtl. noch weitere innen-liegende, aber davon habe ich keine Ahnung)

Auf jeden Fall kann ich davon keinen "auflösen". Die Abarbeitung der Nachrichten kann ich ja unmöglich im Main-Thread machen.

Einen Abbruch-Request? Mal sehen, ob das so geht.

Das klingt jetzt alles ein wenig negativ, hoffenlich kommt das nicht falsch rüber.

Ich forsche dann mal weiter ...

LG Incocnito

Okay, du nimmst TCustomRESTClient.Create(const ABaseApiURL: string); als Constructor, kannte ich so auch noch nicht.

Der Client hat dann keinen Owner und muss selber freigeben werden.
Wenn du aber dann noch Response und Request so erstellst, dass der Client der Owner ist (Übergabe im Constructor), dann kannst du die nicht händisch freigeben.
Daher resultieren wahrscheinlich deine "Beim Freigeben kommt es immer zu Fehlern."-Probleme.

Edit: Den REST-Thread auch nicht selber freigeben, einfach AFreeThread als dritten Parameter im ExecuteAsync() auf True setzen.

Ok,

nächster Step ...
Ich habe den TRestExecutionThread wieder raus geworfen und auf einen "normalen" TRestClient-Aufruf umgebaut. Das RestRequext.Execute(); läuft in einem Thread (der Nachrichten-Thread), wie beschrieben.
Den Thread kann man ja per Terminate(); beenden.
Nun habe ich die Funktion "TerminateSet" von TThread überladen und dort einfach
RESTRequest.Cancel(); aufgerufen.
Oh Wunder, damit bricht er den Request ab und kommt sauber zurück.
Derzeit gebe ich dann wie von TiGü empfohlen nur den RESTClient frei,
aber ich will noch prüfen, ob ich jetzt irgendwelche Speicherlecks habe.
Damit sieht es auf jeden Fall schonmal gut aus.

Am Ende des Tages wusste ich nicht, dass es "TerminateSet();" und "RESTRequest.Cancel();" gibt.

Ich hoffe das hilft einem eventuellen Leser in Zukunft weiter.

Liebe Grüße
Incocnito