Ich habe eine Klasse von TThread abgeleitet. In dieser Klasse habe ich Ereignisse, die ich mit dem Hauptthread synchronisieren muss. Diese Ereignisse haben aber noch Parameter (Um einen Fortschritt anzuzeigen zum Beispiel.). das hab eich so gelöst:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TOnProgress = procedure(Sender: TObject; PercentDone: Integer) of object;
  TOnFinish = procedure(Sender: TObject) of object;
  TSave = class(TThread)
  private
    FFilename: string;
    FIEVect: TImageEnVect;
    FOnProgress: TOnProgress;
    FOnFinish: TOnFinish;
    procedure SetFilename(const Filename: string);
    function GetFilename: string;
    procedure SetIEVect(IEVect: TImageEnVect);
    function GetIEVect: TImageEnVect;
    procedure CompressFiles(Files: TStrings; const Filename: string);
    procedure DecompressFiles(const Filename, DestDirectory: string);
    procedure DoProgress;
  public
    property Filename: string read GetFilename write SetFilename;
    property IEVect: TImageEnVect read GetIEVect write SetIEVect;
    property OnProgress: TOnProgress read FOnProgress write FOnProgress;
    property OnFinish: TOnFinish read FOnFinish write FOnFinish;
    procedure Execute; override;
  end;

markieren

Delphi-Quellcode:

procedure TSave.DoProgress(PercentDone: Integer);
begin
  if Assigned(OnProgress) then
    OnProgress(self, 0);
end;

markieren

Delphi-Quellcode:

pd := (i * 100) div Files.Count;
Synchronize(DoProgress(pd));

Jetzt meckert aber Delphi, dass es keine überladene Methode von Synchronize gäbe, die mit diesen Parametern aufgerufen werden könnte. Wie kann ich jetzt die Parameter weiterreiche ohne über eine zusätzliche lokale Variable gehen zu müssen?

einfach die Parameter in Private-Feldern der Threadklasse ablegen. Dann mit Syncronize eine Methode des Threads aufrufen ohne Parameter. Und in dieser Methode das Event auslösen basierend auf den Private-Feldern der Thread-Klasse

Also doch über eine zusätzliche variable gehen? OK, wenn es denn nicht anders geht.

dieses Problem löse ich jeweils, indem ich eigene Window-Messages definiere (WM_USER + x) und je nach auszuführender Aktion dem Form eine Message poste - die Parameter können bequem per (L|W)PARAM mitgeliefert werden (im schlimmsten Fall auch in Form eines Pointers auf Daten)...

Das wäre auch eine Möglichkeit, die ich auch manchmal nutze. Ist mir bei der Nitzung der VCL Threadklasse aber nicht ganz OOP konform.

Ich habe mich nun auch mal an die TThread herangewagt.

Mein Problem war folgendes:
Ich habe drei Kartenleser. Bei jeder "Station" soll eine andere Aktion ausgeführt werden (Leergewicht ermitteln, Fahrzeug füllen, Vollgewicht ermitteln + Lieferschein drucken).
Somit habe ich drei Threads (für jede Station einen) und verschiedene OnIrgendwas-Funktionen (OnKarte, OnGewicht, usw). Wenn nun eine OnIrgendwas aufgerufen wird, wird vom Thread ja die Funktion des Hauptprogramms ausgeführt, also der Code in Unit1.pas.
Eigentlich dachte ich, dass der Thread dem Hauptprogramm nur mitteilt, dass es den jeweiligen Code ausführen soll. Daher habe ich mir über VCL und Fenster und Komponenten keine Gedanken gemacht, obwohl ich das in dem Thread-Tutorial ja gelesen habe. Meine Annahme ist aber falsch, wie ich inzwischen herausgefunden habe. Einer der Threads kam ins Flattern, als er das Druckformular mit Create erstellen sollte. Daraufhiin habe ich mit etlichen MsgBoxen den Ablauf verfolgt.
Nun habe ich alles so umgebaut, dass die Threads so schnell wie möglich wieder aus dem Code der Unit1 raus kommen. Also setze ich bei OnIrgendwas nur Merker und reagiere dann im Hauptprogramm entsprechend darauf. Wenn es nicht anderst geht, dann benutze ich Synchronize, um den Zugriff zu steuern.

Ist dieses Vorgehen empfehlenswert, oder habt Ihr noch bessere Vorschläge?

Der Weg über Messages ist OOP konform der Weg über Synchronize und Variable ist nicht weil die Daten-Kapslung verletz wird und man die interne Struktur von MyThread kennen muss.

Synchronize macht das ganau gleiche im Hintergrund, führt eine SendMessage aus an den MainThread.


Dein Problem ist wen ich richtig verstehe:

MyThread -> synchroner call einer->Procedure/Function im Unit1

wen ja dann tausche den "synchronen call" gegen einen asynchronen (über Message call "SendMessage").


ciao
radekj

Also für mich ist der Weg über Ereignisse OOP konformer. Und was im Hintergrund passiert, interessiert mich in den Moment nicht.

Beispiel für Asynchrone Calls:

markieren

Delphi-Quellcode:

unit Unit1;

interface

uses
  ..., Messages; // <- !

const
  WM_USER_MYMessage = WM_USER +1; // <-- !

zusammenfalten · markieren

Delphi-Quellcode:

TMyForm = class(Form)
...
  protected
    procedure MYMessageProc(var Message: TMessage); message My_USER_MYMessage; // <-- !
end;


procedure TMyForm.MYMessageProc(var Message: TMessage);
begin
  //Mache etwas
  inherited;
end;

end;

[delphi]
Aufruf aus Thread (aber nicht nur):

markieren

Code:

PostMessage(MyForm.HWND, WM_USER_MYMessage, 0, 0); // du kannst auch SendMessage verwenden !

Wen du string übergeben willst dann:

markieren

Code:

procedure MySend(AText: string); // call aus dem Thread, oder von wo anders !
var
  psText: PString;
begin
  New(psText);
  psText^ := AText;
  PostMessage(MyForm.HWND, WM_USER_MYMessage, Integer(psText), 0); // du kannst auch SendMessage verwenden !
end;

und aus "MYMessageProc" wird:

markieren

Code:

procedure TMyForm.MYMessageProc(var Message: TMessage);
var
  sText: string;
begin
  sText := PString(Message.WParam)^;
  Dispose(PString(Message.WParam)); //frei geben
  inherited;
  //Mache etwas, in sTest ist dein string
end;

ciao
radekj

PS: aus dem Kopf getippt, bug possible