Methoden-Deklaration vorgeben?

[Der schöne Günther]

Ein weiterer absolut nichtssagender Titel. Bessere Vorschläge erbeten. Tags habe ich auch keine...

Nehmen wir an, ich bin im Begriff einen Batzen an Prozeduren zu deklarieren welche alle die gleiche Parameterliste haben. Anstatt nun jedes mal hinzugehen und zu sagen

Delphi-Quellcode:

type TMeineKlasse = class
   procedure proc1(input1: Integer; input2: TSomeClass; out output: Double);
   procedure proc2(input1: Integer; input2: TSomeClass; out output: Double);
   [...]

Kann ich nicht einmal einen Typ deklarieren und dann immer sagen

Delphi-Quellcode:

type TMeineKlasse = class
   type
      TProcType = procedure(input1: Integer; input2: TSomeClass; out output: Double) of object;
   procedure proc1 = TProcType;
   procedure proc2 = TProcType;
   [...]

Da ich so etwas bislang noch nicht gesehen habe ist die Hoffnung jetzt schon im Keller :(

[mkinzler]

Dann schau dir mal die VCL Sourcen an :zwinker:

[Der schöne Günther]

Ja die Eventhandler wie

Delphi-Quellcode:

TNotifyEvent

sind mir auch als erstes eingefallen - Und gerade dort sehe ich so etwas nicht: Einmal gibt der TNotifyEvent-Typ die Parameterliste vor, dann beinhaltet die Deklaration jeder "onClick"-Methode wieder (redundant?) die Parameterliste in Form von "Sender: TObject".

[Namenloser]

Zitat:

Zitat von mkinzler (Beitrag 1224584)

Dann schau dir mal die VCL Sourcen an :zwinker:

:?:

Nein, geht nicht.

[Der schöne Günther]

wat :|

[jaenicke]

Ich frage mich eher, ob es nicht eine bessere Lösung gibt. Das hört sich für mich eher wie eine Frage nach der Umsetzung einer ungünstigen Lösung des Problems an als nach einer Frage nach dem Problem selbst...

[Der schöne Günther]

Nichts großartiges - Es ging um das Empfangen von Netzwerkpaketen und Erstellen einer Antwort. Je nachdem was für eine Information im ankommenden Paket enthalten ist, werden vollkommen unterschiedliche Dinge getan.

Delphi-Quellcode:

if ankommendesPaket.commandStr = 'zooBesuch' then
   TPaketbehandler.zooBesuchProc(ankommendesPaket, ausgehendesPaket, weitereParams)
else if ankommendesPaket.commandStr = 'zirkusBesuch' then
   TPaketbehandler.zirkusBesuchProc(ankommendesPaket, ausgehendesPaket, weitereParams)
;

Die Methoden wie

Delphi-Quellcode:

zooBesuchProc

schauen sich das Paket an, tuen entsprechende Dinge und generieren eine Antwort. Mehr steckt nicht dahinter.

Abgesehen davon welches halbe Dutzend etablierte Patterns ich hier hätte unterbringen können, rein syntaktisch wollte mir nur sparen, für alle Methoden ständig die gleichen Parameterlisten in der Deklaration runterzutippen sondern es einmal an einem Platz haben...

[Perlsau]

Zitat:

Zitat von Der schöne Günther (Beitrag 1224598)

Abgesehen davon welches halbe Dutzend etablierte Patterns ich hier hätte unterbringen können, rein syntaktisch wollte mir nur sparen, für alle Methoden ständig die gleichen Parameterlisten in der Deklaration runterzutippen sondern es einmal an einem Platz haben...

Du kopierst dir einfach die erste Methode mit der notwendigen Parameterliste und fügst dann das Kopierte darunter so oft ein, wie du es benötigst:

Delphi-Quellcode:

private
  procedure proc1(input1: Integer; input2: TSomeClass; out output: Double);
  procedure proc1(input1: Integer; input2: TSomeClass; out output: Double);
  procedure proc1(input1: Integer; input2: TSomeClass; out output: Double);
  procedure proc1(input1: Integer; input2: TSomeClass; out output: Double);
  procedure proc1(input1: Integer; input2: TSomeClass; out output: Double);
  procedure proc1(input1: Integer; input2: TSomeClass; out output: Double);
  procedure proc1(input1: Integer; input2: TSomeClass; out output: Double);

Danach mußt du nur noch die Proceduren-Bezeichner der Kopien ändern:

Delphi-Quellcode:

private
  procedure proc1(input1: Integer; input2: TSomeClass; out output: Double);
  procedure proc2(input1: Integer; input2: TSomeClass; out output: Double);
  procedure proc3(input1: Integer; input2: TSomeClass; out output: Double);
  procedure proc4(input1: Integer; input2: TSomeClass; out output: Double);
  procedure proc5(input1: Integer; input2: TSomeClass; out output: Double);
  procedure proc6(input1: Integer; input2: TSomeClass; out output: Double);
  procedure proc7(input1: Integer; input2: TSomeClass; out output: Double);

Am Schluß erzeugst du die Methoden mit Strg+Shift+C:

Delphi-Quellcode:

procedure TForm1.proc1(input1: Integer; input2: TSomeClass; out output: Double);
begin

end;

procedure TForm1.proc2(input1: Integer; input2: TSomeClass; out output: Double);
begin

end;

procedure TForm1.proc3(input1: Integer; input2: TSomeClass; out output: Double);
begin

end;

procedure TForm1.proc4(input1: Integer; input2: TSomeClass; out output: Double);
begin

end;

procedure TForm1.proc5(input1: Integer; input2: TSomeClass; out output: Double);
begin

end;

procedure TForm1.proc6(input1: Integer; input2: TSomeClass; out output: Double);
begin

end;

procedure TForm1.proc7(input1: Integer; input2: TSomeClass; out output: Double);
begin

end;

Dauer der Aktion bei 7 Proceduren: Unter einer Minute!

[uligerhardt]

Zitat:

Zitat von Perlsau (Beitrag 1224600)

Dauer der Aktion bei 7 Proceduren: Unter einer Minute!

Mag sein. Eine in die Sprache integrierte Lösung wäre trotzdem schöner, wartungsfreundlicher und weniger fehleranfällig.

[Der schöne Günther]

Richtig. So wie manche Bodybuilder auf Veranstaltungen gehen und ihren Körper bewundern lassen, führe ich oft vor, in welcher Geschwindigkeit meine Finger über die Tastatur huschen und mit welchen raffinierten RAD Studio-Tricks ich die wunderbarsten Dinge ermögliche. Ersteres könnte ich natürlich auch, aber da spielt Delphi nur noch eine untergeordnete Rolle.

Tipp des Tages: Die Code-Completion geht sogar rückwärts: Funktion direkt implementieren und der Editor ergänzt die Deklaration in der Klasse.

Zitat:

schöner, wartungsfreundlicher und weniger fehleranfällig

Genau darum ging es mir :-)
Ich hätte die Parameterliste gerne nicht ein Dutzend mal redundant im Quelltext. Hat so etwas eigentlich einen hippen Fachbegriff?

