Endlosschleife + WarteFunktion ohne Programm zu blockieren

[.chicken]

Also genutzt wird die Unit von aussen insofern, dass sie gestartet wird und sobald das Ereignis OnChange auftritt, werden von aussen die Sentences und Options angezeigt, die in den Arrays sind.

Delphi-Quellcode:

Und zudem musst du dann die Execute-Methode anlegen/überschreiben. Die wird nämlich ausgeführt.

Wie mach ich das? Verstehe noch net ganz was du damit meinst! ^^

[sirius]

siehe edit :mrgreen:

Edit: Ach und zum steuern des Threads von aussen gibt es die Methoden:
-suspend (anhalten)
-resume (fortsetzen)
-terminate (abbrechen, dadurch wird eben terminated gesetzt)

[.chicken]

Danke sehe ich mir die Tage an, muss nun wech ;-)

[.chicken]

Ok, das ist soweit ja relativ einfach, also Execute startet den Thread einfach und am Ende von Execute wird er wieder beendet? Dh ich muss für jeden Dialog den ich aufrufe das ganze neu Createn oder?

Die Sache ist jetzt noch, ich kann ja so nur im OnChange Ereignis darauf zugreifen, ich muss aber jedes mal wenn die Form, die die Unit einbindet gepainted wird, darauf zugreifen können, also nur die Variablen abrufen, nicht ändern! Geht das einfach oder muss ihc in der Form dann neue Variablen machen, die im OnChange geändert werden? Fänd ich etwas unpraktisch!

Soweit aber schonmal ein FETTES DANKE, dafür dass du dir die Mühe gemacht hast dir das anzusehn und es zu ändern :) Super nett ;-)

[.chicken]

Würde mir meinen letzten Post wohl nochmal wer beantwortet bitte? :angel: :dp: :-D Frohe Weihnachten ;-)

[Opa]

Ohne Test, so aus dem Kopf. Die Werte aggf. ans Formular senden!!!

Code:

unit MyThread;
interface
uses
  Windows,Classes,SysUtils,ComCtrls)

  TMyThread = class(TThread)
    private
      AHandle    : THandle;
    protected
       procedure Execute;override;
    public
    published
    protected
    public
      constructor Create(Handle:THandle);virtual;
      destructor  Destroy;override;
    published
  end;
implementation
{Type-TDriveThread-Anfang******************************************************}

{Protected-TDriveThread-Anfang*************************************************}
procedure TMyThread.Execute;
var
  I : intger;
begin
  inherited;
  I := 0;
  SendMessage(AHandle,WM_USER+10,0,0); // Für Senden für Meldungen
  while GetAsyncKeystate(VK_ESCAPE) <> 0 do//abbruch wenn ESC-Taste
  begin
    SendMessage(AHandle,WM_USER+11,0,I); //
    inc(I);
  end;
  SendMessage(AHandle,WM_USER+12,0,0);
end;
{Protected-TDriveThread-Ende***************************************************}

{Public-TDriveThread-Anfang****************************************************}
constructor TMyThread.Create(Handle:THandle);
begin
  inherited Create(true);
  AHandle   := Handle;
  Priority  := tpLowest;//Die Eigenschaft Priority gibt die Priorität des Thread an.
                        // Je nach Bedarf kann eine höhere oder niedrigere Priorität zugeordnet werden.
end;
//------------------------------------------------------------------------------
destructor TMyThread.Destroy;
begin
  inherited;
end;
{Public-TDriveThread-Ende******************************************************}
{Type-TDriveThread-Ende********************************************************}

uses
  MyThread;
{in Haupform}
private
  FMyThread  : TMyThread;
  procedure WM_USER10(var Msg: TMessage); message WM_USER+10;
  procedure WM_USER11(var Msg: TMessage); message WM_USER+11;
  procedure WM_USER12(var Msg: TMessage); message WM_USER+12;

procedure TMain.FormDestroy(Sender: TObject);
begin
  FreeAndNil(FProgressbarThread);
end;

procedure TMain.Button1Click(Sender: TObject);
begin
  FMyThread := TMyThread.Create(Handle);
  FMyThread.Resume;
