Eine klassische Delphianwendung, bei der alle Komponenten mit dem visuellen Formulardesigner auf einem Formular abgelegt wurden, erzeugt diese Instanzen im Konstruktor des Formulars. Wenn eine neue Formularinstanz erzeugt wird, werden also zunächst alle Objektinstanzen für die Komponenten auf dem Formular erzeugt, um dann die Eigenschaften aus der Inhalt der *.dfm-Datei, die in die *.exe-Datei mit hingelinkt wurde, auszulesen. Dieses Verhalten bilden wir in diesem Beispiel einfach mal nach. Im Codeeditor werden für die fünf benötigten Komponenten Instanzvariablen festgelegt (Listing 1).

1. Listing 1
2. --------------------------------------------------------
3. type
4. TForm1 = class(TForm)
5. private
6. { Private-Deklarationen }
7. public
8. JvUIBDataBase1: TJvUIBDataBase;
9. JvUIBTransaction1: TJvUIBTransaction;
10. JvUIBDataSet1: TJvUIBDataSet;
11. JvDBGrid1: TJvDBGrid;
12. Datasource1:TDatasource;
13. DBNavigator1:TDBNavigator;
14. { Public-Deklarationen }
15. end;

Damit das Verhalten gegenüber anderen Units identisch zu sonstigen Formularen und deren Komponenten ist, sollten diese im Public-Bereich des Formulars liegen. Für die Benutzung dieser Komponenten sind weitere Units manuell in der Uses-Liste zu ergänzen.

1. DB, JvUIBDataSet, JvUIB, JvComponentBase, JvExDBGrids, JvDBGrid, DBCtrls

Als nächster Schritt wird für das Projekt unter Projekt | Optionen festgelegt, in welchen Suchpfaden die Delphi-IDE die benutzten Units suchen soll. Je nach gewähltem Ort für die JCL- und JVCL-Komponenten sind folgende Suchpfade zu ergänzen:

1. D:\jvcl\run;
2. D:\jvcl\common;
3. D:\jcl\source\common;
4. D:\jcl\source;
5. D:\jcl\source\windows;
6. D:\jvcl\Resources

Der nächste Schritt ist die Erstellung des OnCreate-Ereignisses für das Formular. Und weil wir auch hier das interne Delphi-Verhalten für Formulare nachbilden, werden zunächst mal Instanzen von allen benutzten Komponenten erzeugt (Listing 2).

1. Listing 2
2. ------------------------------------------------------------------
3. procedure TForm1.FormCreate(Sender: TObject);
4. begin
5. JvUIBDataBase1 := TJvUIBDataBase.Create(Self);
6. JvUIBTransaction1 := TJvUIBTransaction.Create(Self);
7. JvUIBDataSet1 := TJvUIBDataSet.Create(Self);
8. JvDBGrid1 := TJvDBGrid.Create(Self);
9. Datasource1:=TDatasource.Create(Self);
10. DBNavigator1:=TDBNavigator.create(Self);

Für jede erstellte Komponente werden im folgenden Schritt die Eigenschaften gesetzt, die man in klassischer Delphiprogrammierung über den Objektinspektor festgelegt hätte (Listing 3). In diesem Beitrag wird aus Platzgründen nur die erste Komponente vorgestellt, der vollständige Quellcode ist hier zu finden.

1. Listing 3
2. ----------------------------------------------------------------
3. with JvUIBDataBase1 do
4. begin
5. Name := 'JvUIBDataBase1';
6. Params.Add('sql_dialect=3');
7. Params.Add('lc_ctype=NONE');
8. Params.Add('sql_role_name=');
9. Params.Add('user_name=sysdba');
10. Params.Add('password=masterke');
11. DatabaseName := 'localhost:C:\EMPLOYEE.FDB';
12. LibraryName := 'gds32.dll';
13. Connected := True;
14. end;

Weitere Eigenschaften werden für die Transaction-Komponente, die DataSet-Komponente, die Datasource-Komponente, die DBGrid-Komponente und für die DBNavigator-Komponente gesetzt. Eine Besonderheit ergibt sich in diesem Falle noch für die beiden sichtbaren Komponenten JvDBGrid1 und JvDBNavigator1. Neben der Position unter der Align-Einstellung müssen diese noch mit der Zuweisung des Parents zu einem Formular oder einer anderen Komponente versehen werden, auf dem diese gezeichnet werden sollen. Während die Delphi-IDE das üblicherweise automatisch erledigt, müssen wir in unserem Bespiel dafür manuell sorgen.

Während dem Einsteiger diese Vorgehensweise vielleicht recht aufwändig erscheint, ergibt sich dadurch jedoch für den fortgeschrittenen Programmierer nach kurzer Einarbeitung eine erheblich höhere Flexibilität. Komplexe Formulare können modular erzeugt oder Komponenten aufgrund von der Existenz eines Datenbankfeldes in einer Tabelle dynamisch erzeugt werden. Die Tabellenstruktur wird erst zur Laufzeit ausgelesen und entsprechende Fehlermeldungen aufgrund hartcodierter Tfield-Komponenten im Formulardesigner fallen weg.

Für den Umstieg von älteren Delphi-Anwendungen empfiehlt der Autor der Einsatz der Funktion ComponentsToCode, die nach der Installation der GExperts in älteren Delphi-Versionen zur Verfügung steht. Nach Auswahl einer oder mehrerer Komponenten in bestehenden Formularen kann mit einem rechten Mausklick ein Quellcode in die Zwischenablage kopiert werden, der die dynamische Erstellung nach dem vorgestellten Verfahren ermöglicht.

Fazit

Mit der Verfügbarkeit der Turbo-Versionen hat Borland sicher einen Schritt in die richtige Richtung getan, denn im Zeitalter des Internets und Open Source funktioniert Softwaredistribution nicht mehr nur wie früher über einen guten Namen, sondern in erster Linie über ein überzeugendes Produkt. Wer erst einmal die wirklichen Vorteile der aktuellen Borland IDE-Produkte erkannt hat, wird nicht mehr automatisch als einzige Alternative die Microsoft Produkte sehen. Monokulturen haben sich gerade im Bereich der Softwareprodukte nie als vorteilhaft für den Endanwender gezeigt. Im Bereich der Entwicklungswerkzeuge außerhalb der Java-Welt gibt es gerade wieder eine Tendenz hin zur Monokultur, dominiert von einem Anbieter, der jahrelang den Markt der Office-Software-Produkte konkurrenzlos beherrscht hat.

Ich wünsche dem Hause Borland viel Glück mit der Strategie der Auslagerung der IDE Sparte und hoffe, dass der Vorgang möglichst umgehend abgeschlossen sein wird. Auch wenn dann der Name Borland nichts mehr mit den Produkten Delphi oder C++ Builder zu tun haben wird, die loyalen Anwender der Borland IDE Produkte werden auch dem neuen Unternehmen die Treue halte, wenn diese sich auf dem erreichten Niveau der aktuellen BDS 2006 Versionen auch zukünftig weiterentwickeln. Eine Unabhängigkeit von Microsoft und auch von Borland sei der DevCo zu wünschen, weil man nur dann sich wirklich auf die Bedürfnisse der Kunden konzentrieren kann.