Programmteile auslagern in Units

[BrunoT]

Hi DP'ler

ich habe schon einige Funktionen und Prozeduren in Units ausgelagert und möchte das gerne noch weiter treiben, um den Quelltext lesbarer zu machen.
Bei diesen Funktionen war das noch relativ einfach, diese hatten recht wenig mit den Objekten des Hauptformulars zu tun, z.B.:

Delphi-Quellcode:

unit UAusgabe;

interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, dialogs;

procedure Linie(ziel: TCanvas; x1, y1, x2, y2, LinienBreite: INTEGER);
procedure Rechteck(ziel: TCanvas; x1, y1, x2, y2, LinienBreite: INTEGER);
function TextRotOut(Canvas: TCanvas;
  x, y: INTEGER;
  Angle: INTEGER;
  FontName: TFontName;
  FontSize: Byte;
  FontStyle: TFontStyles;
  TBreite: INTEGER;
  Laufweite: Single;
  Ausrichtung: Byte;
  s: string): INTEGER;

implementation
...

bei anderen Sachen ist das nicht so einfach, da ich entwerder die Ereignisse, Eigenschaften und Methoden der Objekte der Hauptform anspreche.

Hat da jemand mal ´nen Tip, wie man im Allgemeinen beim Auslagern in Units vorgeht und was dabei zu beachten ist?
Ich möchte aber auch riesige Parameterlisten vermeiden, so wie hier:

Delphi-Quellcode:

unit UFormular_init;

interface
uses
  Windows, Messages, SysUtils, Variants, Classes, UMyprog;

Function Fstandard(sJahr: string; var aF: aFormular; Anz_N, Anz_Kinder,Anz_KAP,Anz_SO,Anz_FW,Anz_Vermietung,Anz_Aus,Anz_AV:Byte):Byte;


implementation
...

eventuell hat da jemand mal ´nen Tut oder einen Literaturhinweis oder Tip.

mfg

BrunoT

[sniper_w]

Es geht am besten über die Parameter einer Funktion. Wenn es zu viel sein soll, dann lieber in ein RECORD packen und den Pointer übergeben.

[BrunoT]

Hi Sniper_w,

Das mit dem Record gefällt mir, auf das obige Beispiel bezogen. Wie die Übergabe als Pointer erfolgt, muss ich mir noch anschauen.

mfg

Im Weiteren muß ich mich wohl weiter mit Include- Dateien behelfen.

mfg

BrunoT

[sniper_w]

Mal angenommen:

Delphi-Quellcode:

type TMyRecord=record
//....
 MeineVars:integer;
//.....
end;

var
  MyVar:TMyRecord;

Wenn du jetzt übergebene Parameter ändern willst, dann sieht die Deklaration einer Funktion so aus:procedure MyFunc(VAR Param:TMyRecord); Wenn du es verhindern wills, dass die Funktion die übergebene Paramater ändert dann so:procedure MyFunc(CONST Param:TMyRecord); Und wenn es dir "egal" ist dann so:procedure MyFunc(Param:TMyRecord); Im letzten Beispiel werden alle Änderungen, die innerhalb von MyFunc stattgefunden sind (bezüglich Param Members) einfach ignoriert.Z.B.

Delphi-Quellcode:

procedure MyFunc(Params:TMyRecord);
begin
  Params.MeineVars := 1000;
end;

Diese zuweisung ist nur innerhalb der Funktion gültig. Wenn du es "weiter" gelten lassen willst, dann musst du die Funktion (wie schon gesagt) so deklarieren:procedure MyFunc(VAR Param:TMyRecord);

[shmia]

Wenn ich mir die Funktion
function Fstandard(sJahr: string; var aF: aFormular; Anz_N, Anz_Kinder,Anz_KAP,Anz_SO,Anz_FW,Anz_Vermietung,Anz_Aus,Anz_AV:Byte):Byte; anschaue, dann fallen mir 3 Dinge auf:
1.) Objekte, so auch Forms brauchen/sollten nicht über var Parameter übergeben werden

2.) Funktionen, die Forms benützen sind so nicht wirklich auslagerbar.
Man kann die Funktion also nicht einfach hernehmen und in einer X-beliebigen Anwendung einbringen
Die Funktion sollte dann eher eine Methode des Formulars sein.

3.) Die Funktion scheint mir komplexe statistische Berechnungen durchzuführen.
Standardabweichung oder sowas. Jetzt wäre es sinnvoll zuerst allgemeine Statistikfunktionen in eine
eigene Unit auszulagern.

[BrunoT]

Hi,

danke erstmal, ich werde mir die Programmlogik noch einmal verinnerlichen, um zu sehen, was man verallgemeinern kann, um es dann auszulagern. In dieser Beziehung hatte ich wohl 'ne Denkblockade. Mich stört, dass manche Prozeduren länger als eine Blidschirmseite sind(bis zu 3), da werde ich sehen, was sich als Subroutinen formulieren lässt(D7 hat noch kein Codefolding).
Wenn man da an eine bestimmte Stelle im Quelltext sucht, muss man ganz schön scrollen.

Die im Programm überall gültigen Variablen( z.B. aktJahr, AktX, AktY, LastX, LastY, AnzB, AnzB) werde ich in einem oder zwei Records zusammenfassen, damit komme ich dann auch ohne globale Variablen aus, da ich die Records leichter als Parameter übergeben kann.

@sniper_w : Wenn ich was als Pointer übergebe, muss da nicht nur die Addr(MyRecord) an die Prozedur übergeben(imho)? Mit Pointern habe ich noch nicht allzuviel gemacht muss ich gestehen, ich glaube aber gelesen zu haben, dass bei normaler Parameterübergabe eine Kopie des Parameters erstellt wird, was beim Pointer wegfällt.

@shima: also Methoden und Ereignisse kann man nicht auslagen (seufz). Ich habe davon ziemlich viele. Ich wollte nur nicht die Übersicht verlieren. Nicht das ich Ordnungsfanatiker bin, aber auf der Festpatte legt man auch Subdirectorys an um Dateien mit ähnlichen Eigenschaften zusammenzufassen. Ich werde also meine Baustellen an das Ende des Quelltextes verlegen.

mfg

BrunoT

P.S.:Ich habe nun GExperts installiert, das sollte helfen.

[Bernhard Geyer]

Ich kenn jetzt dein Programm nicht im Detail, aber evtl. ist nicht eine Komponente/Klasse das geeignetere "Auslagerungskonzept" zu reinen Funktionen/einem Record und Funktionen?

[sniper_w]

Die VAR Parameter werden von Compiler als Pointer behandelt und das ist noch eine feine Sache von Delphi -> Compilermagic.

[mschaefer]

Moin, moin,

also ich würde mir für Deine Funktionssammlung ein Object von TComponent ableiten und darin die gewünschten Funtkionen unterbringen. Wenn das Object auf das Formular gezogen wird, dann hat dies als "Parent" das Formular, sodass damit auch auf Formulardaten zugegriffen werden kann. Ohne Objekt ist das letzlich nicht durchgangig realsierbar.

Grüße // Martin

[shmia]

Zitat von sniper_w:

Die VAR Parameter werden von Compiler als Pointer behandelt und das ist noch eine feine Sache von Delphi -> Compilermagic.

Ja schon, aber nicht bei Objekten. Objekte sind in Delphi von Hause aus schon Zeigertypen.
Wenn man jetzt var tmp:TForm schreibt, hat man einen Zeiger auf einen Zeiger auf ein Objekt.