Komponente erstellen || Ereignis überschreiben/löschen

[Dragon27]

Hallo,

ich möchte die Socketkomponenten ein wenig modifizieren und meinen Bedürfnissen anpassen. Deshalb möchte ich ausgehend von diesen neue Komponenten erstellen. Nun bin ich noch nicht sehr weit gekommen

So sieht derzeit mein Code aus:

Delphi-Quellcode:

unit BrClient;

interface

uses
  SysUtils, Classes, ScktComp,ClientTypen;

type
  TBRClient = class(TClientSocket)
  private
    { Private-Deklarationen }
    FConnectionState: TConnectionState;
    FOnBRFehler: TFehlerEvent;

    Procedure AddError(Fehlernummer:Integer;Beschreibung:String);
  protected
    { Protected-Deklarationen }
  public
    { Public-Deklarationen }
    procedure Connect(PHost:string; PPort:Integer);
  published
    { Published-Deklarationen }

   property ConnectionState: TConnectionState read FConnectionState;
   property OnBRFehler: TFehlerEvent read FOnBRFehler write FOnBRFehler;
  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('BRSC', [TBRClient]);
end;

Procedure TBRClient.AddError(Fehlernummer:Integer;Beschreibung:String);
begin
if Assigned(OnBRFehler) then
      OnBRFehler(Fehlernummer,Beschreibung);
end;

Procedure TBRClient.Connect(PHost:string; PPort:Integer);
begin
 FConnectionState:=csPending;
 Host:=PHost;
 Port:=PPort;
 if (Host='') or (Port<=0) then begin
   AddError(0,'Host oder Port wurden nicht gesetzt!');
   exit;
 end;
 Open;
end;

end.

Anstatt nun ein neues Ereignis (so wie ich das gemacht habe mit OnBRFehler) zu setzten würde ich gerne das OnError Ereignis überschreiben, das eigentlich schon vorhanden ist. Mit override funktioniert das ganze leider nicht

Danke für Eure Hilfe!

[Bernhard Geyer]

Überschreibe die protected Methode Error. Diese ist nur dafür da den Error-Eventhandler aufzugrufen.

Wenn du einige Properties nicht brauchst so mußt du die Basisklasse von TClientSocket überschreiben. Die paar Zeilen Quellcode von TClientSocket must du halt nochmal schreiben.

[Dragon27]

Danke für Deine Antwort!

Leider verstehe ich das Ganze noch nicht komplett Mit Komponentenentwicklung hab ich noch nicht viel zu tun gehabt.

Habe folgendes probiert, aber leider funktioniert das nicht ganz:

Delphi-Quellcode:

  
   published
{ Published-Deklarationen }
   property OnError: TFehlerEvent read FOnBRFehler write FOnBRFehler; override; //Fehler
   property ConnectionState: TConnectionState read FConnectionState;
  end;

Zitat:

[DCC Fehler] BrClient.pas(24): E2169 Felddefinition nicht erlaubt nach Methoden oder Eigenschaften

[DeddyH]

Was Bernhard meinte:

Delphi-Quellcode:

protected
  procedure Error; override;

[Dragon27]

Danke für die Hilfe!

Hat das eine gewisse Logik, warum das im Protected-Teil steht?

Lieder entsteht mit deiner Lösung auch ein Fehler:

Zitat:

[DCC Fehler] BrClient.pas(18): E2037 Deklaration von 'Error' unterscheidet sich von vorheriger Deklaration

[DeddyH]

Protected bedeutet, dass die darin enthaltenen Methoden für abgeleitete Klassen sichtbar sind, für andere nicht. Und ich hatte das nur so dahingeschrieben, Du müsstest mal nachschauen, mit welchen Parametern die Methode in der Basisklasse deklariert ist.

[Alter Mann]

Hi,

auch wenn ich den eigenen(deinen) Gedankengang damit Zerstöre, könnte
die Lösung so aus sehen:

Delphi-Quellcode:

unit uScktComp;

interface

uses
  Windows, Classes, ScktComp;

type
  TMyClientSoket = class(TClientSocket)
  private
    FConnect : Boolean;
    procedure SetConnect(Value : Boolean);
  public
    constructor Create(aOwner : TComponent); override;
    property Connect : Boolean read FConnect write SetConnect;
  end;

implementation

constructor TMyClientSoket.Create(aOwner : TComponent);
begin
  inherited Create(aOwner);
  FConnect := false;
end;

procedure   TMyClientSoket.SetConnect(Value : Boolean);
var
  ErrInt : Integer;