[uligerhardt]

Zitat:

Zitat von der schöne günther (Beitrag 1224604)

ich hätte die parameterliste gerne nicht ein dutzend mal redundant im quelltext. Hat so etwas eigentlich einen hippen fachbegriff?

dry?

Edit: Ich darf DRY nicht großschreiben. :-/
Edit2: ... oder nur, wenn ich ganze Sätze formuliere. :oops:

[Sir Rufo]

Das kann man auch schön so umsetzen

Delphi-Quellcode:

IMyMethod = interface
  procedure Execute( input1: Integer; input2: TSomeClass; out output: Double );
end;

// Eine Dummy-Klasse zum Veranschaulichen
TMyDummyMethod = class( TInterfacedObject, IMyMethod )
protected
  procedure Execute( input1: Integer; input2: TSomeClass; out output: Double );
end;

procedure TMyMethod.Execute( input1: Integer; input2: TSomeClass; out output: Double );  
begin
  output := 0;
end;

Jetzt für jeden konkreten Befehl so eine Klasse erstellen und die jeweilige Instanz in einem

Delphi-Quellcode:

TDictionary<string,IMyMethod>

verwalten

Der Aufruf gestaltet sich ja dann sehr smart

Delphi-Quellcode:

type
  TPacketHandler = class
  private
    fMethodDict : TDictionary<string,IMyMethod>;
  public
    procedure Execute( const ACommandStr : string; input1: Integer; input2: TSomeClass; out output: Double );
    procedure AddMethod( const ACommandStr : string; AMethod : IMyMethod );
  end;

