2. Grundlagen der Programmierung mit Delphi  2.1. Die Delphi-Entwicklungsumgebung  2.2. Das Prinzip der ereignisgesteuerten Programmierung  2.3. Schrittfolge zur Programmerstellung mit Delphi  2.4. Projektverwaltung unter Delphi          2.4.1. Beispiel für die Dateistruktur eines Projektes          2.4.2. Dateien, die in der Entwicklungsphase erzeugt werden          2.4.3. Vom Compiler erzeugte Projektdateien          2.4.4. Empfohlene Vorgehensweise im Unterricht - Projektsicherungsprogramm  2.5. Struktur einer Unit

2.1. Die Delphi-Entwicklungsumgebung

Nach dem Start von Delphi werden verschiedene Fenster geöffnet, die für die visuelle Programmierarbeit notwendig sind. Diese Arbeitsfläche wird als Integrierte Entwicklungsumgebung, kurz IDE (engl. Integratet Development Enviroment) bezeichnet. Alle Fenster der IDE können frei und einzeln auf dem Bildschirm positioniert oder geschlossen werden. Durch das Schließen des Hauptfensters wird Delphi beendet.

Die nachstehende Tabelle gibt einen einführenden Überblick zu Erscheinungsbild und Funktion der wichtigsten Bestandteile der Delphi-Entwicklungsumgebung:
 

Das Formular stellt das zentrale Entwicklungsobjekt eines Delphi-Programms dar. Auf ihm werden die gewünschten Komponenten wie Schaltflächen, Menüs und Eingabefelder per Mausklick platziert und größenmäßig angepasst. Das Erscheinungsbild des Formulars entspricht dem Aussehen des Windows-Fensters, in dem das fertige Programm später ablaufen wird.  Die Komponentenpalette ist in verschiedene Register (Standard, Zusätzlich usw.) unterteilt, und diese erlauben die Auswahl der benötigten Windows-Komponenten. Mit Hilfe des Objektinspektors werden Darstellungsweise und Verhalten der Objekte (Komponenten) in einem Formular sowie das Aussehen des Formulars selbst festgelegt. Das Erscheinungsbild wird über die Seite "Eigenschaften", das Verhalten beim Eintritt eines Ereignisses über die Seite "Ereignisse" eingestellt. Der Quelltexteditor wird zum Schreiben des Programmcodes in der Programmiersprache Pascal genutzt. Dabei generiert Delphi für neu in das Formular eingefügte Komponenten automatisch den Programmcode, der dann im Editor angezeigt wird. Dem Programmierer obliegt daher "nur noch" die Einarbeitung der Algorithmen zur Ereignisbehandlung.

Seitenanfang

2.2. Das Prinzip der ereignisgesteuerten Programmierung

Die Programmierung mit Delphi wird auch als ereignisgesteuerte Programmierung bezeichnet. Ein Ereignis ist eine Aktion, die den Programmablauf beeinflusst.

Was sind Ereignisse?

Alle Aktionen (Tastatureingaben, Mausbewegungen) eines Benutzers, wie zum Beispiel:

• Einfaches oder doppeltes Klicken auf eine Befehlsschaltfläche,
• Verschieben, Öffnen oder Schließen eines Fensters mit der Maus,
• Positionieren des Cursors in ein Eingabefeld mit der Tabulatortaste.
Interne Programmabläufe, wie zum Beispiel:
 
• Berechnungen durchführen,
• Öffnen und Schließen eines Fensters (vom Programm gesteuert),
• Ermitteln von aktueller Uhrzeit und Datum.

Mit Delphi werden Programme entwickelt, die durch die grafische Benutzeroberfläche von Windows mit Steuerelementen wie beispielsweise Dialogfenstern, Schaltflächen und Eingabefeldern gesteuert werden.

Durch ein Ereignis (z.B. Klicken auf eine Schaltfläche) wird eine Reaktion (z.B. Öffnen eines Fensters) hervorgerufen. Diese Reaktion wird in Form von Object-Pascal-Code in einer Prozedur erstellt, die als Ereignisbehandlungsroutine bezeichnet wird.

 2.3. Schrittfolge zur Programmerstellung mit Delphi

