Wie lang sind eure Delphi Quellen?

[Florian Hämmerle]

Zitat von mquadrat:

Ich probier nicht über die 2000 / 3000 Zeilen zu kommen. Bei manchen Klassen lässt es sich aber nicht verhindern. Allein Properties und Getter und Setter erzeugen ja haufenweise Zeilen. Delphi ist nun mal nicht die kompakteste Sprache.

Naja, für Getter und Setter benötigst du aber eigentlich immer zwei Methoden, egal in welcher Sprache
-> Funktionskopf + begin + Anweisungen + end; brauchen eben mal mindestens 4 Zeilen wenn man es standardmäßig formatiert

[Namenloser]

Zitat von Assarbad:

Apropos: bei den riesigen Units ist noch keiner auf die Idee gekommen es zumindest in Include-Dateien auszulagern?

Ich finde, mit Include-Dateien verliert man imo eher Übersicht. Wenn man tatsächlich seinen Code in mehrere Units trennt, gewinnt man Übersicht, da man seinen Code modularisieren muss (sonst gibts zirkuläre Abhängigkeiten und der Compiler meckert). Includes sinnvoll einzusetzen ist in Delphi hingegen schwierig, da man ja zwangsläufig oben den interface- und unten den implementation-Teil hat, sodass man immer mindestens zwei Dateien anpassen muss, wenn man eine Sache ändert. Da fährt man mit einer großen Datei besser, zumal die sich die Navigation innerhalb einer Unit dank IDE ja leicht gestaltet.

[himitsu]

Zitat von Assarbad:

Apropos: bei den riesigen Units ist noch keiner auf die Idee gekommen es zumindest in Include-Dateien auszulagern?

Wie schon erwähnt ... ICH ... nur hatte es sich (zumindestens damals in Delphi 7) nicht als optimal erwiesen.

- Der Debugger und vorallem der Compiler kamm nicht wirklich damit klar, bzw. man wußte nicht immer wo man sich grade befindet, bzw. wo sich nun wirklich der gemeldete Compilerfehler befindet.

[Bummi]

Zitat:

Apropos: bei den riesigen Units ist noch keiner auf die Idee gekommen es zumindest in Include-Dateien auszulagern?

ich habe es eine Zeit lang gemacht, allerdings waren die Kollegen die den Code später weiterverwenden sollten nicht sehr angetan....

[implementation]

[OT]

Zitat von Florian Hämmerle:

Zitat von mquadrat:

Ich probier nicht über die 2000 / 3000 Zeilen zu kommen. Bei manchen Klassen lässt es sich aber nicht verhindern. Allein Properties und Getter und Setter erzeugen ja haufenweise Zeilen. Delphi ist nun mal nicht die kompakteste Sprache.

Naja, für Getter und Setter benötigst du aber eigentlich immer zwei Methoden, egal in welcher Sprache
-> Funktionskopf + begin + Anweisungen + end; brauchen eben mal mindestens 4 Zeilen wenn man es standardmäßig formatiert

Vergleichen wir mal Delphi und C#:

Delphi-Quellcode:

type
  TKlasse = class(TObject)
  protected
    FX: Integer;
    procedure SetX(const aX: Integer);
    function GetX: Integer;
  public
    property X: Integer read GetX write SetX;
  end;

procedure TKlasse.SetX(const aX: Integer);
begin
  FX := aX;
end;

function TKlasse.GetX: Integer;
begin
  Result := FX;
end;

Code:

class Klasse
{
  protected int x;
  public int X
  {
    get { return x; }
    set { x = value; }
  }
}

Schon ein Unterschied, oder?
(ohne jetzt Werbung für C# machen zu wollen ...)
[/OT]

[mleyen]

Delphi-Quellcode:

TKlasse = class(TObject)
protected
  FX: Integer;
public
  property X: Integer read FX write FX;
end;

Und include-files versuch ich auch zu vermeiden wo es nur geht, die Unitgröße wird dadurch eig auch nicht kleiner.

[mquadrat]

Ohne Getter und Setter ist das keine Kunst kürzer zu werden.

[mleyen]

Das sind getter/setter, außer das der compiler direkt auf die Variable zugreift.
Der Abstraktionsgrad bleibt erhalten und man kann immer ein get()/set() draus machen, falls es mal notwendig wird.

Aber ich such schon ewig nach einer sinnvollen Situation für ein get(). Hast du eine für mich?

[mquadrat]

Zum Beispiel Lazy Loading von Objekten. Oder berechnete Properties, die gar keine Member-Variable haben. Oder Properties von Decorator-Klassen.

Aber stimmt schon, solange man kein Get() braucht muss man es auch nicht hinschreiben.

[himitsu]

Diese Codeschlangenbildung vom C kann man in Delphi auch machen und schon wird es ebenfalls kürzer.

Delphi-Quellcode:

type
  TKlasse = class(TObject)
  protected
    var FX: Integer;  procedure SetX(const aX: Integer);  function GetX: Integer;
    var FY: Integer;  procedure SetY(const aY: Integer);  function GetY: Integer;
  public
    property X: Integer read GetX write SetX;
    property Y: Integer read GetY write SetY;
  end;

procedure TKlasse.SetX(const aX: Integer);  begin  FX := aX;  end;
function  TKlasse.GetX: Integer;            begin  Result := FX;  end; 
procedure TKlasse.SetY(const aX: Integer);  begin  FY := aY;  end;
function  TKlasse.GetY: Integer;            begin  Result := FY;  end;

und wenn man dagegen C# mal einrückt, dann sieht das gleich ganz anders aus

Code:

class Klasse
{
  protected 
    int x, y;
  public
    int X
    {
      get 
      { 
        return x; 
      }
      set 
      { 
        x = value; 
      }
    }
    int Y
    {
      get 
      { 
        return y; 
      }
      set 
      { 
        y = value; 
      }
    }
}

Abgesehn davon, daß ich diese casesensitive Namensbehandlung nicht wirklich als gut leserlich empfinde.