procedure TPacketHandler.Execute( const ACommandStr : string; input1: Integer; input2: TSomeClass; out output: Double );
begin
  fMethodDict[ACommandStr].Execute( input1, input2, output );
end;

procedure TPacketHandler.AddMethod( const ACommandStr : string; AMethod : IMyMethod );
begin
  fMethodDict.AddOrSet( ACommandStr, AMethod );
end;

Man kann das auch mit einem Chain-Of-Responsibility-Pattern lösen, aber für meinen Geschmack nehme ich lieber ein Dictionary :)

[Perlsau]

Zitat:

Zitat von uligerhardt (Beitrag 1224601)

Zitat:

Zitat von Perlsau (Beitrag 1224600)

Dauer der Aktion bei 7 Proceduren: Unter einer Minute!

Mag sein. Eine in die Sprache integrierte Lösung wäre trotzdem schöner, wartungsfreundlicher und weniger fehleranfällig.

Damit mußt du dich an Embarcadero wenden ...

[uligerhardt]

Zitat:

Zitat von Perlsau (Beitrag 1224612)

Damit mußt du dich an Embarcadero wenden ...

Das ist klar. :mrgreen:

[Perlsau]

Zitat:

Zitat von Sir Rufo (Beitrag 1224610)

Das kann man auch schön so umsetzen

Delphi-Quellcode:

IMyMethod = interface
  procedure Execute( input1: Integer; input2: TSomeClass; out output: Double );
end;

// Eine Dummy-Klasse zum Veranschaulichen
TMyDummyMethod = class( TInterfacedObject, IMyMethod )
protected
  procedure Execute( input1: Integer; input2: TSomeClass; out output: Double );
end;

procedure TMyMethod.Execute( input1: Integer; input2: TSomeClass; out output: Double );  
begin
  output := 0;
end;

Jetzt für jeden konkreten Befehl so eine Klasse erstellen und die jeweilige Instanz in einem

Delphi-Quellcode:

TDictionary<string,IMyMethod>

verwalten

Der Aufruf gestaltet sich ja dann sehr smart

Delphi-Quellcode:

type
  TPacketHandler = class
  private
    fMethodDict : TDictionary<string,IMyMethod>;
  public
    procedure Execute( const ACommandStr : string; input1: Integer; input2: TSomeClass; out output: Double );
    procedure AddMethod( const ACommandStr : string; AMethod : IMyMethod );
  end;

procedure TPacketHandler.Execute( const ACommandStr : string; input1: Integer; input2: TSomeClass; out output: Double );
begin
  fMethodDict[ACommandStr].Execute( input1, input2, output );
end;

procedure TPacketHandler.AddMethod( const ACommandStr : string; AMethod : IMyMethod );
begin
  fMethodDict.AddOrSet( ACommandStr, AMethod );
end;

Und damit bist du natürlich sehr viel schneller, weil du viel weniger Aufwand betreiben mußt, nicht wahr?

[Sir Rufo]

Zitat:

Zitat von Perlsau (Beitrag 1224614)

Zitat:

Zitat von Sir Rufo (Beitrag 1224610)

Das kann man auch schön so umsetzen

Delphi-Quellcode:

IMyMethod = interface
  procedure Execute( input1: Integer; input2: TSomeClass; out output: Double );
end;

// Eine Dummy-Klasse zum Veranschaulichen
TMyDummyMethod = class( TInterfacedObject, IMyMethod )
protected
  procedure Execute( input1: Integer; input2: TSomeClass; out output: Double );
