Hallo,

ich habe zwei Varianten eines Threads geschrieben, von denen wahlweise einer ein Problem beackern soll. Mir ist aber unklar, wie ich das datentechnisch strukturieren muss.

Im Prinzip soll das wie folgt funktionieren:

markieren

Delphi-Quellcode:

Type
TThread1=class(TThread);
...
TThread2=class(TThread);
...

und im Hauptprogram:

markieren

Delphi-Quellcode:

var
MyThread: TThread;
first: boolean;
...
if first then MyThread:=TThread1.Create(Self)
         else MyThread:=TThread2.Create(Self);
...
MyThread. ...
...

TThread1 und TThread2 haben dieselbe Daten- und Methodenstruktur, die aber natürlich über die von TThread hinausgeht. Die Methoden selbst unterscheiden sich natürlich (nicht im Namen und der Deklaration aber im Inhalt).

Mein obiges Beispiel läuft im Prinzip sogar, ich kann aber auf Daten und Methoden, die TThread nicht kennt, nicht zugreifen. Ein Typecast würde den Zugriff zwar ermöglichen, ich weiß aber zur Compilezeit ja noch nicht, ob TThread1 oder TThread2 gewählt wird.

Wie strukturiert man so was?

Am einfachsten geht das mit einem BasisThread:

zusammenfalten · markieren

Delphi-Quellcode:

TMyBaseThread = class( TThread )
public
  procedure TuWas1; virtual; abstract;
  procedure TuWas2; virtual; abstract;
end;

TThread1 = class( TMyBaseThread )
protected
  procedure Execute; override;
public
  procedure TuWas1; override;
  procedure TuWas2; override;
end;

TThread2 = class( TMyBaseThread )
protected
  procedure Execute;
public
  procedure TuWas1; override;
  procedure TuWas2; override;
end;

und nun

markieren

Delphi-Quellcode:

var
MyThread: TMyBaseThread;
first: boolean;
...
if first then MyThread:=TThread1.Create(Self)
         else MyThread:=TThread2.Create(Self);
...
MyThread. ...
...

Prima, danke für die Nachhilfestunde!
Genau sach so einem Konstrukt hab ich gesucht

Noch eine Frage:

Wie verfahre ich mit den Methoden Execute und Destroy im Basisthread? Die sollen ja auch überladen werden. Deklariere ich die auch als virtuell oder lege ich da tatsächlich Methoden an mit inherited drin?

Zitat von iphi:

Noch eine Frage:

Wie verfahre ich mit den Methoden Execute und Destroy im Basisthread? Die sollen ja auch überladen werden. Deklariere ich die auch als virtuell oder lege ich da tatsächlich Methoden an mit inherited drin?

Deine abgeleiteten Klassen verhalten sich genauso wie die Vorgänger-Klasse zzgl. der Erweiterungen.

zusammenfalten · markieren

Delphi-Quellcode:

TFooBase = class
protected
  procedure BaseVirtual; virtual;
end;

TFooAfterBase = class( TFooBase )
protected
  procedure AfterBaseVirtual; virtual;
end;

TFooKonkret = class( TFooAfterBase )
protected
  // wurde in TFooBase eingeführt
  procedure BaseVirtual; override;
  // wurde in TFooAfterBase eingeführt
  procedure AfterBaseVirtual; override;
end;

procedure TFooBase.BaseVirtual;
begin
  // man kann hier was machen
end;

procedure TFooAfterBase.AfterBaseVirtual;
begin
  // man kann hier was machen
end;

procedure TFooKonkret.BaseVirtual;
begin
  inherited;
  // Irgendwas machen
end;

procedure TFooKonkret.AfterBaseVirtual;
begin
  inherited;
  // irgendwas machen
end;

Es gibt übrigens eine nette Hilfe bei der Implementierung der konkreten Klassen:

markieren

Delphi-Quellcode:

type
  TMyThread = class( TThread )
  // Den Cursor unter dieser Kommentar-Zeile platzieren und Strg+Leertaste drücken =8o)
  
  end;