Interface-Unterstützung

[stahli]

Hi,

auch wenn mein Ansatz nicht so auf allgemeine Begeisterung stößt will ich mal etwas grundsätzliches fragen:

Welche Ordnung würdet Ihr innerhalb einer Interface- und Klassendeklaration bevorzugen?
Mein Tool soll ja einiges automatisieren. Jetzt stellt sich die Frage, wie es da heran gehen sollte.
Unabhängig davon, dass man natürlich (falls es doch mal Interesse gibt) auch Optionen anbieten sollte, möchte ich mal Eure Meinungen dazu anfragen.

Im Interface werden bei Properties die Getter und Setter ergänzt.
Ich würde diese jeweils unmittelbar vor den Properties einfügen in der Reihenfolge
Getter (wenn nötig), Setter (wenn nötig), Property.
Macht Ihr das anders?
Sollte vor dem Block noch eine Leerzeile zur besseren Übersichtlichkeit eingefügt werden?

Bei den Klassen habe ich verschiedene Ideen.

Class1:
Man könnte alles (klasseneigene und Interface-Member) zusammen in die normalen Sektionen (private, protected und public) schreiben.

Class2:
Oder man erzeugt eigene Sektionen (private, protected und public) pro Interface und beschriftet diese (mit einem Kommentar).

Class3:
Wie Class2 aber die Interface-Sektionen kommen alle zum Schluss.

Class4:
Alle Interface-Member kommen einfach in eine beschriftete public-Sektion.

Im letzten Beispiel habe ich ich auch mal eine eigene Sektion vorgesehen, in die alle Getter und Setter kommen könnten (entweder nur die von der Klasse selbst oder auch alle Getter und Setter, die zu den Interfaces gehören).


Zu entscheiden wäre auch, ob private Felder sowie Getter und Setter jetzt eher in protected oder private sections gehören.
Das Tool soll bestehende Ordnungen NICHT durcheinander bringen aber ich müsste entscheiden, wie es mit automatischen Ergänzungen umgehen soll.
Was sind da Eure Ideen und Meinungen?

Delphi-Quellcode:

interface

IIntf1 = interface 
  procedure Proc(Param: String);
  function Func(var Param: Integer): Boolean; 

  function Getter1: string; 
  procedure Setter1(aValue: string); 
  property Prop1: string read Getter1 write Setter1;

  function Getter2: string; 
  procedure Setter2(aValue: string); 
  property Prop2: string read Getter2 write Setter2;
end; 

TClass1 = class(TInterfacedObject, IIntf1) 
private 
  fNew: String;
  fProp1: string; 
  fProp2: string; 
protected
  function GetterNew: string; 
  procedure SetterNew(aValue: string); 
  function Getter1: string; 
  procedure Setter1(aValue: string); 
  function Getter2: string; 
  procedure Setter2(aValue: string); 
public 
  constructor Create; virtual; 
  destructor Destroy; override; 
  procedure New;
  procedure Proc(Param: String);
  function Func(var Param: Integer): Boolean; 
  property New: string read GetterNew write SetterNew;
  property Prop1: string read Getter1 write Setter1;
  property Prop2: string read Getter2 write Setter2;
end; 

TClass2 = class(TInterfacedObject, IIntf1) 
private 
  fNew: String;
private // IIntf1
  fProp1: string;
  fProp2: string; 
protected
  function GetterNew: string; 
  procedure SetterNew(aValue: string); 
protected // IIntf1
  function Getter1: string; 
  procedure Setter1(aValue: string); 
  function Getter2: string; 
  procedure Setter2(aValue: string); 
public 
  constructor Create; virtual; 
  destructor Destroy; override; 
  procedure New;
  property New: string read GetterNew write SetterNew;
public // IIntf1
  procedure Proc(Param: String);
  function Func(var Param: Integer): Boolean; 
  property Prop1: string read Getter1 write Setter1;
  property Prop2: string read Getter2 write Setter2;
end; 

TClass3 = class(TInterfacedObject, IIntf1) 
private 
  fNew: String;
protected
  function GetterNew: string; 
  procedure SetterNew(aValue: string); 
public 
  constructor Create; virtual; 
  destructor Destroy; override; 
  procedure New;
  property New: string read GetterNew write SetterNew;
private // IIntf1
  fProp1: string; 
  fProp2: string; 
protected // IIntf1
  function Getter1: string; 
  procedure Setter1(aValue: string); 
  function Getter2: string; 
  procedure Setter2(aValue: string); 
public // IIntf1
  procedure Proc(Param: String);
  function Func(var Param: Integer): Boolean; 
  property Prop1: string read Getter1 write Setter1;
  property Prop2: string read Getter2 write Setter2;
end; 

TClass4 = class(TInterfacedObject, IIntf1) 
private 
  fNew: String;
protected // Getter&Setter
  function GetterNew: string; 
  procedure SetterNew(aValue: string); 
public 
  constructor Create; virtual; 
  destructor Destroy; override; 
  procedure New;
  property New: string read GetterNew write SetterNew;
public // IIntf1
  fProp1: string; 
  fProp2: string; 
  function Getter1: string; 
  procedure Setter1(aValue: string); 
  function Getter2: string; 
  procedure Setter2(aValue: string); 
  procedure Proc(Param: String);
  function Func(var Param: Integer): Boolean; 
  property Prop1: string read Getter1 write Setter1;
  property Prop2: string read Getter2 write Setter2;
end; 

implementation 

...

end.