end;

procedure TMyMethod.Execute( input1: Integer; input2: TSomeClass; out output: Double );  
begin
  output := 0;
end;

Jetzt für jeden konkreten Befehl so eine Klasse erstellen und die jeweilige Instanz in einem

Delphi-Quellcode:

TDictionary<string,IMyMethod>

verwalten

Der Aufruf gestaltet sich ja dann sehr smart

Delphi-Quellcode:

type
  TPacketHandler = class
  private
    fMethodDict : TDictionary<string,IMyMethod>;
  public
    procedure Execute( const ACommandStr : string; input1: Integer; input2: TSomeClass; out output: Double );
    procedure AddMethod( const ACommandStr : string; AMethod : IMyMethod );
  end;

procedure TPacketHandler.Execute( const ACommandStr : string; input1: Integer; input2: TSomeClass; out output: Double );
begin
  fMethodDict[ACommandStr].Execute( input1, input2, output );
end;

procedure TPacketHandler.AddMethod( const ACommandStr : string; AMethod : IMyMethod );
begin
  fMethodDict.AddOrSet( ACommandStr, AMethod );
end;

Und damit bist du natürlich sehr viel schneller, weil du viel weniger Aufwand betreiben mußt, nicht wahr?

Nicht unbedingt schneller, aber flexibler ;)

[BUG]

Zitat:

Zitat von Perlsau (Beitrag 1224612)

Zitat:

Zitat von uligerhardt (Beitrag 1224601)

Mag sein. Eine in die Sprache integrierte Lösung wäre trotzdem schöner, wartungsfreundlicher und weniger fehleranfällig.

Damit mußt du dich an Embarcadero wenden ...

Da die Signatur einer Methode mehr oder weniger als Bezeichner verwendet wird, sehe ich kaum eine elegante Methode um das zu lösen.

Mit Makros à la C++ würde es funktionieren:

Code:

#define DECLARE_HANDLER_PROC(NAME) procedure NAME(input1: Integer; input2: TSomeClass; out output: Double)
  
  DECLARE_HANDLER_PROC(proc1);
  DECLARE_HANDLER_PROC(proc2);
  DECLARE_HANDLER_PROC(proc3);
  DECLARE_HANDLER_PROC(proc4);
  DECLARE_HANDLER_PROC(proc5);

Am schönsten fände ich es, wenn man einen vordefinierten Funktions-/Methodentyp bei der Deklaration benutzen könnte.
Das habe ich aber noch in keiner Sprache gesehen.

[Furtbichler]

Zitat:

Zitat von BUG (Beitrag 1224656)

Das habe ich aber noch in keiner Sprache gesehen.

Natürlich nicht, weil man sich damit zum Horstl macht. Man verwendet eine Factory. Deshalb wurden die ja erfunden. Wenn ich in einer Klasse alle Handler/Methoden unterbringe, dann verstoße ich z.B. gegen das Open/Closed-Prinzip und meine Klasse degeneriert immer weiter, d.h. wird immer größer und größer => Ganz ganz schlecht und peinlich.

Also: Mach es wie Sir Rufo vorgeschlagen hat: Nimm eine Factory.

[BUG]

Zitat:

Zitat von Furtbichler (Beitrag 1224657)

Natürlich nicht, weil man sich damit zum Horstl macht. Man verwendet eine Factory. Deshalb wurden die ja erfunden.

Das Problem war imho nicht:
"Wie teile ich Methoden auf Klassen auf." => Factories, usw.
sondern:
"Wie vermeide ich es, tausendmal (auch in verschiedenen Klassen) die gleiche Signatur zu tippen.".

Gerade bei SirRufus' Lösung muss man bei jeder Implementierung von IMyMethod bei jeder Deklaration und jeder Definition der Methode die gleiche Signatur tippen.
Oder übersehe ich da etwas?


BTW: Meine "Lieblingslösung" wurde ja schon im Ausgangspost genannt :oops:

[Namenloser]