begin
  if ((Host = '') or (Port = -1)) and Assigned(OnError) then
  begin
    ErrInt := 12345;
    Error(Socket, eeGeneral, ErrInt);
    Active := true;
  end
  else
  Active := true;
end;

Da ich aber nichts mit Client/Server.Socket programmiere = ungetestet!!!

Das einfügen einer neuen Eigenschat Connect ist einfacher als 'alles'
neu zu schreiben und auch sicherer!

Letzeres greift nur, wenn es garnicht anders geht( da man für alles selber Verantwortlich ist!!!).

Viele Grüße

[Dragon27]

Hallo Alter Mann,

danke für deinen ausführlichen Beitrag. In meinem speziellen Problem hat er mir nicht direkt geholfen, jedoch habe ich wieder was dazugelernt

Also irgendwie bin ich langsam am Ende Ich habe nun fast alles probiert und komme zu keinem Ergebnis... Kann es sein dass man die Socketkomponenten nicht ableiten kann?

Ich möchte im Prinzip soetwas machen:

Das Ereignis OnRead etc. umschreiben im Schema:

Delphi-Quellcode:

Procedure Read(hier keine Parameteränderung);
begin
//Eigener Quelltext
inherited Read;
end;

Leider bekomme ich immer die Fehlermeldungen "ist in Basisklasse nicht vorhanden" oder "Falsche Parameter" etc. Praktisch komme ich nie auf eine Lösung...

Danke für Eure Hilfe!

[Blup]

Zitat von Dragon27:

"ist in Basisklasse nicht vorhanden"

Die Meldung sagt aber eigentlich alles aus...
Du kannst nur überschreiben was es auch gibt und nicht im Abschnitt "private" steht.

Zitat von Dragon27:

"Falsche Parameter"

Schau dir die Deklaration in der orginalen Klasse an, wenn du eine Methode überschreiben willst, muss diese nicht nur genau den selben Namen, sondern auch die selben Paramter und Rückgabewerte haben.

Delphi-Quellcode:

type
   TOrginal = class(TObject)
   private
     {kann nicht überschrieben oder von Nachfahren aufgerufen werden}
     procedure Proc1(AParam: TParamTyp);
   protected
     {kann nicht überschrieben aber von Nachfahren aufgerufen werden}
     procedure Proc2;
     {kann überschrieben werden}
     procedure Proc3(AParam: TParamTyp); virtual;
   end;

   TNachfahre = class(TOrginal)
   private
     {hat nichts mit der Methode gleichen Namens in der Basisklasse zu tun}
     procedure Proc1;
   protected
     {hat nichts mit der Methode gleichen Namens in der Basisklasse zu tun,
      verdeckt aber die Methode der Basisklasse}
     procedure Proc2(AParam: TParamTyp); reintroduce;
     {überscheibt ordentlich die orginale Methode}
     procedure Proc3(AParam: TParamTyp); override;
   end;

implementation

procedure TNachfahre.Proc1;
begin
  {tut irgendwas anderes als TOrginal.Proc1}
end;

procedure TNachfahre.Proc1(AParam: TParamTyp);
begin
  {optional Aufruf der Methode gleichen Namens in der Vorgängerklasse}
  inherited Proc1;
  {tut irgendwas mit dem Parameter}
end;

procedure TNachfahre.Proc3(AParam: TParamTyp);
begin
  {optional Aufruf der Methode der Vorgängerklasse mit selben Parametern}
  inherited;
  {tut irgendwas zusätzlich}
end;

[Alter Mann]

Hi,

kann es sein das du keinen Zugriff auf dei Quell-Unit 'ScktComp' hast?

Ein kleiner Auszug:

