Hallo,

ich habe ein Programm, dass über eine Schnittstelle(USB/COM) mit einem externem Gerät spricht.
Die Kommunikation habe ich komplett ausgelagert in einen 2. Thread, da dem Senden einer Anfrage auch eine
Antwort erwarte (und das warten passiert also jetzt in einem extra Thread, ohne die GUI lahmzulegen).

Mein Thread ist folgender Maßen aufgebaut:

Er beinhaltet eine Jobliste, die sequentiell (FIFO) abgearbeitet wird.

Ein Job ist einfach ein Nachfahre einer abstrakten Jobklasse, die dann die Methode DoJob implementiert.

In meinem DoJob hole ich also bestimmte Werte aus meinem externem Gerät (Beispiel : aktueller Druck).
Wie kann ich denn die Werte die ich dort auslese meiner GUI übergebe?

Sollte ich eine Funktion deklarieren, die einen Datensatz (alle gelesenen Daten) an die GUI (natürlich synchronisiert)
zurückgibt?

Wenn ja wie mache ich dass am Besten?

Oder soll ich die Werte als public Variablen im Thread ablegen und von der GUI aus darauf zugreifen??

Vielleicht könnt ihr mir helfen.

Danke
Gruß DelphiManiac

Meiner Meinung nach wäre eine prozedur die du dann über eine synchronisierung übergibst am besten.

Hättest du da ein Pseudo Code Beispiel ?

in etwa so:

zusammenfalten · markieren

Delphi-Quellcode:

type TmyThread=class TThread
      ...
      procedure uebergeben;
      ...
      zu_uebergeben:string;
      ...
end;
...

procedure Tmythread.uebergeben;
begin
   referenzform.edit1.text:=zu_uebergeben;
end;


procedure TmyThread.execute
begin
  ...
  zu_uebergeben:=irgendetwas
  ...
  synchronize(uebergeben);
  ...
end;

Edit: Delphi-Tags vergessen

Hey Danke Sirius,

dann müsste ich meinem Thread aber genau sagen welches Form und genau welches Editfeld er bedienen soll,
dass will ich aber ungern, da ich ein wenig abstrakter (bzw. Entkoppelung von Design und Logik) arbeiten will.
Ich will eigentlich, dass mein Thread meldet :

--> Hier ist ein neuer Wert
--> Die GUI selbst muss dann entscheiden, was mit dem Wert passiert.

Will also nicht direkt den Wert zuweisen, sondern eher einen Datensatz übergeben.

Danke

Da würde ich mit snychronize Propertys in TmyThread setzen.
Und wenn du sie von aussen abrufst machst du
-mythread.suspend
-Werte auslesen
-mythread.resume

hier gibts auch noch etwas, wie waitforsingleobject. Weis aber nicht, ob das weiterhilft.

Beschäftige dich doch mal mit dem sog. Command-Pattern.
Dort kannst du unabhängige Jobs definieren und abarbeiten.

Der Thread bzw. die ausführende Jobliste kennt die einzelnen
Commands nicht genau -- es führt sie lediglich aus und
über gibt dessen Events.

Im Programm kannst du dir dann das Event des aktuellen
Commands vorknöpfen. So kanns du dein Programm auch mit
immer neuen und unabhängingen Commands füllen und trennst
zugleich alle Komponenten voneinander.

Die genauen Links zum Thema weiß ich nicht mehr, ich bin
allerdings über Google darauf gestoßen. (ich glaube u.a.
Delphi3000.com)

Gruß
Pfoto

Hi Pfoto,

das Command-Pattern wende ich schon an,

ich habe eine Jobliste(die in einem Thread immer einen Job entgegennimmt und ausführt)
Die Jobliste weiß nicht was das für Jobs sind, sie weiß nur, dass sie von der Klasse
TBaseJobs sind

markieren

Delphi-Quellcode:

TBaseJob = class(TObject)
  private
  fSignal:TEvent;
  public
    function DoJob:TJobResult; virtual; abstract; // Wird in den Kindsklassen implementiert
    procedure CallBackData; virtual; abstract;
    property Signal:TEvent
      read fSignal write fSignal;
end; // of TBaseJob = class(TObject)

und die Methode DoJob implementieren
hier in so einem speziellen Job lese ich dann zB. den Druck.
Soweit so gut, nur habe ich ja jetzt den Parameter Druck im Job, der in einem Thread abläuft, aber ich brauche ihn in der GUI.
--> Dass hat mir übrigends DER_UNWISSENDE super erklärt.

Hast du ne Ahnung wie ich das Event gesteuert (und dazu noch synchronisiert) mache?
Die GUI soll sich nicht die Werte holen, sie soll benachrichtigt werden.

Danke schonmal

Hi nochmal:

Hier das command-Pattern, was ich im Kopf hatte,
ist jedoch vom Prinzip her das gleich wie deins:

zusammenfalten · markieren

Delphi-Quellcode:

 
{ Hier ein Beispiel-Command }
TSaveImageCommand = class(TCommand)
  private
    FFilename: string;
  protected
  public
    constructor Create(const AFilename: string); reintroduce; overload;
    procedure Execute; override;
  end;

  TCommand = class
  protected
    FCaption: string;
    FOnCommandProgress: TOnCommandProgress;
    procedure CommandProgress(ACommand: TCommand);
  public
    Constructor Create; virtual;
    procedure Execute; virtual;
    property Caption: string read FCaption;
    property OnCommandProgress: TOnCommandProgress read FOnCommandProgress write FOnCommandProgress;
  end;

Im Thread würde ich nun das Event des Commands umleiten,
so dass es erst den Thread informiert und nicht einfach
bis zur Hauptanwendung durchschlägt, wo es ja nicht synchronisiert
wäre.

Wenn das Event dann den Thread erreicht hat, würde ich einfach
ein Event des Threads auslösen, welches das aktuelle TCommand
übergibt.

Wenn du dann das Event in deiner Anwendung auswerten willst,
kannst du ja das übergebene TCommand-Objekt holen und die
gewünschte Eigenschaft auslesen.

Soweit meine Gedanken hierzu...

Gruß
Pfoto

Hi Pfoto,

ja genau wie in deinem Beispiel mach ich das.
Du hast Recht, dass Event darf der Job (bzw. Command) nicht selbst feuern. Aber wie baue ich dass so,
dass ich es im Thread selbst synchronisiert aufrufe?

Ich brauche natürlich eine parameterlose Thread-Prozedur, die ich mit
  Synchronize(ParameterLoseProz); aufrufe. Meinst du ich soll den konkreten Job übergeben?

Gruß
DelphiManiac