Methoden-Deklaration vorgeben?

[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 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 von Der schöne Günther:

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 von Perlsau:

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 von der schöne günther:

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.

[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 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

[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;

[Perlsau]

Zitat von uligerhardt:

Zitat von Perlsau:

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 ...