Threads - Methode .. nicht in Basisklasse gefunden

[SyntaxXx]

Nabend zusammen,
ich bin gerade dabei mich ein wenig mit Threads zu befassen.
Jetzt habe ich versucht 2 Memos zur selben Zeit zu befüllen, indem ich einfach die zahlen 0 bis 100 ausgeben lasse.

Dazu hier mein gesammter Quellcode:

Code:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TThread1 = class(TThread)
    protected
       procedure SendMemo1; override;
       procedure SendMemo2; override;
  end;


type
  TForm1 = class(TForm)
    Memo1: TMemo;
    Memo2: TMemo;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);



  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;



var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TThread1.SendMemo1;
var i : integer;
begin
for i := 0 to 100 do
    TForm1.Memo1.Lines.Add(IntToStr(i));
end;

procedure TThread1.SendMemo2;
var i : integer;
begin
for i := 0 to 100 do
    TForm1.Memo2.Lines.Add(IntToStr(i));
end;

procedure TForm1.Button1Click(Sender: TObject);
var Thread : TThread1;
begin
Thread := TThread1.Create(false);
Thread.FreeOnTerminate := true;

end;

end.

Doch immer wenn ich das Programm starten möchte kommt folgender Fehler:

"[DCC Fehler] Unit1.pas(12): E2137 Methode 'SendMemo1' nicht in Basisklasse gefunden"
"[DCC Fehler] Unit1.pas(13): E2137 Methode 'SendMemo2' nicht in Basisklasse gefunden"


Könnt ihr mir sagen, warum ich diese meldung bekomme?

[Sir Rufo]

Also in deinem Beispiel ist so ziemlich alles falsch.

Delphi-Quellcode:

type
  TThread1 = class(TThread)
    protected
       procedure SendMemo1; //override; <- zum Überschreiben von Methode aus den Vorgängerklassen
       procedure SendMemo2; //override;
  // wo ist die Methode Execute ???? denn die führt der Thread automatisch aus
  // und ohne, was soll der Thread ausführen, machen? Einfach nix
  end;

Delphi-Quellcode:

procedure TThread1.SendMemo1;
var i : integer;
begin
for i := 0 to 100 do
  // TForm1 ist die Klasse ... ein Zugriff kann aber nur auf ein Instanz erfolgen
  TForm1.Memo1.Lines.Add(IntToStr(i));
  // Aber ein Thread läuft in einem anderen anderen Thread-Kontext als eine Form
  // und da bekommt man ganz schnell Zugriffsfehler
  // also aus einem Thread NIEMALS direkt auf die GUI/Form/Form-Controls zugreifen
end;

Such mal nach Thread-Tutorials und ein paar Grundlagen Tutorials würden glaub ich auch nicht schaden :)

[SyntaxXx]

Hmmm, ich habe mich nach diesem Tut gehalten: http://wiki.delphigl.com/index.php/T...Multithreading

Und dort steht unten:

Code:

procedure TMyOwnThread.Execute;
begin
  // Führe hier irgendwelche Berechnungen aus.
end;

Deswegen dachte ich TMyOwnThread.Execute ist eine ganz normale procedure.

Override habe ich nur genommen, weil es eben im Beispiel auch da stand.

Ok, ich werde das nochmal durcharbeiten.


Jetzt stell ich mir nur die Frage, wie greife ich denn dann z.B. auf das Memo zu?

[Sir Rufo]

Schau dir einfach mal den Aufbau der Basisklasse TThread an

Und das Tut was du dir angeschaut hast sagt doch auch ganz deutlich

Zitat:

Das Erstellen eines Thread ist in Delphi wahnsinnig einfach. *eg*
Das Einzige was wir tun müssen ist die Klasse TThread abzuleiten und die Methode Execute zu überschreiben.
Wer keine Ahnung von Objekt orientiertem Programmieren (OOP) hat sollte sich an dieser Stelle erst einmal darüber schlau machen.

Das haben die nicht aus Langeweile geschrieben ;)

Falls du wissen möchtest, welche Methoden du aus den Vorgängerklassen "overriden" kannst, dann hat die IDE da eine sehr geniale Hilfe

Delphi-Quellcode:

