Ich habe ein Objekt, welches Daten aus dem Internet laden soll und dann kalkulieren soll.

Kann aber sein, dass das Objekt nicht mehr benötigt wird, bevor die Kalkulation beendet wurde. Wie kann das Objekt in seinem Destroy den Task beenden?

Hier mal ein Codebeispiel:

zusammenfalten · markieren

Delphi-Quellcode:

type

  TComplexDataRec = record
    // ManyItemsToCalculate
    dataAvailable:Boolean;
  end;

  TDataObject = class(TObject)
  public
    fcalculatedComplexData: TComplexDataRec;

    procedure LoadAndCalculate;

    constructor Create;
    destructor Destroy;override;
  end;

implementation

{ TDataObject }

constructor TDataObject.Create;
begin

end;

destructor TDataObject.Destroy;
begin
  // Instanz wird nicht mehr gebraucht und soll freigegeben werden.
  // Aber der Task, welcher mit LoadAndCalculate gestartet wurde
  // kann eventurell noch laufen.

  // Eigentlich darf ich diese Instanz nicht freigeben, solange der Task noch läuft, da dieser
  // ja auf die Variable fcalculatedComplexData zugreifen wird.

  // Wie beende ich den Task und stelle sicher, dass das zweite TThread.Synchronize noch
  // abgearbeitet wird.
  inherited
end;

procedure TDataObject.LoadAndCalculate;
var
  lComplexDataToCalc: TComplexDataRec;
begin
  TTask.run(
    procedure
    begin
      TThread.Synchronize(nil,
        procedure
        begin
          //************************************************************************
          // Hier mit einem NotifyEvent in eine Liste der aktiven Treads eintragen.
          //************************************************************************

          fcalculatedComplexData.dataAvailable := False;
        end);

        // hier Daten aus dem Internet laden und die complexe Berechnung durchführen
        // und in lComplexDataToCalc speichern

      TThread.Synchronize(nil,
        procedure
        begin
          fcalculatedComplexData:=lComplexDataToCalc;
          fcalculatedComplexData.dataAvailable := True;

          //************************************************************************
          // Hier mit einem NotifyEvent aus der Liste der aktiven Treads austragen.
          //************************************************************************
        end);
    end);
end;

Über diese bzw. eine ähnliche Problematik habe ich mal was geschrieben: Async Tasks in VCL Projects. Vielleicht passt das ja für deinen Fall.

im DoTerminate/OnTerminate,
aber am Einfachsten als Try-Except in der Execute-Methode,

bzw., wenn du eh ein eigenes DatenObjekt hast, dann das doch einfach als Interface (referenzgezählt).

Danke ihr beiden.

Das mit dem Interface ist ja mal ne Idee
Manchmal kann die Lösung so einfach sein.


<Insider>Frank (Mavarik), das wird bestimmt Gesprächsthema beim nächsten Delphifrühstück </Insider>

Zitat von bernau:

Danke ihr beiden.

Das mit dem Interface ist ja mal ne Idee
Manchmal kann die Lösung so einfach sein.


<Insider>Frank (Mavarik), das wird bestimmt Gesprächsthema beim nächsten Delphifrühstück </Insider>

Ich war nicht schnell genug... <Insider>Natürlich</Insider>

Mavarik

<Outsider> Frank (der Andere) war schneller </Outsider>

Tatsächlich habe ich das auch mit Interfaces gelöst. Konkret habe ich einen Handler dafür an unseren Basisformular-Typ angetackert, so dass man dann in dem Interface prüfen kann, ob das Fenster noch vorhanden, noch sichtbar usw. ist. So kann man nicht nur darin die anonyme Methode unterbringen, die nach dem Ende des Threads im Formular arbeitet, sondern man kann darin auch prüfen, ob das Ergebnis noch angezeigt werden muss usw., falls das nicht mehr nötig ist, wenn das Fenster nicht mehr sichtbar ist.

Das ganze noch mit Generics verfeinert gab eine echt schöne Lösung.