OnEvent überschreiben?

[Pseudemys Nelsoni]

hallöle,

wie kann ich ein OnEvent umschreiben? z.b "OnConnect"?

heisst sicher nicht "procedure OnConnect(...); override;" oder?

[SirThornberry]

definier das Event einfach neu. Mal nen Beispiel mit OnClick

Delphi-Quellcode:

  TNewButton = class(TButton)
  private
    FNewOnClick: TNotifyEvent;
    procedure FOnClickProc(Sender: TObject);
  public
    constructor Create(AOwner: TComponent); override;
  published
    property OnClick: TNotifyEvent read FNewOnClick write FNewOnClick;
  end;

constructor TNewButton.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  inherited OnClick := FOnClickProc;
end;

procedure TNewButton.FOnClickProc(Sender: TObject);
begin
  if Assigned(FNewOnClick) then FNewOnClick(Sender);
  //do something other on Click too
end;

[Bernhard Geyer]

Was meinst Du mit "Umschreiben"?
Der Event-Property OnEvent wird immer OnEvent heißen. Du kannst aber neue Events definieren.

Was willst Du eigentlich machen (bzw. welche Komponenen willst Du "umschreiben")?

[Bernhard Geyer]

Zitat:

Zitat von SirThornberry

definier das Event einfach neu. Mal nen Beispiel mit OnClick

Für diese Art des "Umschreibens" haben die Entwickler der Komponente aber i.d.R. eine DoOnClick/DoClick-Methode spendiert, die man einfach überladen kann.

[Pseudemys Nelsoni]

Danke SirThornberry,

auch wenn ich noch nicht alle so verstehe <g>

Was wird da mit assigned() geprüft? ich weiss das die funktion prüft ob der inhalt nil ist aber mehr nicht.

Zitat:

Was meinst Du mit "Umschreiben"?

Also ich habe eine klasse von TClientSocket abgeleitet, ich möchte das "onconnect" ereignis so modifizieren, das es einige sachen "sendet", also "sendtext",

nur ka wie <g>

[SirThornberry]

mit dem Assigned wird einfach geprüft ob das neue Ereignis zugewiesen ist