Die nachfolgende Tabelle soll aufzeigen, wie sich der "klassische" Software-live-cycle unter den Gegebenheiten einer visuellen Programmierumgebung erweitert bzw. modifiziert. Dabei darf man sich den Durchlauf der einzelnen Schritte keinesfalls als einmalige lineare Abfolge vorstellen, vielmehr entstehen durch Rücksprünge und das mehrmalige Durchlaufen von Teilen der Schrittfolge zyklische Strukturen. Werden z.B. bei der Resultatsprüfung unter Punkt 5) Fehler festgestellt, muss wieder bei Punkt 2A) begonnen werden, indem man logische Fehler im Algorithmus beseitigt.

Und schließlich kann auch die gesamte Schrittfolge als zyklische Struktur begriffen werden: kaum ist die Version 1.0 eines Programms ausgeliefert, werden bisher unerkannte "Bugs" entdeckt und Wünsche zur Erweiterung der Funktionalität des Programms laut - also neue Problemformulierung, Problemanalyse, ... und schon existiert die Version 1.1 usw.
 

1) Problemformulierung
"Es ist ein Programm zu erstellen, das folgendes leistet: ... "  So oder so ähnlich beginnt die Formulierung dessen, was das Programm im ganzen realisieren soll. Man wird mehr oder weniger klare Vorstellung zu notwendigen Eingabewerten, zum Erscheinungsbild des Programms, zur Art der Ergebnisausgabe, zum potentiellen Nutzerprofil etc. vorfinden. Die nachfolgenden beiden Schritte verlaufen im Prinzip parallel - die Programmierhandlung springt zwischen algorithmischer und visueller Seite hin und her, weil der algorithmische Aufbau des Programms bestimmte Komponenten einer Nutzeroberfläche bedingt bzw. die gewünschte Oberflächenstruktur Einfluss auf die Modularisierung der Lösungsalgorithmen haben kann.
2A) Algorithmischer Problemlösungsprozeß                 - Algorithmische Seite -	2V) Benutzeroberfläche erstellen und         Eigenschaften der Objekte festlegen                      - Visuelle Seite -
I) Problemanalyse Das Gesamtproblem wird in überschaubare Teilprobleme zerlegt - Modularisierung und Modellierung der Problemsituation. II) Entwurf von Lösungsalgorithmen für die Teilprobleme Die Lösungswege dazu werden zunächst in abstrakter Weise beschrieben. Je nach Komplexität kann dies in verbaler Form geschehen (Eindeutigkeit!) oder es kommen grafische Beschreibungsformen, z.B. Struktogramme oder Programmablaufpläne zum Einsatz.  Es wird noch nicht mit konkreter Programmiersprache gearbeitet. III) Synthese der Teillösungen  Nunmehr werden die entwickelten Teillösungen zur Gesamtlösung verknüpft und notwendige E/A-Funktionen zwischen den einzelnen Modulen festgelegt.	Mit zunehmenden Voranschreiten im algorithmischen Problemlösungsprozeß wächst auch die Vorstellung über Beschaffenheit und Funktionalität der Benutzeroberfläche.  Erstellt wird diese durch Anordnung aller notwendigen Komponenten (Textfelder, Optionsfelder, Eingabefelder, Schalter usw.) auf dem Formular.  Die Auswahl der Komponenten erfolgt über die Komponentenpalette. Dabei werden mit Hilfe des Objektinspektors die Eigenschaften der Komponenten festgelegt, z.B. Größe, Farbe, Bezeichnung der Schaltflächen, Text- und Eingabefelder. Spätestens an dieser Stelle sollte das Projekt erstmals gespeichert werden!
4) Ereignisbehandlung codieren       - "Hochzeit" von Algorithmus und Programmoberfläche -
Zunächst werden über den Objektinspektor diejenigen Ereignisse ausgewählt, die für den späteren Programmablauf von Bedeutung sein werden (z.B. Klicken eines Schalters). In einer zugehörigen Ereignisbehandlungsroutine wird dann im Quelltexteditor in der Programmiersprache Pascal beschrieben, wie die jeweiligen Komponenten auf das betreffende Ereignis reagieren sollen. Dabei werden also die unter 3A) gefundenen Lösungsalgorithmen in Programmiersprache "übersetzt" und die Ergebnisausgabe wiederum über Komponenten realisiert.
5) Test-Korrektur-Durchläufe
I) Syntaxprüfung: Vorm ersten Start sollte unbedingt die syntaktische Korrektheit der eingegebenen Pascal-Anweisungen getestet und ggf. korrigiert werden. Anschließend wird das Projekt erneut gespeichert! II) Resultatsprüfung: Das syntaktisch korrekte Programm wird nun compiliert und gestartet. Um die Richtigkeit seiner Resultate hinreichend abzusichern, muss es mit verschiedenen Beispieleingaben getestet werden. Treten während des Tests Fehler auf, sind die oben genannten Schritte zu wiederholen.
6) Sicherung der Dateien, Dokumentation und Nutzung des Programms
In einem eigens dafür angelegten Verzeichnis (z.B. auf Diskette) werden abschließend alle für eine spätere Weiterbearbeitung des Programmprojektes nötigen Dateien gesichert.  Die beim Compilieren entstandene Programmdatei kann nunmehr unabhängig von Delphi unter Windows genutzt werden.