type
  TThread1 = class( TThread )
    // <- Mit dem Cursor an diese Stelle gehen (diesen Kommentar wegdenken) und dann STRG+SPACE drücken
    // dann bekommst du eine Liste mit diesen Methoden angezeigt und brauchst die gewünschte nur noch auswählen
    // SHIFT+STRG+C (CodeCompletion) und lostippen :o)
  end;

[Luckie]

Eventuell hilft das: http://www.michael-puff.de/Programmi...rials/Threads/ Kapitel 10.

[Sir Rufo]

Oder das hier http://www.delphipraxis.net/142081-p...ogressbar.html (mit einem fertigen Beispiel-Projekt)

Oder das hier http://www.delphipraxis.net/847415-post19.html (ok, ist schon etwas abgedrehter)

[SyntaxXx]

Ok ich hab jetzt nochmal ein wenig gelesen.

Habe jetzt hier folgendes:

In ein Memo wird die ganze Zeit "Thread started" geschrieben.

Normalerweise ohne thread würde das Programm komplett abschmieren, doch jetzt kann ich die Form verschieben wie ich es möchte.
Jetzt ist nur die Frage, wie kann ich den Thread wieder schließen?

Hier mein Code:

Code:

procedure MyThread.Execute;
begin
repeat
Synchronize(Form1.FillMemo);
until 0 = 1;
end;

procedure TForm1.Button1Click(Sender: TObject);
var Thread : MyThread;
begin
Thread := MyThread.Create(true);
Thread.Priority := tpLowest;
Thread.FreeOnTerminate := true;
Thread.Resume;

end;

procedure TForm1.FillMemo;
begin
Memo1.Lines.Add('Thread started');
end;

Am besten wäre es wenn ich mit einem zweiten button den Thread wieder Stoppen kann.
Das problem was ich habe, bei Button1 erstelle ich den Thread "Thread := MyThread.Create(true);".

Wenn ich das jetzt bei Button2 auch aufrufe würde ich ja den thread nochmal starten.
Aber ohne den Aufruf kann ich "Thread.terminate;" nicht aufrufen.

Könnt ihr mir da noch helfen?

[Sir Rufo]

@SyntaxXx

Wenn du Delphi-Code postest, dann benutze bitte die Delphi-Tags
für sonstigen Code die Code-Tags

sonst krieg ich hier Augenkrebs

Code:

procedure SiehtDoofAus;
begin
  // Ja ganz doof
end;

Delphi-Quellcode:

procedure SiehtVielBesserAus;
begin
  // Ja viel besser
end;

Nach über 100 Beiträgen solltest du das eigentlich wissen und es ist lediglich ein Knöppeschen weiter
(und eine anständige Formatierung/Einrückung sollte auch drin sein)

Nun zu deiner Frage:

1. In der Execute-Methode hast du keine Abbruchbedingung definiert
   Delphi-Quellcode:

   until Terminated;

2. Thread ist als lokale Variable in der procedure definiert. Ausserhalb der procedure kann auf diese nicht zugegriffen werden und beim erneuten Aufrufen der procedure ist der Wert undefiniert (auf jeden Fall nicht mehr mit einem vernünftigen Wert gefüllt)

Deklariere in der Form eine entsprechende Thread-Variable

Delphi-Quellcode:

type
  TFooForm = class( TForm )
  ...
  private
    Thread : MyThread;
  ...
  end;

und den Rest so

Delphi-Quellcode:

procedure MyThread.Execute;
begin
  repeat
    Synchronize(Form1.FillMemo);
  until Terminated;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  if Assigned( Thread ) then
    begin
      Thread.Terminate;
      Thread := nil;
    end
  else
    begin
      Thread := MyThread.Create(true);
      Thread.Priority := tpLowest;
      Thread.FreeOnTerminate := true;
      Thread.Resume;
    end;
end;

Jetzt wird mit jedem Klick auf den Button1 der Thread gestartet und auch wieder angehalten

[SyntaxXx]

Ok ich danke dir. Es funktioniert.
Ich muss ganz erlich sagen ich habs total verpeilt das es hier nen Extra Delphi Code Button gibt.

Kommt nicht mehr vor.

Aber vielen Dank für deine Hilfe in dieser späten Stunde.^^