Daten für Nachfolgekomponente "irgendwo"hin senden

[Pseudemys Nelsoni]

Moin,

ich habe eine Komponente geschrieben, dort habe ich es so gemacht, das unverarbeitete Daten an eine (private) prozedur gereicht werden (die die nachfolgerkomponente dann überschreibt). Das heisst aber auch das ich die Funktion bereits in der aktuellen Klasse definieren muss und zwar so:

Delphi-Quellcode:

private 
  procedure proc(daten: string); virtual;
end;

...

procedure myclass.proc(daten: string); 
begin
end;

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

[IngoD7]

Verfolge deinen eigenen Thread hier bis zum Ende. Dort sollte draus hervorgehen, warum eine abstrakte Methode an der Stelle besser ist als eine leere.

[Pseudemys Nelsoni]

Moin Ingo,

das problem ist, das diese Vorgängerkomponente ja auch schon zu benutzen sein soll, wenn ich dort eine abstrakte methode drin habe geht das natürlich nicht.

[IngoD7]

Zitat von Pseudemys Nelsoni:

das problem ist, das diese Vorgängerkomponente ja auch schon zu benutzen sein soll, wenn ich dort eine abstrakte methode drin habe geht das natürlich nicht.

Du meinst, es soll später bei einer Instanz von myclass die Methode proc angesprochen werden können? Ja, dann ist es zwar so korrekt, aber dann sollte die Prozedur proc nicht leer sein, oder?

[Pseudemys Nelsoni]

Moin ingo,

doch in der vorgängerklasse sollte sie leer sein, da ich dort nichts mache in diesem event.

[IngoD7]

Zitat von Pseudemys Nelsoni:

doch in der vorgängerklasse sollte sie leer sein, da ich dort nichts mache in diesem event.

Hmmm ...

Gilt das hier nun, oder gilt es nicht:

Zitat:

Du meinst, es soll später bei einer Instanz von myclass die Methode proc angesprochen werden können?

Bis jetzt habe ich dich so verstanden, als würde es später Instanzen von Tmyclass (ich ergänze jetzt mal das T davor) geben. Also deine Klasse so:

Delphi-Quellcode:

interface
type
  Tmyclass = class(...)
  private 
    procedure proc(daten: string); virtual; 
  end; 

... 

implementation

procedure Tmyclass.proc(daten: string); 
begin 
...?...
end;

Und später im Programm dann so:

Delphi-Quellcode:

var myInst : Tmyclass;

...

myInst := Tmyclass.Create;

Und nun soll es vorkommen dürfen, dass myInst.proc im Programm angesprochen wird?

Ist das so? Wenn ja, warum? Welchen Sinn macht es, eine leere Methode aufzurufen?

Oder werden vielleicht doch nur Nachkommen/Ableitungen von Tmyclass instantiiert?

[Pseudemys Nelsoni]

moin ingo,

ich meinte nicht das ich einer instanz einer klasse erzeuge, sondern das ich eine klasse geschrieben habe, von selbiger möchte ich nun noch eine erstellen durch ableitung.
Sagen wir mal ich mache etwas für die internetprogrammierung und meine erste klasse hat ein feld (TClientSocket) in meiner kompo überschreibe ich das ReadEvent und verarbeite 2 befehle, z.B wenn der socket "blah" "blubb" und "hi" empfängt. Ist es aber etwas anderes soll es für nachfolgerkomponenten möglich sein zu wissen was stattdessen gekommen ist. Um das zu machen muss ich die daten ja irgendwo hingeben (meine idee war eben eine prozedur die die nachfolger kompo überschreiben muss um an die daten zu kommen).

Ist bisschen schwer zu erklären was ich meine, ich hoffe du verstehst was ich meine, sonst erklär ichs nochmal gerne =)

Sollten Fehler im text sein - nicht erwähnen bitte, ich bin schon ein wenig müde *g*

mfg und danke für deine hilfe

[IngoD7]

Zitat von Pseudemys Nelsoni:

ich meinte nicht das ich einer instanz einer klasse erzeuge, sondern das ich eine klasse geschrieben habe, von selbiger möchte ich nun noch eine erstellen durch ableitung.

Und ich meinte, dass keine Klasse und deren Ableitungen etwas nützt, wenn nicht später im Programm Instanzen davon benutzt werden. Meine Frage zielte also auf die spätere Nutzung in Programmen. Das ist entscheidend dafür, ob die Methode proc in deinem Beispiel abstrakt sein sollte oder nicht.

Zitat von Pseudemys Nelsoni:

Sagen wir mal ich mache etwas für die internetprogrammierung und meine erste klasse hat ein feld (TClientSocket) in meiner kompo überschreibe ich das ReadEvent und verarbeite 2 befehle, z.B wenn der socket "blah" "blubb" und "hi" empfängt. Ist es aber etwas anderes soll es für nachfolgerkomponenten möglich sein zu wissen was stattdessen gekommen ist.

Ich verstehe nicht, in welchem Zusammenhang du hier Nachfolgerkomponenten verwendest.
Im späteren Programm hast du doch entweder eine Komponente vom Typ TDeineErsteKlasse oder vom Typ TNachfolgerDerErstenKlasse. Und selbst, wenn du beides hättest, so wären sie doch völlig getrennt voneinander.

Benutzt du deine Basisklasse, also so ... var DeineKomp : TDeineErsteKlasse; ..., so passiert bei DeineKomp.proc gar nichts, weil die proc in TDeineErsteKlasse leer ist.

Benutzt du den Nachfolger, also so ... var DeineKomp : TNachfolgerDerErstenKlasse; ..., so wird bei DeineKomp.proc die Methode TNachfolgerDerErstenKlasse.proc ausgeführt.

Zitat von Pseudemys Nelsoni:

Um das zu machen muss ich die daten ja irgendwo hingeben (meine idee war eben eine prozedur die die nachfolger kompo überschreiben muss um an die daten zu kommen).

Eine Klasse übergibt doch im Programm nichts an seine Nachfolger ....

Zitat von Pseudemys Nelsoni:

ich hoffe du verstehst was ich meine

Ich befürchte, bisher hoffst du vergebens.

Entweder Sender (du) und Empfänger (ich) sind noch nicht auf dieselbe Frequenz eingestellt, weshalb ich nicht begreife, was du meinst, oder aber du hast ein leicht bis mittelschweres Fehlverständnis von Klassen und deren Nutzung.

[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

[IngoD7]

So, nun habe ich - glaube ich zumindest - halbwegs begriffen.

Deine Formulierungen, dass die Basisklasse "die Daten irgendwo hingeben" muss oder sie "Daten an den Nachfolger übergeben soll" waren aber ja wohl grausam missverständlich.

Zitat:

Die Methode die ich überschreibe wird niemals in einer Instanz der Klassen zu sehen sein, [...]daher protected.

Ups ... und da machte ich die ganze Zeit einen mittelprächtigen Gedankenfehler.

Nun bin ich ganz bestimmt auch nicht der große Fachmann in solchen Sachen, doch wenn man als Alternative nicht die ganze TMain.SockReadHandler virtuell machen und in den Nachfolgern jedesmal überschreiben will (dabei würde man dann DoRaw "einsparen"), dann sieht das doch recht plausibel aus, finde ich.

Kannst ja in TMain.DoRaw eine Exception "Die dumme Basisklasse versteht das RawCommand nicht" schmeißen. Dann ist sie nicht so leer.