Seitenanfang

  2.4. Projektverwaltung unter Delphi

Ein Delphi-Projekt ist eine Sammlung aller Dateien, die zusammen eine Delphi-Anwendung auf dem Entwicklungssystem ergeben. Einige dieser Dateien werden im Entwurfsmodus erzeugt, andere werden bei der Compilierung des Projekt-Quelltextes angelegt. 

2.4.1. Beispiel für die Dateistruktur eines Projektes

Ein Delphi-Projekt namens Projekt1 bestehe aus zwei Formularen: (Dateien sind zur Erläuterung anklickbar) 

2.4.2. Dateien, die in der Entwicklungsphase erzeugt werden:

 

Dateinamen- erweiterung	Definition	Zweck / Bemerkungen
.DPR	Projektdatei	Pascal-Quelltext für die Hauptprogrammdatei des Projektes, enthält den Standardnamen des Projektes, verzeichnet alle Formular- und Unit-Dateien im Projekt und enthält den Initialisierungscode wird von Delphi verwaltet und sollte nicht manuell verändert werden!
.DFM	Grafische Formulardatei	Quelltext, der die Entwurfseigenschaften eines Formulars des Projekts enthält, für jedes projektzugehörige Formular wird beim ersten Speichern des Projekts eine .DFM Datei zugleich mit der entsprechenden .PAS Datei angelegt. Datei selbst wird von Delphi verwaltet während die Entwurfseigenschaften des Formulars vom Programmierer über den Objektinspektor eingestellt werden!
.PAS	Unit-Quelltext (in Pascal)	wichtigste Bausteine für den Programmablauf! Für jedes Formular wird automatisch eine zugehörige Unit erzeugt, die alle Deklarationen und Prozeduren (Methoden) für die vom Formular auslösbaren Ereignisse enthält. nur in diese Dateien wird vom Programmierer der eigentliche Programmquelltext geschrieben!
.RES	Compiler- Ressourcendatei	Binärdatei für vom Projekt zu verwendende äußere Ressourcen wird von Delphi verwaltet

Zur Datensicherung bzw. zur Speicherung von Systemeinstellungen erzeugt Delphi noch weitere Dateiarten, die hier nicht aufgeführt sind.

Um ein Projekt jedoch zwecks späterer Weiterbearbeitung zu sichern, genügt es (für den Einsteiger), alle zum Projekt gehörenden Dateien mit den oben aufgeführten Erweiterungen zu sichern.

2.4.3. Vom Compiler erzeugte Projektdateien:

 

Dateinamen- erweiterung	Definition	Zweck / Bemerkungen
.DCU	Unit-Objekt-Code	während der Compilierung wird automatisch aus jeder .PAS-Datei und der zugehörigen .DFM-Datei eine entsprechende .DCU Datei erzeugt, die alle Eigenschaften und Methoden eines Formulars im Binärcode enthält.
.EXE	Compilierte ausführbare Programmdatei	vertriebsfähige Programmdatei, die alle für das Programm nötigen .DCU-Dateien enthält.

Soll also das fertige Delphi-Programm auf andere Rechner übertragen werden, genügt es, die entsprechende .EXE Datei dorthin zu kopieren. Dabei müssen diese Rechner natürlich unter Windows laufen und die nötigen Delphi-Ressourcen besitzen.