end;

procedure TMain.WM_USER10(var Msg: TMessage);
begin
  Label1.Caption := 'Start';
end;

procedure TMain.WM_USER11(var Msg: TMessage);
begin
  Label2.Caption := intToStr(Msg.LParam);
end;

procedure TMain.WM_USER11(var Msg: TMessage);
begin
  Label3.Caption := 'Fertig';
end;

MFG

[.chicken]

Finds toll dass du duir soviel Mühe gemacht hast, danke aber mit fertigem Code kann ich recht wenig anfangen. Ich hätte lieber einen kleinen Denkanstoß gehabt. Was muss ich machen damit ich dauerhaft bestimmte Variablen von aussen lesen kann?

Wie wärs mit einer onRead-Procedure, die während der Ausgabe den Thread pausiert!?

[Opa]

Zitat:

Wie wärs mit einer onRead-Procedure, die während der Ausgabe den Thread pausiert!?

Komm darauf an ob ich richtig verstanden habe:
Wenn der Thread läuft soll irgend was nicht passieren? Du wenn der Thread zuende ist soll es weiter gehen?
Wo ist das Problem!
SendMessage(AHandle,WM_USER+10,0,0); Meldung das der Thread gestartet wurde, er sagt dieses dem Hauptformular. SendMessage(AHandle,WM_USER+12,0,0), macht das gleiche wenn Thread fertig.


procedure WM_USER10(var Msg: TMessage);
begin
FtuNix := true;
end;
procedure WM_USER12(var Msg: TMessage);
begin
FtuNix := false;
end;

SendMessage(AHandle,WM_USER+11,0,0), sagt dem Hauptformular das er arbeitet.

Wenn es das nicht ist was du gefragt hast: Dann mal erklären was du mit onRead meinst.

Mfg

[.chicken]

Nene, also ich habein meiner DialogUnit zwei ein paar Variablen und Arrays, auf die das Formular jederzeit zugreifen können soll, damit sie dort gezeichnet werden. Ich habe ein OnChange-Event, in diesem Event kann die Form schon auf die Variablen zugreifen, ich möchte aber dass die Form das immer kann.

Dazu könnte ich einfach im OnChange Event die Variablen an das Formular übergeben und sie da speichern, bis ein neues OnChange Event auftritt. Das ist mir aber eigentlich zu umständlich und "unsauber" (warum Variablen doppelt speichern...).

Also könnte ich nicht einfach die Variablen in meiner Dialog Unit als Property erstellen und dann eine ReadFunktion für sie schreiben in der der Thread pausiert wird, dann die Variable zurückgegeben und dann der Thread wieder gestartet wird oder so?
Oder gibts da ne andere, bessere Lösung?

Danke schonmal für die Hilfe!

[sirius]

:gruebel: ich dachte ich hätte schon darauf geantwortet.

Mir fallen drei Möglichkeiten ein:
1. Die Werte zwischenspeichern. Du nennst es zwar unsauber, ist aber genau das um Threads sauber zu trennen und nich kreuz und quer auf Variablen zuzugreifen
2. Wenn sich die Werte sowieso selten ändern, könnte man hier mal über "Critical Sections" (TCriticalSection) nachdenken. Das sind quasi verschiedene Codeabschnitte die irgendwo in beiden Threads liegen (können) und wo du sicherstellen kannst, dass sich nur ein Thread zu einem Zeitpunkt in einem dieser Abschnitte befindet (und eben alle anderen dadurch "blockiert" sind). Ein zweiter Thread müsste, wenn er auch in so einen Abschnitt wöllte, erstmal warten. Dadurch erreichst du eine gewisse Synchronisation. Solche Codeabschnitte sind dann eben der gemeinsame Datenzugriff.
3. Message an den Thread schicken. Dürfte für dich irrelevant sein, denn dann müsste man erstmal ein Windohandle erzeugen (da ist 2. einfacher)
4. Thread mittels suspend anhalten, Variablen lesen und dann resume aufrufen. Finde ich unschön, auch wenns am einfachsten aussieht