Delphi-Quellcode:

  TAbstractSocket = class(TComponent)
  private
    FActive: Boolean;
    FPort: Integer;
    FAddress: string;
    FHost: string;
    FService: string;
    procedure DoEvent(Sender: TObject; Socket: TCustomWinSocket; SocketEvent: TSocketEvent);
    procedure DoError(Sender: TObject; Socket: TCustomWinSocket; ErrorEvent: TErrorEvent; var ErrorCode: Integer);
  protected
    procedure Event(Socket: TCustomWinSocket; SocketEvent: TSocketEvent);   virtual; abstract;
    procedure Error(Socket: TCustomWinSocket; ErrorEvent: TErrorEvent;  var ErrorCode: Integer); virtual; abstract;
    procedure DoActivate(Value: Boolean); virtual; abstract;
    procedure InitSocket(Socket: TCustomWinSocket);
    procedure Loaded; override;
    procedure SetActive(Value: Boolean);
    procedure SetAddress(Value: string);
    procedure SetHost(Value: string);
    procedure SetPort(Value: Integer);
    procedure SetService(Value: string);
    property Active: Boolean read FActive write SetActive;
    property Address: string read FAddress write SetAddress;
    property Host: string read FHost write SetHost;
    property Port: Integer read FPort write SetPort;
    property Service: string read FService write SetService;
  public
    procedure Open;
    procedure Close;
  end;

  TCustomSocket = class(TAbstractSocket)
  private
    FOnLookup: TSocketNotifyEvent;
    FOnConnect: TSocketNotifyEvent;
    FOnConnecting: TSocketNotifyEvent;
    FOnDisconnect: TSocketNotifyEvent;
    FOnListen: TSocketNotifyEvent;
    FOnAccept: TSocketNotifyEvent;
    FOnRead: TSocketNotifyEvent;
    FOnWrite: TSocketNotifyEvent;
    FOnError: TSocketErrorEvent;
  protected
    procedure Event(Socket: TCustomWinSocket; SocketEvent: TSocketEvent); override;
    procedure Error(Socket: TCustomWinSocket; ErrorEvent: TErrorEvent;
      var ErrorCode: Integer); override;
    property OnLookup: TSocketNotifyEvent read FOnLookup write FOnLookup;
    property OnConnecting: TSocketNotifyEvent read FOnConnecting write FOnConnecting;
    property OnConnect: TSocketNotifyEvent read FOnConnect write FOnConnect;
    property OnDisconnect: TSocketNotifyEvent read FOnDisconnect write FOnDisconnect;
    property OnListen: TSocketNotifyEvent read FOnListen write FOnListen;
    property OnAccept: TSocketNotifyEvent read FOnAccept write FOnAccept;
    property OnRead: TSocketNotifyEvent read FOnRead write FOnRead;
    property OnWrite: TSocketNotifyEvent read FOnWrite write FOnWrite;
    property OnError: TSocketErrorEvent read FOnError write FOnError;
  end;

  TClientSocket = class(TCustomSocket)
  private
    FClientSocket: TClientWinSocket;
  protected
    procedure DoActivate(Value: Boolean); override;
    function GetClientType: TClientType;
    procedure SetClientType(Value: TClientType);
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    property Socket: TClientWinSocket read FClientSocket;
  published
    property Active;
    property Address;
    property ClientType: TClientType read GetClientType write SetClientType;
    property Host;
    property Port;
    property Service;
    property OnLookup;
    property OnConnecting;
    property OnConnect;
    property OnDisconnect;
    property OnRead;
    property OnWrite;
    property OnError;
  end;

Wie du siehst, es gibt kein Read welches als virtual deklariert ist.

Die einzige Komponente die hier eine Möglichkeit des Überschreibens einer Methode Read ermöglicht,
wäre FClientSocket: TClientWinSocket -> TCustomWinSocket.Read(Socket: TSocket); virtual;.

Soll heißen, die Ableitung muss von ganz anderer Stelle aus erfolgen. Es müssen also neu geschrieben werden:

Delphi-Quellcode:

  TNewCustomWinSocket = class(TCustomWinSoket)
  public
    constructor Create(ASocket: TSocket);override;
    destructor Destroy; override;
    procedure Read(Socket: TSocket); override;
    property LocalHost;
    property LocalAddress;
    property LocalPort;
    property RemoteHost;
    property RemoteAddress;
    property RemotePort;
    property RemoteAddr;
    property Connected;
    property Addr;
    property ASyncStyles;
    property Handle;
    property SocketHandle;
    property LookupState;
    property OnSocketEvent;
    property OnErrorEvent;
    property Data;
  end;

  TNewClientWinSocket = class(TNewCustomWinSocket)
  private
    FClientType: TClientType;
  protected
    procedure SetClientType(Value: TClientType);
  public
    procedure Connect(Socket: TSocket); override;
    property ClientType: TClientType read FClientType write SetClientType;
  end;

  TClientSocket = class(TCustomSocket)
  private
    FClientSocket: TNewClientWinSocket;
  protected
    procedure DoActivate(Value: Boolean); override;
    function GetClientType: TClientType;
    procedure SetClientType(Value: TClientType);
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    property Socket: TClientWinSocket read FClientSocket;
  published
    property Active;
    property Address;
    property ClientType: TClientType read GetClientType write SetClientType;
    property Host;
    property Port;
    property Service;
    property OnLookup;
    property OnConnecting;
    property OnConnect;
    property OnDisconnect;
    property OnRead;
    property OnWrite;
    property OnError;
  end;

Und wie ich finde, ist das eine lösbare Aufgabe.

Viele Grüße