2.4.4. Empfohlene Vorgehensweise im Unterricht:

Das nachfolgende Szenario geht davon aus, dass der Unterricht in einem vernetzten Computerkabinett durchgeführt wird, wobei jedem Schüler ein temporär gemapptes Serverlaufwerk (bei uns L:) zum Lesen und Schreiben zur Verfügung steht. Auf diesem Laufwerk werden zur Entwicklungszeit alle zum Delphi-Projekt gehörenden Dateien geführt.

Zum Unterrichtsende speichern die Schüler alle Projektdateien dauerhaft auf Diskette, und falls in der folgenden Stunde am Projekt weiter gearbeitet werden soll, werden die notwendigen Dateien wiederum von A: nach L: kopiert.
Ein ausschließliches Arbeiten mit Disketten hat sich als wenig praktikabel erwiesen, da das Compilieren dann jedes Mal unangenehm lange dauert und durch das dauerhafte Ablegen der relativ großen EXE-Dateien die Disketten schon nach wenigen Projekten voll sind.

Um die Speicherung auf die wirklich notwendigen Projektdateien zu begrenzen, wurde (übrigens auch unter Delphi!) ein einfaches Projektsicherungsprogramm namens projsave.exe entwickelt und steht hier zum Download bereit. Eventuelle Nutzer müssten natürlich das beschriebene Szenario den Gegebenheiten in ihrem Kabinett anpassen ;-)
Wer das Programm modifizieren oder verbessern möchte, kann sich auch die Quelltexte im Zip-Format herunter laden - Mail an mich wäre nett!

Für das derzeitige Netzwerk des Lessing-Gymnasiums Plauen sieht das ganze dann so aus:

 

Man lege sich auf Diskette im Laufwerk A: eine geeignete Verzeichnisstruktur an!  Ein neu zu erstellendes Projekt wird während seiner Bearbeitung auf Laufwerk L: (Server) zwischengespeichert. Nachdem Delphi beendet ist, verwende man das Programm „PROJSAVE.EXE“ und stelle als Quelle L: und als Ziel ein freies Verzeichnis auf A: ein (z.B. A:\delphi\proj02).  Das Sicherungsprogramm ist so konzipiert, dass es nur die für eine spätere Weiterbearbeitung wirklich notwendigen Dateien auf A: kopiert und damit sparsam mit dem Speicherplatz der Diskette umgeht. Der gesamte Inhalt des (temporären!) Laufwerks L: wird in dem Moment automatisch gelöscht, da der Schüler sich vom Server abmeldet. Nicht gesicherte Dateien sind spätestens dann unweigerlich verloren!  Soll zu einem späteren Zeitpunkt das Projekt weiterbearbeitet werden, sorge man zunächst dafür, dass Laufwerk L: von evtl. vorhandenen Delphi-Dateien aus anderen Projekten bereinigt wird (über „PROJSAVE.EXE“ möglich). Danach kopiere man sich über das Sicherungsprogramm die zu bearbeitenden Delphi-Dateien von A: nach L:, und nachdem Delphi gestartet wurde, kann deren Bearbeitung weitergehen.

Seitenanfang

2.5. Struktur einer Unit unter Delphi

Die nachfolgend aufgelistete Unit bezieht sich auf das abgebildete einfache Formular - Addition zweier Zahlen.
Bemerkenswert (und beruhigend!) ist die Tatsache, dass alle in der Unit schwarz geschriebenen Zeilen während der visuellen Formularerstellung automatisch von Delphi erzeugt werden.
Nur die wenigen rot gekennzeichneten Zeilen der Prozedur zur Realisierung der Addition sind wirklich vom Programmierer zu tippen.
Dies untersetzt die eingangs getroffene Feststellung, dass auch Programmier-Einsteiger ohne nennenswerte Vorkenntnisse unter Delphi schnell zu "greifbaren" Ergebnissen - sprich ablauffähigen Programmen - gelangen und einfache Algorithmen implementieren können. Es erscheint daher sinnvoll, erst nach einigen Projektübungen zum praktischen Teil der Programmierung die Lernenden sukzessive mit der Struktur einer Unit und der Funktion ihrer Bestandteile vertraut zu machen.