Umstieg von VFP nach Delphi (Teil 2)

Gegenstand ist der Serie ist kein Tutorial zur Sprache Pascal/Delphi. Vielmehr soll mit der Entwicklungsumgebung vertraut gemacht werden und einige bereits wesentliche Unterschiede zu VFP, aber auch Gemeinsamkeiten, aufgezeigt werden.

Der Grundaufbau eines Delphi-Programm zeigt natürlich auch Ähnlichkeiten zu einem VFP-Programm, aber unterscheidet sich natürlich auch in wesentlichen Punkten.

Ein erstes Projekt

Ein neues Projekt wird mit Datei – Neu – Formularanwendung VCL angelegt.
Ein Projekt kann dabei an beliebiger Stelle auf Ihrem System abgelegt werden:

Delphi zeigt sich dann wie folgt:

Die einzelnen Programmelemente und die Desktopgestaltung von Delphi können dabei entsprechend Ihren Wünschen anpasst werden, wobei Sie Ihr individuelles Layout auch abspeichern können.

Der Objektinspektor ist vergleichbar zu dem von Foxpro, auch wenn in der Regel die Anzahl der Eigenschaften / Ereignisse zahlreicher sind. Der Objektinspektor passt sich dem jeweils gewählten Element an.

Formulare

In der Mitte sehen Sie das Formular, wobei Sie unten jederzeit zwischen Code und Formulargestaltung umschalten können. Während Sie im Formularmodus unter VFP niemals den ganzen Code sehen können, sondern immer nur Teile, z.B. den Code eines Klick-Events einer Schaltfläche, haben Sie in Delphi immer den ganzen Code in einer Unit, was m.E. übersichtlicher ist. Bei sehr umfangreichen Units empfiehlt es sich aber den Code auf weitere Units, auf die Sie dann in der Ausgangsunit verweisen, zu verteilen. Von daher sollte schon vorher über eine gewisse Strukturierung Ihres Projekts nachgedacht werden. Ohnehin werden Sie vermutlich spezielle Units mit Klassenbibliotheken, Zugriffsfunktionen für Ihre Daten etc. erstellen. Dies ist aber nicht Gegenstand dieser Serie.

Eine Unit (also Ihre Codebibliothek, in diesem Fall die eines Formulars) sieht dabei immer wie folgt aus:

unit mainform;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs;

type
TForm1 = class(TForm)
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;

var
Form1: TForm1;

implementation

{$R *.dfm}

end.

Uses verweist dabei auf Bibliotheken (also andere Units) aus denen Sie Funktionen / Prozeduren etc verwenden.Eine Unit kann ein Formular sein, muss es aber nicht. Genauso gut kann es eine Sammlung von Prozeduren/Funktionen sein oder Klassenbibliotheken enthalten. In letzteren Fall ist dann ein *.pas Unit eine reine Code-Bibliothek.

Delphi – als objektorientierte Sprache – begreift das Formular als Objekt.   Unter Private deklarieren Sie dann Funktionen oder auch Variablen, die nur innerhalb des Formulars verwendet werden können. In Public deklarieren Sie Funktionen, die auch von außen zugänglich sind.

Fügen Sie einer Delphi Form Komponenten hinzu (z.B. ein Label), so werden die entsprechenden Deklarationen automatisch hinzugefügt.

Ändern Sie später den Namen einer solchen Komponente, so werden alle mit dieser Komponenten verbundenen Ereignisse namentlich automatisch angepasst.

Ein ganz wesentlicher Unterschied zu VFP ist, dass Delphi keine dynamische Sprache ist: d.h. alles, was Sie verwenden an Variablen, Prozeduren muss deklariert werden. Möchten Sie also eine String-Variable deklarieren , so muss auch dieser Typ angegeben werden:

var meinString: String;

Dieser Variable können Sie dann auch nur einen String zuweisen und nicht mal eben eine Zahl, wie dies unter VFP möglich ist. Möchten Sie also eine Zahl zuweisen, so müssten Sie zunächst eine Typ-Umwandlung durchführen, also z.B.

meinString :=IntToStr(7);

Ab Delphi 2009 ist String dabei immer ein Unicode-String, was einerseits nach sich zieht, dass Sie bestimmte Dinge beachten müssen, andererseits öffnet es Ihr Programm aber auch einem weltweiten Markt.