@Sir Rufo, Furtbichler: Ändert allerdings auch nichts daran, dass man die Parameterdeklaration bei jeder Methode wieder hinschreiben muss.

Wenn dann würde sich vielleicht eher dieses Pattern anbieten, wo man statt die Parameter einzeln zu übergeben, ein einziges Objekt übergibt, das alle Parameter beinhaltet... mit Namen hab ichs nicht so :-D. So spielt die dann Reihenfolge keine Rolle und man kann auch neue Parameter hinzufügen, ohne alle Methoden anpassen zu müssen.

Also statt:

Delphi-Quellcode:

TMyDummyMethod = class
protected
  procedure Execute( input1: Integer; input2: TSomeClass; out output: Double );
end;

procedure TPacketHandler.Execute( const ACommandStr : string; input1: Integer; input2: TSomeClass; out output: Double );
begin
  fMethodDict[ACommandStr].Execute( input1, input2, output );
end;

Delphi-Quellcode:

TMyMethodParameters = class
  input1: Integer;
  input2: TSomeClass;
  output: Double;
end;

TMyDummyMethod = class
protected
  procedure Execute(parameters: TMyMethodParameters);
end;

procedure TPacketHandler.Execute( const ACommandStr : string; input1: Integer; input2: TSomeClass; out output: Double );
var 
  Parameters: TMyMethodParameters;
begin
  Parameters:= TMyMethodParameters.Create(input2, input2, output);
  fMethodDict[ACommandStr].Execute(Arguments);
  Parameters.Free;
end;

(jaja public Felder sind pöhse usw., ist nur qualitativ).

Aber KISS.

[Der schöne Günther]

Tippen an sich sollte man noch jedem zutrauen können :-D

Es sollte ja nicht darum gehen, weniger Tasten drücken zu müssen, sondern das ganze leichter wartbar zu machen und die Gelegenheit hier etwas falsch oder uneinheitlich zu machen zu entfernen. Wenn ich mittels Interface oder Oberklasse die Signatur schon vorgebe (wie z.B. bei Sir Rufo) erreiche ich das ja. Nur meiner Meinung nach für so klitzekleine Dinge wie in meinem Beispiel trotzdem etwas ... oversized.

In zwei Jahren hat sich das ganze zwar garantiert dermaßen aufgebläht dass ich weinend am Boden liege und jammere "Warum habe ich nicht gleich auf ihn gehört", aber trotzdem :spin:

[Furtbichler]

Zitat:

Zitat von BUG (Beitrag 1224660)

Das Problem war imho nicht...

Dummdidumm: Wie man vom Thema abweichen kann.. Hast Recht.
Aber falsch ist die Vorgehensweise trotzdem. So. ;-)

Bei VS bzw. Resharper geht das ganz einfach:

Code:

class MyNewClass : IMyMethod{}

ALT-Enter, Enter, fertig (Refactoring "Implement Methods" wird ausgeführt). Gibts da was für Delphi?

Zitat:

Zitat von Der schöne Günther (Beitrag 1224662)

Nur meiner Meinung nach für so klitzekleine Dinge wie in meinem Beispiel trotzdem etwas ... oversized.

Falsche Meinung. :mrgreen:

Gewöhne Dir das einfach an. Factories sind soooo praktisch und dir wird alle Nase lang etwas über den Weg laufen, wo Du anhand eines Tokens (String, Enum, sonstewas) eine Methode aufrufen musst.

[BUG]

Zitat:

Zitat von NamenLozer (Beitrag 1224661)

Wenn dann würde sich vielleicht eher dieses Pattern anbieten, wo man statt die Parameter einzeln zu übergeben, ein einziges Objekt übergibt, das alle Parameter beinhaltet...

Natürlich ... und da es sich anscheinend um Netzwerkpaketen handelt, könnte so eine Klasse/Record eventuell sogar schon existieren :mrgreen:

[Der schöne Günther]

Zitat:

Zitat von Furtbichler (Beitrag 1224665)

Gibts da was für Delphi?