@Bernhard Geyer: Leider aber nicht immer und wenn man die Sourcen nicht hat ist es schwer heraus zu finden (wenn man nur die DCU's hat). Somit hab ich mir das so angewöhnt. Du meinst bestimmt auch "überschreiben" oder meinst du wirklich "überladen"?

[Bernhard Geyer]

Zitat:

Zitat von Pseudemys Nelsoni

Also ich habe eine klasse von TClientSocket abgeleitet, ich möchte das "onconnect" ereignis so modifizieren, das es einige sachen "sendet", also "sendtext",

Ich würde keine Ableitung von TClientSocket machen sondern entweder:

1, Ein Komponente, welche sich mit einer TClientSocket-Komponente verbindet (wie es Delphi mit TDatabase/TTable/TDataSource/...) auch macht.

2, Eine TClientSocket-Komponente als Member deiner Klasse erzeugst und deine Komponente z.B. nur von TComponent ableitest. Damit hast Du keine Probleme mehr irgendwelche unnötigen Properties/Events/Methoden.

Beide Lösungen sind auch viel eher an das gebräuchliche ISO-Schichtenmodell angelehnt, wie es z.B. auch im Internet verwendet wird (FTP -> TCP -> IP -> "Ethernet-Protokol" -> HW-Sicherungsschicht).

[Bernhard Geyer]

Zitat:

Zitat von SirThornberry

Leider aber nicht immer und wenn man die Sourcen nicht hat ist es schwer heraus zu finden (wenn man nur die DCU's hat). Somit hab ich mir das so angewöhnt. Du meinst bestimmt auch "überschreiben" oder meinst du wirklich "überladen"?

Überschreiben ist es. Aber hab auch schon 2 andere Lösungsmöglichkeiten aufgezeigt.

[Pseudemys Nelsoni]

oh man, ich glaub ich bin zu blöd dazu, sirthornberry :?

ist "FNewOnClick" denn nicht immer "assigned" ? was passiert wenn assigned false ist? funzt der button click dann nicht oder wie ist das <g>

Bernhard, ich glaub das ist mir auch "zu schwer"

[Die Muhkuh]

Hi,

du kannst dir das so vorstellen wie wenn du einen doppelklick auf ne kompo machst und der damit z.B. das OnClick event zuweißt. Wenn es nicht "assinged" ist dann passiert nichts und wenn es "assinged" ist, dann wird dein Code ausgeführt.

[Bernhard Geyer]

Zitat:

Zitat von Pseudemys Nelsoni

Bernhard, ich glaub das ist mir auch "zu schwer"

Wieso zu schwer?

Delphi-Quellcode:

type
  TMyClass = class(TComponent)
  private
    FClientSocket: TClientSocket;
    FOnConnect: TNotifyEvent;

    function ClientSocketEvent(...);
  public
    constructor Create(AOwner: TComponent);
  
  published    
    property OnConnect: TNotifyEvent read FOnConnect write FOnConnect; 
  end;    


constructor TMyClass.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FClientSocket := TClientSocket.Create(self);
  FClientSocket.OnEvent := ClientSocketEvent;
  ...
end;

function TMyClass.ClientSocketEvent(...);
begin
  ...
  ...
  if xyz ....
    if Assigned(OnConnect) then
      OnConnect(self);
  ...
end;

Ohne Garantie auf sofortige Compilierbarkeit!

[Pseudemys Nelsoni]

hallo bernhard,

danke für den code und die mühe in zu schreiben, ich würde ihn sogar verstehen wenn ich wüsste was assigned tut (ja ich kapiers noch immer nicht :oops:)
wenn das event ausgelöst wird wieso muss dann noch mit assigned geprüft werden?

[Bernhard Geyer]

Assigned(OnConnect) entspricht if OnConnect <> nil

Nur wenn dem OnConnect-Event ein Event-Handler zugewiesen wurde, wird dieser Event aufgrufen.

z.B. wenn Du in der IDE eine TButton auf dein Formular legst und darauf doppelklickst, so wird dem Evenhandler OnClick ein Wert zugewiesen. Im Code von TButton (oder einer Basisklasse) steht dann:

Delphi-Quellcode:

  if Assigned(OnClick) then
    OnClick(self);

und dein Code wird dann bei einem Doppelklick während der Laufzeit ausgeführt.

[Pseudemys Nelsoni]

Hallo Bernhard,

Zitat:

Nur wenn dem OnConnect-Event ein Event-Handler zugewiesen wurde, wird dieser Event aufgrufen.

Wann wäre dies nicht der fall? ich meine, wann kann assigned mal "false" ausgeben? muss ja dann ein fehler im source sein oder?

[Die Muhkuh]

Ne, dann wird einfach das Ereigniss nicht ausgeführt.

[Pseudemys Nelsoni]

mannometer ich kriegs echt nicht gebacken...

ich schreib nochmal genau was ich vor habe...

ich leite eine klasse von TClientSocket ab, von der neuen klasse möchte ich das "OnConnect" ereignis
überschreiben. Das OnConnect Ereignis sollte also wenn es fertig ist so aussehen:

Delphi-Quellcode:

procedure TMyClass.OnConnect;
begin
  self.SendText('data1');
  self.SendText('data2');
  self.SendText('data3');
end;

jetzt weiss ich nichtmal wo ich das ereignis hinpacken müsste, protected oder published? letzteres ist doch für den OI gedacht oder? (was ich nichtmal bräuchte).
Dann weiss ich nicht ob da noch irgendwelche parameter beim onconnect hin müssen (Sender: TObject z.b (wozu auch immer das ist).

Hatte schon so angefangen:

Delphi-Quellcode:

type
  TTSSocketClass = class(TClientSocket)
  private
    FOnConnect: TSocketNotifyEvent;
    procedure OnConnectProc(SocketNotifyEvent: TSocketNotifyEvent);
  public
    constructor Create(AOwner: TComponent); override;
  published
    property OnConnect: TSocketNotifyEvent read FOnConnect write FOnConnect;
  end;

implementation

constructor TTSSocketClass.Create(AOwner: TComponent);
begin
  inherited;
  inherited OnConnect := OnConnectProc;
end;

procedure TTSSocketClass.OnConnectProc(Sender: TObject);
begin
  self.SendText('irgendwas eben);
end;

aber ist sicher wieder falsch oder? ich bekomme immer irgendein fehler, diesmal "liste der parameter ist unterschiedlich..."

[Pseudemys Nelsoni]

*hochschieb*

wie "überschreib" ich denn das "OnConnect"? :( wie überschreibe ich überhaupt irgendein Ereignis? ich muss irgendwie ja wissen WANN ich aus meiner klasse heraus daten senden kann, daher brauch ich das "onconnected" ja

[Pseudemys Nelsoni]

*hochschieb*

[Nothine]

is nich getestet, aber ich hab mich kurz mit der TClientSocket komponente auseinandergesetzt und das dürfte sein, wonach du suchst:

Delphi-Quellcode:

interface
  uses ScktComp;

  type TClientSocketDescendant = class(TClientSocket)
  private
  protected
    procedure Event(Socket: TCustomWinSocket; SocketEvent: TSocketEvent); override;
  public
  published
  end;

implementation

  procedure TClientSocketDescendant.Event(Socket: TCustomWinSocket; SocketEvent: TSocketEvent);
  begin
    if SocketEvent = seConnect then
      DoWhateverYouFeelLike(WithTheParamsYouWantOrNeed);
    inherited;
  end;

end;

hoffe es klappt :stupid: :roll: