Daten für Nachfolgekomponente "irgendwo"hin senden

[Pseudemys Nelsoni]

Moin Ingo.

So, heute habe ich mehr Zeit *g*.

Ich versuche es jetzt mal etwas genauer zu beschreiben was ich meine...

Sagen wir mal das ist meine erste Klasse(Das unwichtige (Properties etc) habe ich weggelassen da das hier ja nichts zur Sache tut ):

Delphi-Quellcode:

interface

type
  TMain = class(TComponent)
  private
    FClient: TClientSocket;
    FQueue: string;
    procedure SockReadHandler(Sender: TObject; Socket: TCustomWinSocket);
  protected
    procedure DoRaw(ARawCommand: string); virtual;
  public
    constructor Create(AOwner: TComponent); override;
  end;

implementation

constructor TMain.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FClient := TClientSocket.Create(Self);
  FClient.OnRead := SockReadHandler;
end;

procedure TMain.SockReadHandler(Sender: TObject; Socket: TCustomWinSocket);
var
  RawCommand: string;
begin
  FQueue := FQueue + Socket.ReceiveText;
  while Pos(#10, FQueue) <> 0 do FQueue[Pos(#10, FQueue)] := #13;
  while Pos(#13#13, FQueue) <> 0 do Delete(FQueue, Pos(#13#13, FQueue), 1);
  while Pos(#13, FQueue) <> 0 do
  begin
    RawCommand := Copy(FQueue, 1, Pos(#13, FQueue)-1);
    Delete(FQueue, 1, Pos(#13, FQueue));
    if RawCommand = '' then Continue;
    if RawCommand := 'blah' then ...
    else if RawCommand := 'blubb' then ...
    else if RawCommand := 'hi' then ...
    else DoRaw(RawCommand);  // Alles was obigen Commands nicht zutrifft soll für Nachfolgerklassen sein (durch überschreiben selbiger Methode)
  end;
end;

procedure TPBRawIRCClient.DoRaw(ARawCommand: string);
begin
end;

Das hier ist eine Nachfolgerkomponente:

Delphi-Quellcode:

interface

type
  TSub = class(TMain)
  protected
     procedure DoRaw(ARawCommand: string); override;
  end;

implementation

procedure TSub.DoRaw(ARawCommand: string);
begin
  if RawCommand := 'irgendwasanderes' then ...
  else if RawCommand := 'irgendwasanderes2' then ...
  else if RawCommand := 'irgendwasanderes3' then ...
end;

Hoffe du weisst nun was ich meine. Die Methode die ich überschreibe wird niemals in einer Instanz der Klassen zu sehen sein, sie soll nur für Nachfolgerkomponenten sein, daher protected.
Es sollen von beiden Klassen Instanzen erzeugt werden können, daher kann ich die Methode bei der ersten Klasse nicht als abstract definieren, d.h ich muss sie schon leer in der Klasse implementiert haben damit ich sie überhaupt definieren kann.

Um mich selbst zu quoten:

Zitat:

Meine Frage nun: Ist das der richtige Weg? Funktionieren tut es zwar, aber wie gefragt, ist es richtig?

*g*

MfG