Interfaces in Delphi habe ich mir immer noch nicht angeschaut, aber ich meine Vorgaben vom zu implementierenden Interface auf Methoden von aggregierten Objekten delegieren.

Zitat:

Zitat von Furtbichler (Beitrag 1224665)

Falsche Meinung. :mrgreen: Gewöhne Dir das einfach an.

Ich versuchs. Später rächt sich das immer :oops:

[jaenicke]

Zitat:

Zitat von Furtbichler (Beitrag 1224665)

Bei VS bzw. Resharper geht das ganz einfach:

Code:

class MyNewClass : IMyMethod{}

ALT-Enter, Enter, fertig (Refactoring "Implement Methods" wird ausgeführt). Gibts da was für Delphi?

Nicht für Delphi, sondern direkt schon in Delphi drin:
Klassendeklaration hinschreiben inkl. end, vor dem end bleiben, Strg + Leertaste, zu implementierende Methoden des Interfaces aus der Liste auswählen, Enter (jetzt stehen sie da inkl. public), Strg + Shift + C, fertig. ;-)

[Sir Rufo]

@jaenicke :thumb:

Obwohl mich das

Delphi-Quellcode:

public

eher stört, das verleitet einige statt dem Interface, die Klassen-Instanz zu benutzen.

Also definiere ich die Klassen entweder im

Delphi-Quellcode:

implementation

-Abschnitt (Zugriff dann über eine Factory) oder deklariere diese Methoden als

Delphi-Quellcode:

protected

.

[sx2008]

Mit geschachtelten Funktionen lässt sich das "Problem" lösen:

Delphi-Quellcode:

procedure AllInOneHandler(input1: Integer; input2: TSomeClass; out output: Double);

  procedure proc1;  // hat Zugriff auf die Parameter der äusseren Funktion oder Methode
  begin
  end;
 
  procedure proc2;  // so was von dry - dryer geht's nicht
  begin
  end;

begin
  if ankommendesPaket.commandStr = 'zooBesuch' then
    proc1
  else if ankommendesPaket.commandStr = 'zirkusBesuch' then
    proc2
  else
    ...
end;

[jaenicke]

Zitat:

Zitat von Sir Rufo (Beitrag 1224682)

Obwohl mich das

Delphi-Quellcode:

public

eher stört, das verleitet einige statt dem Interface, die Klassen-Instanz zu benutzen.

Wenn sie denn verfügbar wäre. Bei den Interfaces, die ich im Moment implementiere, ist in der Schnittstelle nach außen nur das Interface verfügbar.
Das Interface deklarierst du ja hoffentlich nicht in der selben Unit wie das Objekt, oder?
Wer dann die Unit mit dem Objekt extra nimmt, ist selbst schuld...

Nebenbei kann man bei XE4 anders als früher auch problemlos den Interface-Zeiger wieder auf die Objektinstanz casten (mit as).

Auch noch nebenbei: Das Überschreiben von Elternmethoden funktioniert analog inkl. override dahinter. ;-)

Das public wieder zu entfernen ist jedenfalls deutlich weniger Arbeit als alles manuell zu kopieren usw. ;-)

[Furtbichler]

Zitat:

Zitat von jaenicke (Beitrag 1224673)

Nicht für Delphi, sondern direkt schon in Delphi drin:...

Na dann hätten wir ja das Problem

Zitat:

Zitat von NamenLozer (Beitrag 1224661)

...Ändert allerdings auch nichts daran, dass man die Parameterdeklaration bei jeder Methode wieder hinschreiben muss.

gelöst hätten.

Interface-Methoden sollten public sein, schließlich verwendet man sie ja 'öffentlich', auch wenn die Klasse an sich nicht verfügbar sein sollte.

[jaenicke]

Zitat:

Zitat von Furtbichler (Beitrag 1224693)

Interface-Methoden sollten public sein, schließlich verwendet man sie ja 'öffentlich', auch wenn die Klasse an sich nicht verfügbar sein sollte.

Ich schreibe die immer unter protected um zu verhindern, dass man aus Versehen die Klasse als Klasse nutzt, wenn man diese noch nicht kennt.