Grundlage – zumindest eines fensterorientierten Programms (also einer VCL -Visual Component Library – Anwendung) – ist immer ein Formular. Welches das Hauptformular ist, können Sie dabei unter Projekt -> Optionen – Formulare festlegen. Dieses Hauptformular stellt dann den Rahmen Ihres Programmes dar. Unterformulare können Modal/Nichtmodal sein oder auch MDI-Fenster.

Prinzipiell gibt es auch ein Startprogramm, ähnlich dem, was man oft in VFP hat. Dessen Code sehen Sie, wenn Sie Projekt -> Quelltext anzeigen wählen. Die Datei wird von Delphi automatisch erzeugt, man kann aber auch eigene Erweiterungen einfügen, z.B. um den Standardfont Ihrer Anwendung dem jeweiligen Betriebssystem anzupassen.

In unserem Falle würde dies so aussehen:

program cfp2delphi;

uses
Forms,
mainform in ‚mainform.pas‘ {Form1};

{$R *.res}

begin
Application.Initialize;
Application.MainFormOnTaskbar := True;
Application.CreateForm(TForm1, Form1);
Application.Run;
end.

Im wesentlichen also die Initialisierung und eine Auflistung aller Formulare, die Sie erstellen.

Ganz wichtig: erstellen Sie mehrere Formulare, so werden diese automatisch erzeugt beim Programmstart, was oft nicht gewollt ist. Unter VFP werden diese ja in der Regel erst angezeigt, wenn angefragt. Es ist also wichtig, dass Sie unter Projekte -> Optionen -> Formulare Formulare, die nicht sofort benötigt werden von ‘Automatisch erzeugen’ nach ‘Verfügbare Formulare’ ziehen.

Ein solches Formular muss dann manuell erzeugt werden, aus einem
DO form Form1 in VFP
wird dann ein
Form1:=Tform.create(nil);
form1.showmodal;
form1.free;

Ganz wichtig ist es das Formular nach Beenden wieder freizugeben (also den Speicher aufräumen).

oder bei einem Nicht-modalen Fenster
Form1:=Tform.create(nil);
form1.show;

Hier muss die Freigabe des Speichers im Formular selbst erfolgen, sonst würde das Formular direkt nach dem Erstellen wieder geschlossen.

Im OnClose-Event der jeweiligen Form:

Action:=caFree;
form1:=Nil;

Ob eine Form modal ist oder nicht, wird also über den Zusatz show oder showmodal entschieden und nicht über eine Eigenschaft der Form.

Ganz netter Zusatz ist übrigens die Komponente  TScrollbox aus der Palette ‘Zusätzlich’ – fügen Sie diese einer Form hinzu, können Sie auf dieser mehr Steuerelemente hinzufügen als in der Höhe eigentlich hineinpasst, eine Form kann also eine Höhe von 600 Pixel haben, Sie können aber ein Element mit einem Wert von Top=1000 einbauen. Dieses Element kann dann über die Scrollbars rechts angezeigt werden. Der gesamte von Ihnen gewünschte Raum kann direkt in der IDE bearbeitet werden.

Ohne irgendwas zu machen, ist Ihr Programm dann eigentlich schon lauffähig. Wählen Sie Start / Start – fertig. Irgendwelche Read Events oder eine App-Klasse o.ä. brauchen Sie nicht. Dabei wird auch eine echte EXE-Datei erzeugt, die direkt aus dem Programm heraus lauffähig ist.

Neben der Code und der Formularansicht gibt es auch noch eine Ansicht ‘Historie’ – sehr nützlich, denn Delphi speichert Ihnen hier diverse Änderungen zwischen, dies ermöglicht es Ihnen jederzeit auf den Code früherer Bearbeitungszeitpunkte zurückzugreifen. Eine vergleichbare Funktion bietet Ihnen VFP nicht.

Obwohl eine Ansicht speichert Ihnen Delphi beide Teile eines Forumlars getrennt, den Codeteil in einer Datei *.pas, die Form als *.dfm – Datei, wobei die DFM – Datei mit jedem Editor geöffnet und auch bearbeitet werden kann, was aber nur mit Vorsicht erfolgen sollte. Auch die Pascal-Datei lässt sich mit jedem externen Editor bearbeiten.

Sehr nett ist, dass mehrere Formulare gleichzeitig geöffnet werden können und diese über das Formularregister oben leicht erreichbar sind, was ohne Hilfsmittel in VFP zumindest unbequemer ist (vorsichtig formuliert)

Sie haben also in der Delphi-IDE:

• Zugriff auf alle Dateien Ihres Projektes über die Projektverwaltung
• Zugriff auf kompletten Code und Ihre Formulare durch einfaches Umschalten
• Zugriff auf alle geöffneten Formulare oder Units über das Register

Insgesamt ermöglicht dies ein komfortablen und schnelleren Arbeitsfluß als unter VFP.

Steuerelemente, um Ihrem Programm Leben zu geben:

Auf der rechten Seite können Sie aus der Tool-Palette auf zahlreiche vorgefertige Komponenten zurückgreifen, die in Anzahl und Leistung weit über das hinausgehen, was Ihnen die VFP-Palette bietet. Die Tool-Palette ist dabei in diverse Register aufgegliedert – je nach Anwendungszweck (Standardkomponenten, Datenbankzugriffskomponenten, Internetkomponenten…).

Noch schöner ist es aber, dass Sie diese jederzeit durch kostenlose oder kommerzielle Komponenten von Dritten erweitern können, dies über Komponente -> Packages installieren.

Einmal importierte Komponenten stehen dann jedem Projekt zur Verfügung und müssen nicht explizit einem Projekt wie unter VFP zugewiesen werden. Dies erleichtert die Organisation Ihrer Zusatzkomponenten erheblich. Es genügt ein solches Steuerelement/Klasse etc. dann von der Toolpalette einer beliebigen Form eines beliebigen Projekts zuzuweisen.

Natürlich ist es wichtig Delphi mitzuteilen, in welchen Suchpfad es die entsprechenden Dateien finden kann. Dies geschieht über Tools -> Optionen -> Delphi -Optionen -> Bibliothek Win 32.

Unter VFP entpacken Sie Zusatz-Bibliotheken in der Regel irgendwo auf Ihrer Platte und fügen diese dann manuell Ihrem Projekt zu, was bei jedem weiteren Projekt wieder neu erfolgen muss. In Delphi stehen Komponenten dagegen – einmal importiert – jedem Projekt automatisch zur Verfügung.

Ebenso können Sie ActiveX/Com-Objekte importieren, in der Regel sollten Sie aber auf Delphi-Komponenten zurückgreifen, diese sind in der Regel in Pascal geschrieben, also native. Probleme, wie oft bei ActiveX Komponenten, bleiben Ihnen damit erspart. Ebenso Registrierungsprobleme bei der Installation Ihres Programms. Sie haben dabei unter Delphi eine wesentlich größere Auswahl als unter VFP und erhalten Komponenten oft sogar mit Sourcecode oder können diese zumindest gegen Aufpreis erwerben.

Letzteres ist auch empfehlenswert, weil eine neue Delphi-Version u.U. eine Neukompilierung dieser Komponenten benötigt und hierzu brauchen Sie den Sourcecode, überlebenswichtig, falls der Hersteller zwischenzeitlich nicht mehr vorhanden ist.

Die Projektverwaltung rechts listet Ihnen wiederum alle Dateien Ihres Projekts, inklusive von Buildkonfigurationen, hier können Sie z.B. zwischen Einstellungen für eine Debug-Version und einer Finalversion umschalten und Ihre EXE-Datei entsprechend kompilieren.  Verschiedene Projekte lassen sich im Unterschied zu VFP auch in einer Projektgruppe zusammenfassen.

Steuerelemente können Sie direkt aus der jeweiligen Tool-Palette auf Ihre Form ziehen, ganz wie in Ihrem VFP-Programm, haben Sie aber mehrere Elemente auf Ihrer Form werden Sie schnell einen kleinen Unterschied bemerken: Delphi zeigt Ihnen automatisch Hilfslinien an,  eine erhebliche Erleichterung bei der Ausrichtung von Elementen !

Ein markiertes Objekt kann unter VFP mit den Pfeiltasten verschoben werden, in Delphi erfolgt dies mit der Kombination von Ctrl und der jeweiligen Richtungstaste.

Ein neues Element wird dem Code-Teil Ihrer Form automatisch hinzugefügt:

z.B.

