Alles in allem habe ich jetzt mit Buttons, PupupMenüs und nem StringGrid über 30 Methoden.
Da verliere ich leider so langsam den Überblick.
Was macht ihr, um euren Code übersichtlicher zu gestallten?
Abgesehen von den bereits genannten wertvollen Hinweisen, wie man seinen Code übersichtlich gestaltet (Trennung
GUI und Verwaltung, verstärkt Klassen einsetzen, Code auf mehrere Units aufteilen usw.) bin ich inzwischen weitgehend dazu übergegangen, mit Frames zu arbeiten statt z.B. mit PageControls oder zahlreichen Formularen. Frames werden im Hauptfenster angezeigt und enthalten die
GUI sowie, je nach Umfang, auch einiges an Berechnungs- und Verwaltungskram. Bei Datenbank-Anwendungen setzt man Datenmodule ein, die die Verbindungs-Komponenten aufnehmen und die gesamten Datenbank-Methoden enthalten.
Auch eine Sortierung der Variablen und Methoden entgegen der von Delphi beim Implementieren gewählten Stelle kann hilfreich sein. So sortiere ich z.B. die Komponenten-Variablen stets entsprechend dem
GUI-Aufbau:
Delphi-Quellcode:
UNIT UnitMain;
INTERFACE
USES
Windows, Messages,
...;
TYPE
TFormMain =
CLASS(TForm)
StatBar : TJvStatusBar;
Panel_Main : TPanel;
Panel_Navi : TPanel;
TrBt_Append : TJvTransparentButton;
TrBt_Delete : TJvTransparentButton;
TrBt_Edit : TJvTransparentButton;
TrBt_Post : TJvTransparentButton;
TrBt_Cancel : TJvTransparentButton;
AktionsListe : TActionList;
AL_DB_Close : TAction;
AL_ED_Append : TAction;
AL_ED_Delete : TAction;
AL_ED_Edit : TAction;
AL_ED_Post : TAction;
AL_ED_Cancel : TAction;
AL_WN_Zentrale : TAction;
HauptMenu : TMainMenu;
HM_DB : TMenuItem;
HM_DB_Close : TMenuItem;
HM_ED : TMenuItem;
HM_ED_Append : TMenuItem;
HM_ED_Delete : TMenuItem;
HM_ED_Edit : TMenuItem;
HM_ED_Post : TMenuItem;
HM_ED_Cancel : TMenuItem;
HM_TO : TMenuItem;
HM_WN : TMenuItem;
HM_WN_Zentrale : TMenuItem;
HM_WN_Video : TMenuItem;
HM_WN_VideoAkt : TMenuItem;
HM_WN_Personen : TMenuItem;
HM_WN_PersAkt : TMenuItem;
HM_WN_FSK : TMenuItem;
Procedure FormCreate(Sender : TObject);
Procedure FormShow(Sender : TObject);
Procedure FormActivate(Sender : TObject);
Procedure FormCloseQuery(Sender : TObject;
var CanClose: Boolean);
Procedure FormClose(Sender : TObject;
var Action: TCloseAction);
Procedure FormDestroy(Sender : TObject);
Procedure AL_DB_CloseExecute(Sender : TObject);
Procedure AL_ED_AppendExecute(Sender : TObject);
Procedure AL_ED_DeleteExecute(Sender : TObject);
Procedure AL_ED_EditExecute(Sender : TObject);
Procedure AL_ED_PostExecute(Sender : TObject);
Procedure AL_ED_CancelExecute(Sender : TObject);
Procedure AL_WN_ZentraleExecute(Sender : TObject);
Das sind alle Komponenten auf meiner Mainform, und dennoch ist das Programm insgesamt äußerst umfangreich (mehr als 800.000 Zeilen). Alles andere liegt in Frames oder im Datenmodul. Damit bleibt das hier ziemlich übersichtlich.
Private Methoden ordne ich ebenfalls so an, daß ich sie leicht wiederfinde, auch wenn ich gerade mal nicht wissen sollte, wie die Methode genau heißt. Im Implementation-Teil kommen immer zuerst die privaten Methoden in derselben Reihefolge, wie sie im PRIVATE-Abschnitt stehen:
Delphi-Quellcode:
PRIVATE { Private-Deklarationen }
Procedure StatusBarAktuell;
Procedure EinstellungenLesen;
Procedure EinstellungenSchreiben;
...
PUBLIC { Public-Deklarationen }
END;
VAR
FormMain : TFormMain;
IMPLEMENTATION
{$R *.dfm}
{ TFormMain }
Uses
UnitData, GLD, DatBankEdit, Fram_Main, ...;
Var
DBE : TDatBankEdit;
...
// ##### PRIVATE METHODEN ###############################################################################################################
// ---------- Statusbar aktualisieren -------------------------------------------------------------------------------------------- Privat
Procedure TFormMain.StatusBarAktuell;
begin
...
Public-Methoden habe ich in meinen Mainforms keine, da letztgenannte niemals von anderen Units referenziert werden. Am Ende stehen dann die Ereignis-Behandlungen, und zwar ebenfalls in einer mir sinnvoll erscheinenden Reihenfolge:
Delphi-Quellcode:
// ##### EREIGNISSE #####################################################################################################################
// ---------- On Create ------------------------------------------------------------------------------------------------------ Ereignisse
Procedure TFormMain.FormCreate(Sender: TObject);
begin
...
end;
// ---------- On Show -------------------------------------------------------------------------------------------------------- Ereignisse
Procedure TFormMain.FormShow(Sender: TObject);
begin
...
end;
// ---------- On Activate ---------------------------------------------------------------------------------------------------- Ereignisse
Procedure TFormMain.FormActivate(Sender: TObject);
begin
...
end;
// ---------- On Close Query ------------------------------------------------------------------------------------------------- Ereignisse
Procedure TFormMain.FormCloseQuery(Sender: TObject;
Var CanClose: Boolean);
begin
...
end;
// ---------- On Close ------------------------------------------------------------------------------------------------------- Ereignisse
Procedure TFormMain.FormClose(Sender: TObject;
Var Action: TCloseAction);
begin
...
end;
// ---------- On Destroy ----------------------------------------------------------------------------------------------------- Ereignisse
Procedure TFormMain.FormDestroy(Sender: TObject);
begin
...
end;
// ---------- Programm beenden ----------------------------------------------------------------------------------------------- Ereignisse
Procedure TFormMain.AL_DB_CloseExecute(Sender: TObject);
begin
Close;
end;
// ---------- Append --------------------------------------------------------------------------------------------------------- Ereignisse
Procedure TFormMain.AL_ED_AppendExecute(Sender: TObject);
...
Um gleich erkennen zu können, wo genau ich mich befinde, habe ich mir angewöhnt, ausnahmslos jeder Function und Procedure einen Kommentar-Header zu verpassen, der mir auf Anhieb zeigt, was die Methode macht und wo sie steht (z.B. Private oder Ereignisse). Auch die Ereignisse ordne ich so, daß oben die Start- und Ende-Ereignisse stehen, danach Reaktionen auf Komponenten-Ereignisse (hier nur ActionList-Ereignisse). Mit dieser Art & Weise, meinen Quellcode zu gestalten, komme ich seit Jahren ausgezeichnet zurecht.
Natürlich schreibe ich die ganzen Kommentarzeilen nicht bei jedem Projekt oder bei jeder
Unit neu, sondern habe mir dafür ein Default-Projekt angelegt, das natürlich noch viel mehr grundlegende Sachen enthält, die ich aus meiner Erfahrung heraus in jedem Projekt benötige.