type
TForm1 = class(TForm)
Label1: TLabel;

Selbstverständlich lassen sich alle Elemente natürlich auch programmatisch erzeugen, z.B.

Label1 :=Tlabel.create(form1);

Möchten Sie einer VFP-Form eine neue Eigenschaft oder Methode hinzufügen, so geschieht dies normalerweise mit Neue Eigenschaft oder Neue Methode im Formularmodus. Unter Delphi wechseln Sie dazu in den Codeeditor und deklarieren eine Variable/Prozedur/Funktion in folgenden Block

private
{ Private-Deklarationen }
Privat_meineVariable : String;    // Variable, auf die nur in der Form zurückgegriffen werden kann
procedure Privat_meineErste;      // Prozedur/Methode, auf die nur in der Form zurückgegriffen werden kann
public
{ Public-Deklarationen }
Public_meineVariable : String;    // Variable, auf die auch von außen zugegriffen werden kann
procedure Public_meineErste;      // Prozedur/Methode, auf die auch von außen zugegriffen werden kann
end;

Es ist nicht notwendig, wie unter VFP ein thisform. oder this. vor den Namen der Variable oder der Prozedur/Funktion zu setzen, wenn Sie innerhalb des jeweiligen Formulars diese referenzieren.
Sie können also jederzeit im Code

Privat_meineErste:=’Test’;
schreiben.

Nur wenn Sie von ausserhalb darauf zugreifen, müssten Sie dann
Form1.Public_meineVariable:=’Test’;
schreiben. Auf die Variable Privat_meineErste können Sie von aussen natürlich nicht zugreifen, da diese ja als Privat angelegt wurde.

Delphi hat ein sehr ausgefeiltes Intellisense und Infosystem innerhalb des Editors – ausserdem zeigt es Code-Fehler recht schnell an, z.B. wenn einer String-Variablen ein numerischer Wert zugewiesen wird. Mitunter läuft dieses System aber Amok ;) und zeigt Ihnen alles mögliche rot unterlegt an, obwohl es sich nicht um Fehler handelt. Kleinere Macken hat halt jedes System.

Es würde zu weit führen alle Funktionen, die Ihnen Delphi bietet hier aufzulisten. Sehr nette Funktionen bietet Ihnen z.B. „Refactor“ an.

Schreiben Sie z.B. x:=’100’; markieren x und klicken Sie dann rechts an, wählen Sie aus dem Kontextmenü ‘Refactor’ an, so bieten sich Ihnen sehr nette Funktionen, u.a. ‘Variable deklarieren’- dies ist insbesondere dann nett, wenn Sie eine längere Funktion haben und nicht zum Deklarationsteil der jeweiligen Funktion scrollen möchten.

Eine weitere interessante Funktion ist die Funktion „Deklaration suchen„, um einmal deklarierte Variablen oder Methoden im Code zu verfolgen.

Während der VFP Compiler oft nur schwerwiegende Fehler anmahnt, bietet Ihnen Delphi zahlreiche Hinweise oder Warnungen, z.B. über möglicherweise nicht inititalisierte Variablen, unnötigerweise deklarierte Variablen und vielen mehr und selbstverständlich  natürlich auch schwerwiegende Fehler – hier lässt sich dann in der Regel ein Programm gar nicht erst erstellen. Die Fehlersuche oder das Schreiben möglichst fehlerfreien Codes ist damit erheblich leichter als unter VFP. Weitere Funktionalitäten wie Code-Templates, Tools zur Fehleranalyse, der komplexe Debugger seien zumindest erwähnt.

Ich hoffe, dieser zweite Teil hat Ihnen einen ersten Einblick in Delphi gegeben und Sie ein bisschen hineinschnuppern lassen, vor allem aber Unterschiede/Gemeinsamkeiten zu VFP aufgezeigt.

In den nächsten Teilen dieser kleinen Serie werde ich mich dann mehr mit dem Thema Datenbanken auseinandersetzen, was für jeden VFP – Entwickler natürlich im Zentrum steht. Ich kann Ihnen versprechen : Delphi ist ausgesprochen datenbankorientiert und bietet Ihnen zahlreiche Möglichkeiten, es ist sogar möglich Ihre Daten live in der IDE beim Entwickeln Ihrer Anwendung zu sehen. Also schauen Sie wieder rein!