Das Orakel von PHP

CodeGears Delphi for PHP im Überblick
Kommentare

Mit „Delphi for PHP“ hat CodeGear ein Rapid Application Development (RAD-)Tool für PHP auf den Markt gebracht. Die Entwicklungszeit von PHP-Anwendungen zu verkürzen und die Qualität des Codes zu verbessern hört sich gut an. Aber kann Delphi den Markt der Windows-PHP-IDEs revolutionieren oder ist es nur eine interessante Randerscheinung?

„Delphi for PHP? Was soll das denn sein?“ war mein erster Gedanke als ich las, dass CodeGear „Delphi for PHP“ auf den Markt bringt. Was sollte das sein? Eine neue IDE? Eine Möglichkeit die „Sprache Delphi“ mit PHP zu verknüpfen? Oder vielleicht doch eine Variante, um Windows-Anwendungen mit PHP zu erstellen? Nachdem ich die Trial-Version heruntergeladen und installiert hatte, wurde ich eines Besseren belehrt. „Delphi for PHP“ bietet die Möglichkeit, PHP-basierende Anwendungen schnell und effizient zu „zusammenzuklicken“. Rapid Application Development, also Techniken um Software möglichst schnell zu entwickeln, ist in vielen Bereichen der Softwareentwicklung schon lange ein Thema. Zieht man in Betracht, dass ein fest angestellter Entwickler den Arbeitgeber meist zwischen 60 und 80 Euro pro Stunde kostet, dann macht es Sinn, die Entwicklungszeit möglichst kurz zu halten. Erste Ansätze dieser Idee finden sich in der PHP-Community in Form von Funktions- und Klassenbibliotheken bzw. ganzen Frameworks. Auch diese sollen helfen, die Entwicklungszeit möglichst kurz zu halten und Fehler zu vermeiden.

Delphi for PHP geht aber noch einen Schritt weiter. Hier geht es nicht nur darum serverseitige Vereinfachungen bereitzustellen, sondern auch darum die Client-Seite zu bedienen. Das heißt Delphi gibt Ihnen die Möglichkeit, eine Oberfläche auf Basis einer großen Anzahl von Komponenten zu erstellen. Diese Komponenten können zum Großteil untereinander kommunizieren und stellen somit ein breites Spektrum an Leistungsmöglichkeiten bereit.

Aus zwei mach eins

Der Kern von Delphi for PHP ist „VCL for PHP“. VCL, die Visual Component Library, ist eine Komponentenbibliothek, die bei der Entwicklung von Delphi-Anwendungen schon lange Verwendung findet. VCL for PHP stellt das PHP-Pendant zu dieser Bibliothek dar. Das wirklich spannende an VCL for PHP ist, dass diese PHP-Bibliothek in der Lage ist, die (HTML-)Komponenten, die für die Darstellung benötigt werden, zu generieren und mit diesen zu kommunizieren. Das heißt, in VCL werden HTML, JavaScript und PHP miteinander „verschmolzen“. Der Client ist applikationstechnisch also sehr eng an den Server gekoppelt. Das führt natürlich auch dazu, dass relativ viel Kommunikation zwischen dem Client und dem Server stattfindet. Angenehm ist, dass der Entwickler in den meisten Fällen entscheiden kann ob die Kommunikation AJAX-basierend oder mit „normalen“ Requests stattfinden soll.

Sehr positiv finde ich, dass VCL als Open Source vorliegt und CodeGear nicht versucht, die Bibliothek „geheim“ zu halten. Sie können VCL auch ohne Delphi verwenden und kostenlos bei Sourceforge herunterladen. Sollten Sie sich mit Delphi auskennen, so wird Ihnen der Einstieg in Delphi for PHP leicht fallen. Sollten Sie allerdings wie ich aus der PHP-Ecke kommen, so wird Delphi for PHP zuerst sehr ungewohnt sein. Aber lassen Sie uns am Anfang beginnen.

Installation

Die Installation gestaltet sich, wie bei den meisten Windows-Anwendungen, einfach und unkompliziert. Nach wenigen Mausklicks ist die Anwendung installiert und einsatzbereit. Alle notwendigen Komponenten, wie PHP, Webserver etc. bringt Delphi mit. Das einzige, was Sie eventuell noch zusätzlich installieren müssen, ist eine MySQL-Datenbank.

Die Oberfläche

Die Oberfläche von Delphi for PHP kommt einem vertraut vor, wenn man schon mit dem Zend Studio oder Eclipse gearbeitet hat. Um den Editier-Bereich in der Mitte des Fensters gruppieren sich verschiedene kleinere Fenster mit diversen Informationen und Tools (Abbildung 1).

Abb. 1: Delphi for PHP

Lassen Sie mich in der Mitte des Fensters anfangen. Hier finden Sie die Datei bzw. die Dateien, die gerade geöffnet sind. Mit den Reitern am oberen Rand können Sie zwischen den Dateien umschalten. Am unteren Rand können Sie zwischen der Design- und der Code-Ansicht umschalten. In der Code-Ansicht können Sie den Code genau so editieren, wie Sie das aus anderen Editoren kennen. Wie der Code aufgebaut ist, erläutere ich später. In der Design-Ansicht können Sie die Oberfläche visuell erstellen. Die Elemente, die Sie dazu benötigen, finden Sie rechts unten im Fenster in der Tool-Palette. Dort sind viele verschiedene Elemente mit unterschiedlichem Komplexitätsgrad zu finden. Angefangen bei einfachen Formular-Elementen, über einen Online-Editor bis hin zu einem Element, mit dem Sie ganze Datenbanktabellen auf einmal darstellen können, finden Sie hier (fast) alles was das Herz begehrt. Ein Großteil dieser Objekte ist dabei so aufeinander abgestimmt, dass sie direkt miteinander kommunizieren können. Das nimmt dem Entwickler zwar viel Arbeit ab, zieht unter Umständen aber auch Probleme nach sich. Benötigen Sie eine Funktionalität, die nicht durch die Komponenten abgedeckt wird, ist der Aufwand unter Umständen ein wenig größer. Um eine Komponente einzufügen, wählen Sie diese in der Toolbox an und klicken dann in der Design-Ansicht an die Stelle, an der sie erscheinen soll. Auch Komponenten, die keine Bildschirmdarstellung generieren, wie eine Datenbank, werden auf diesem Weg hinzugefügt.

Nachdem Sie ein Objekt eingefügt haben, finden Sie links unten im Fenster die Eigenschaften der Komponente im „Object Inspector“. Mithilfe der Eigenschaften können Sie sowohl das Aussehen als auch das Verhalten beeinflussen. Eine Trennung zwischen Eigenschaften, die das serverseitige Verhalten und denen, die das clientseitige Verhalten beeinflussen, ist nicht vorgesehen. Dass hier z.B. die Schriftart direkt neben der Datenbankverbindung steht, ist erst ein wenig gewöhnungsbedürftig, macht aber Sinn, wenn man der „Delphi-Philosophie“ folgt und die Komponenten als „Ganzes“ betrachtet und die Trennung zwischen Client und Server ein wenig vernachlässigt. Im Object Inspector finden Sie noch zwei weitere Reiter: Events und JavaScript. Hinter Events verbergen sich einige Ereignisse, auf die serverseitig reagiert werden kann. Mithilfe des Reiters JavaScript können Sie Funktionsaufrufe einfügen, mit denen auf clientseitige Ereignisse reagiert werden kann. Um eine Funktion für eine Ereignisbehandlung einzufügen, können Sie einfach einen Doppelklick auf die leere Zeile hinter dem Namen des Events machen. Der Funktionskörper wird automatisch generiert. Dies gilt auch für den JavaScript-Code. Dieser wird, was sicherlich auch ein wenig komisch anmutet, in PHP eingebettet. Das heißt, nach dem Doppelklick wird eine PHP-Methode erstellt, in welche Sie den JavaScript-Code einbetten. Dass der Code in eine JavaScript-Funktion überführt und korrekt in die HTML-Seite eingebettet wird, übernimmt Delphi für Sie.

Ein kleiner Tipp am Rande: Sollten Sie mal eine Methode aus dem Quelltext entfernen, so denken Sie bitte auch daran, den Aufruf aus dem entsprechenden Event zu entfernen, da Delphi das nicht automatisch macht. Standardmäßig finden Sie oben links den Code-Explorer und das Structure-Fenster. Im Code-Explorer sind alle Funktionen, Klassen und Eigenschaften zu finden, die auch in der aktuell geöffneten Datei zu finden sind. Des Weiteren können Sie hier auch sehen, welche Dateien inkludiert werden. Mit einem Doppelklick auf den jeweiligen Eintrag springt der Editor auch zu der dazugehörigen Code-Zeile. Wenn Sie die inkludierten Dateien suchen sollten, so finden Sie diese unter dem Punkt USES. Klicken Sie auf den Reiter STRUCTURE, so sehen Sie eine Übersicht der Komponenten, die momentan verwendet werden und wie diese voneinander abhängen. Gegenüber auf der rechten Seite finden Sie den Project Manager, der alle Dateien auflistet, die zu dem aktuellen Projekt gehören. Des Weiteren ist hier auch Data Explorer zu finden, mit dem Sie auf Datenbanken zugreifen können.

Obwohl Delphi per PHP den Zugriff auf verschiedenste Datenbanken unterstützt, so können Sie hier momentan doch nur auf MySQL und InterBase zugreifen. Da InterBase in den meisten Fällen nicht so spannend sein wird, gehe ich hier nur auf MySQL ein. Klicken die mit der rechten Maustaste in das Feld und wählen Sie REGISTER DATABASE, so erscheint ein Dialog in dem Sie eine neue Datenbankverbindung anlegen können. In das Fenster müssen Sie neben den üblichen Daten wie Server-, Username und Passwort auch den Namen der Datenbank eingeben. Dies hat den Hintergrund, dass es möglich ist, eine Tabelle oder einzelne Tabellenspalten aus dem Data Explorer auch direkt in die Oberfläche übernehmen können. Logischerweise benötigt Delphi dazu alle Informationen, die für den Zugriff auf eine Tabelle notwendig sind. Allerdings möchte ich Ihnen momentan noch davon abraten, Tabellen direkt aus dem Data Explorer zu übernehmen. Hier scheint es noch einen Bug zu geben, der in einigen Fällen dazu führt, dass kein Zugriff auf die Daten möglich ist. Aber keine Angst, auch ohne den Data Explorer ist der Zugriff auf Daten innerhalb von wenigen Minuten erledigt. Nichts desto trotz ist der Data Explorer sehr hilfreich, um einen Überblick über die Namen von Tabellen und deren Spalten zu behalten. Ein direkter Zugriff auf die Daten ist zurzeit leider noch nicht möglich.

Getting started

Nachdem Sie nun einen Überblick über die Oberfläche haben, möchte ich Ihnen eine kleine Beispielanwendung vorstellen. Dazu klicken Sie bitte auf FILE | NEW | APPLICATION. Delphi generiert ein neues Projekt für Sie, in welchem eine neue Unit, also die eigentliche Anwendung, enthalten ist. Schalten Sie auf die Code-Ansicht um, so finden Sie den Code aus Listing 1.

Listing 1

loadResource(__FILE__);

        //Shows the form
        $Unit16->show();

?>

Zugegebenermaßen wirkt der Code auf Anhieb so, als müsste da was fehlen, weil er doch recht kurz ist. Aber keine Angst, alles Benötigte ist da. In den ersten Zeilen finden Sie die Dateien, die inkludiert werden. Das use_unit(), das hier Verwendung findet, ist übrigens nichts anderes als ein require_conce(), bei dem der VCL-Basis-Pfad automatisch ergänzt wird. Das heißt, die damit eingebundenen Dateien werden relativ zum VCL-Pfad gesucht. Die Klasse Unit16 – sie kann bei Ihnen auch anders heißen – wird von der Klasse Page abgeleitet und beinhaltet später alle selbst erstellten Funktionalitäten der Applikation. In der Delphi-Nomenklatur wird die Unit auch als Formular (form) bezeichnet. Nach der Klassendeklaration folgt die Logik, die für die Darstellung und das Darstellen des Formulars zuständig ist. Üblicherweise können Sie diese Zeilen unverändert lassen. Zwar bringt Delphi eine komplette Dokumentation mit, aber leider ist die in vielen Fällen nicht sonderlich aussagekräftig. Inzwischen finden Sie im Internet aber eine deutlich verbesserte und erweiterte Variante, deren Nutzung ich empfehlen würde.

Ein Beispiel

Nach der ganzen Theorie möchte ich Ihnen die Funktionsweise an einem kleinen Beispiel vorstellen. Und zwar möchte ich eine kleine Verwaltung für Telefonnummern implementieren. Die MySQL-Tabelle, auf der die Anwendung basiert, hat diesen Aufbau:

CREATE TABLE 'telefon' (
  'id' int(11) NOT NULL auto_increment,
  'vorname' varchar(100) default NULL,
  'nachname' varchar(100) default NULL,
  'telefon' varchar(100) default NULL,
  PRIMARY KEY ('id')
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

Nachdem die Tabelle angelegt ist, kann es auch schon losgehen. Wie gesagt, der einfachste Weg wäre die Felder der Tabelle aus dem Data Explorer in die Design-Ansicht zu ziehen, was aber nicht immer so funktioniert, wie es sollte. Daher werde ich Ihnen den manuellen Weg vorstellen.

Die Datenbankverbindung

Da die Anwendung auf einer Datenbank basiert, muss auch genau diese Komponente erst aus der Toolbox in die Design-Ansicht übernommen werden. Keine Angst, diese Komponente sehen Sie nur im Entwurf, aber nicht in der eigentlichen Applikation. Der Datenbankzugriff muss danach über den Object Inspector konfiguriert werden. Geben Sie dazu einfach den Namen der Datenbank, den Namen des Hosts, den Benutzernamen und ein Passwort an, wenn es benötigt wird. Als DriverName würde ich Ihnen empfehlen, mysql und nicht mysqli zu nutzen, da es bei mysqli noch zu Problemen kommen kann. Ob Sie die Eigenschaft Name verändern oder nicht, bleibt Ihnen überlassen. Es wäre aber hilfreich, hier einen aussagekräftigen Namen zu nehmen.

Nachdem die Datenbank konfiguriert ist, stellt sich die Frage, mit welcher Tabelle gearbeitet werden soll. Damit die Anwendung die Kommunikation mit der Datenbank weitgehend automatisieren kann, benötigen Sie eine Table-Komponente aus der Toolbox. Nachdem Sie diese in die Design-Ansicht eingefügt haben, müssen Sie auch hier die Eigenschaften anpassen. Als Erstes selektieren Sie bitte den Namen der Datenbank, die genutzt werden soll. Achtung: Dabei handelt es sich nicht um den Namen der Datenbank auf dem Server, sondern um den Namen, den Sie der Datenbankkomponente gegeben haben. Danach geben Sie als TableName bitte den Namen der Tabelle, in diesem Beispiel also telefon, an. Als letzter Punkt ist noch wichtig, dass Sie die Tabelle aktivieren indem Sie die Eigenschaft Active auf true setzen. In einigen Fällen kann es noch hilfreich sein, wenn Sie die Reihenfolge der Daten mithilfe der OrderField-Eigenschaft festlegen. Hier können Sie einfach den Namen einer Spalte eingeben.

Damit ist der Großteil der Datenbankkommunikation bereits erledigt. Was hier jetzt noch fehlt, ist eine Datasource. Auch diese übernehmen Sie bitte aus der Toolbox in die Design-Ansicht. Die Datasource ist dafür zuständig, dass die Daten aus einer Tabellen- oder Query-Komponente so aufbereitet werden, dass Darstellungskomponenten damit arbeiten können. Genau genommen leistet sie noch mehr, wie Sie gleich sehen werden. Danach ist die Datenbank komplett eingerichtet. Nun fehlen noch die Komponenten für die Darstellung der Daten.

Die Oberfläche

Die Oberfläche setzt sich in diesem Fall aus relativ wenigen Komponenten zusammen. Beschriftungen und Überschriften können Sie mithilfe der Komponente Label erstellen. Solche Labels können Sie in der Design-Ansicht frei platzieren. Größe, Schriftart und Ausrichtung des Textes können Sie mithilfe der Eigenschaften beeinflussen, womit Sie auch die Beschriftung (CAPTION) ändern können. Bitte machen Sie nicht denselben Fehler, den ich gerne mache und klicken Sie doppelt auf ein Label, um die Beschriftung zu ändern. Damit fügen Sie nur eine Methode ein, die dann onClick ausgeführt wird. Um die Beschriftungen auszurichten, können Sie übrigens mehrere gleichzeitig markieren und dann mit einem Rechtsklick und dem Punkt ALIGN ausrichten.

Jetzt fehlen natürlich noch Felder für die Daten aus der Datenbank. Dazu können Sie Edit-Komponenten nutzen. Dabei handelt es sich um einfache Textfelder, die aber direkt mit einer Datasource kommunizieren können. Das heißt im Endeffekt, dass die Daten aus der Tabelle hiermit direkt dargestellt und editiert werden können. Für jede Datenbankspalte, die dargestellt werden soll, benötigen Sie also eine Edit-Komponente. Nachdem Sie diese in das Formular eingefügt haben, müssen Sie sie mit der Datasource und den jeweiligen Tabellenspalten verbinden. Dazu wählen Sie im Object Inspector bei der Eigenschaft DATA SOURCE bitte den Namen der Datasource aus und geben in das Feld DataField den Namen der jeweiligen Tabellenspalte ein. Damit könnte die Applikation immer einen Datensatz darstellen. Allerdings wird es auf Dauer langweilig, immer nur denselben Datensatz zu betrachten. Daher wäre es hilfreich, durch die Daten blättern zu können. Dazu hat CodeGear die Komponente DBPaginator eingeführt. Ein DBPaginator-Objekt kann mit einer Datasource kommunizieren und ihr mitteilen, welcher Datensatz der aktuelle ist. Da die Edit-Felder ihre Daten von der Datasource beziehen ist es somit möglich, unterschiedliche Datensätze auszuwählen. Nachdem Sie ein DBPagnator-Objekt aus der Toolbox übernommen haben können Sie dieses natürlich anpassen. Mit den ersten vier Eigenschaften in der Liste können Sie die Beschriftung ändern. Die Zahlen, die sich zwischen den Texten befinden, generiert die Komponente automatisch. Darüber hinaus müssen Sie natürlich noch die korrekte DataScource selektieren.

Ein erster Test

Damit könnten Sie auch schon den ersten Testlauf machen. Dazu klicken Sie auf das rote Ausrufungszeichen aus der Symbolleiste. Das startet mit Delphi die Anwendung in Ihrem Standardbrowser. Wenn Sie noch keine Daten in Ihrer Tabelle haben, so können Sie natürlich auch noch nicht so ganz viel sehen. Zwar können Sie schon Daten in die Edit-Felder eintragen, aber diese würden noch nicht gespeichert. Das heißt, die Anwendung muss noch ein wenig erweitert werden.

Daten speichern

Um die Daten verändern zu können, benötigen Sie drei Button-Komponenten aus der Toolbox. Drei deswegen, weil Sie ja neue Daten eingeben, bestehende Daten editieren und vielleicht auch Sätze löschen wollen. An dieser Stelle wird es nun das erste Mal passieren, dass Sie wirklich im Code arbeiten müssen. Nachdem Sie die drei Buttons positioniert haben, sollten Sie zuerst die Beschriftung ändern, was wiederum über den Object Inspector machen. Nun muss den Buttons noch ein entsprechendes Verhalten zugewiesen werden, sprich, es muss eine serverseitige Methode bei Klick auf den Button aufgerufen werden. Dazu wählen Sie im Object Inspector den Reiter EVENTS und machen dann einen Doppelklick auf den Eintrag ONCLICK. Delphi generiert automatisch den Körper einer Methode, die aufgerufen wird, wenn der Button geklickt wird.

Abb. 2: Der Entwurf der Anwendung in der IDE

Da die Applikation im Endeffekt ein großes Objekt darstellt, können Sie alle Komponenten, die Sie hinzugefügt haben, über

psenv::pushli(); eval($_oclass[„this“]); psenv::popli(); ?>

und ihren Namen ansprechen. Oh, bevor ich es vergesse: Sollten Sie einmal nicht wissen, welche Eigenschaft eines Objektes die gesuchten Daten enthält, so sollten Sie nicht versuchen, das mit einem var_dump() herauszufinden. Die Objekte sind so umfangreich, dass das im schlimmsten Fall Ihren Browser zum Absturz bringt. Auf jeden Fall bringt diese Vorgehensweise Sie sicher nicht weiter. Ein weiterer Punkt, der in diesem Zusammenhang ein wenig gewöhnungsbedürftig ist, ist die Tatsache, dass viele Eigenschaften nur gelesen, nicht aber geschrieben werden können. Das ist für PHP-Anwendungen ein wenig unüblich und wurde mit Hilfe von __get() und __set() implementiert. Wundern Sie sich also nicht, dass Sie eine Exception erhalten, wenn Sie versuchen, eine Eigenschaft mit einem Wert zu belegen.

Nun aber zurück zum Code. Die onClick-Methode muss im Endeffekt nur eine Sache machen. Und zwar muss sie der Datasource mitteilen, dass sie in den Insert-Modus wechseln soll. Genau genommen muss das nicht der Datasource, sondern dem darin enthaltenen Dataset-Objekt mitgeteilt werden und geschieht durch Aufruf der Methode insert(). Allerdings ist das in der Praxis nicht ganz so einfach. Die Komponente DataSource beinhaltet anscheinend leider noch einen Bug. Ist die Tabelle leer, kann er dazu führen, dass die Komponente ungültiges SQL generiert. Um das zu verhindern musste ich in dieser und den anderen Methoden kleine Workarounds mit einbauen. Die VCL-Bibliothek zu patchen wäre zwar auch möglich gewesen, hätte allerdings dazu geführt, dass man nicht mehr auf die nächste Version updaten kann. Die Workarounds basieren jeweils darauf, dass sie mithilfe der Eigenschaft RecordCount prüfen, ob mindestens ein Datensatz vorhanden ist. Der Code könnte beispielsweise so aussehen. Bitte beachten Sie, dass die Datasource in Ihrer Anwendung einen anderen Namen haben könnte.

function Button2Click($sender, $params)
{
   // Das if ist ein Workaround
   if ($this->Datasource1->DataSet->RecordCount > 0)
   {
      $this->Datasource1->DataSet->insert();
   }
}

Ein Klick auf den Button führt dazu, dass ein neuer Datensatz im Dataset angelegt wird. Die Edit-Felder, die mit diesem Objekt verbunden sind, werden dann auch automatisch geleert. Nun müssen die Daten natürlich auch gespeichert werden, was ein Klick auf den zweiten Button initiieren soll. Das heißt, auch hier muss ein entsprechendes onClick-Event im Object Inspector angelegt werden. Leider ist der Code an dieser Stelle nicht ganz so trivial und portabel, weil auch hier der Bug zum Problem wird. Der passenden Code sehen Sie in Listing 2.

Listing 2

function Button1Click($sender, $params)
{
   if ($this->Datasource1->DataSet->RecordCount == 0)
   {
      $vorname = $this->Datasource1->DataSet->vorname;
      $nachname = $this->Datasource1->DataSet->nachname;
      $telefon = $this->Datasource1->DataSet->telefon;
      $this->dbLokal->execute("INSERT INTO telefon (vorname, nachname, telefon)
                                 VALUES ('$vorname', '$nachname', '$telefon')");
      $this->Datasource1->DataSet->refresh();
   }
   else
   {
      $this->Datasource1->DataSet->post();
      $this->Datasource1->DataSet->refresh();
   }
}

In diesem Fall wird also auch wieder geprüft, ob die Tabelle schon einen Datensatz enthält. Ist das nicht der Fall, muss der erste Datensatz manuell eingefügt werden. Dazu werden die Daten zuerst aus dem Dataset ausgelesen und dann als komplettes SQL-Statement an die Datenbank geschickt. Das kann direkt mithilfe der Database-Komponente erfolgen, die das Statement mittels der Methode execute() an die Datenbank schickt.

Der zweite Teil der if-Abfrage ist der „Standard-Fall“, der immer dann ausgeführt wird, wenn schon Daten vorhanden sind. Die Methode post() verschickt die aus dem aktuellen Dataset und führt entweder ein INSERT- oder ein UPDATE-Statement aus, abhängig davon in welchem Modus de Komponente sich gerade befindet. In beiden Fällen der if-Abfrage wird zusätzlich noch die Methode refresh() aufgerufen. Damit wird sichergestellt, dass die DBPaginator-Komponente auch immer mit den aktuellen Daten versorgt ist. Die letzte Methode, die zu implementieren ist, muss den Löschvorgang durchführen. Dazu muss sie nur die Methode delete() aufrufen, welche den aktuellen Datensatz aus der Tabelle entfernt:

function Button3Click($sender, $params)
{
   if ($this->Datasource1->DataSet->RecordCount > 0)
   {
      $this->Datasource1->DataSet->delete();
      $this->Datasource1->DataSet->refresh();
   }
}

Die fertige Anwendung sehen Sie in Abbildung 3.

Abb. 3: Die fertige Anwendung im Browser

Fehlersuche

Sollte Ihre Anwendung mal nicht das tun, was Sie erwartet haben, unterstützt Delphi Sie mithilfe des Debuggers. Delphi for PHP bringt standardmäßig den Debugger DBG mit. Leider ist momentan nur ein lokales Debugging möglich, was sich zukünftig aber ändern soll.

Nichtsdestotrotz ist auch das lokale Debugging sehr hilfreich und unterscheidet sich nicht großartig von den Möglichkeiten, die z.B. das Zend Studio bietet. Möchten Sie einen Breakpoint in den Code einfügen, also eine Stelle an welcher der Debugger die Ausführung anhalten soll, so klicken Sie einfach vor die Zeilennummer. Nachdem Sie alle Haltepunkte eingefügt haben, können Sie die Debug-Sitzung starten. Klicken Sie dazu einfach oben in der Symbolleiste auf das grüne, nach rechts gerichtete Dreieck (Play-Symbol). Die Ausführung des Codes wird normal gestartet. Sobald einer der Haltepunkte erreicht ist, wird die Ausführung angehalten und Sie können den Code inspizieren. Den aktuellen Zustand der Variablen und Eigenschaften finden Sie unterhalb des Editors. Um den Code weiter auszuführen, können Sie die drei Symbole rechts neben dem roten Ausrufungszeichen nutzen. Damit können Sie den Code zeilenweise abarbeiten lassen, wobei externe Dateien auch automatisch nachgeladen werden.

Ab ins Netz

Nachdem Sie Ihre Anwendung nun lokal fertig gestellt haben, möchten Sie sie sicher auf einem Server installieren. Eine manuelle Installation wäre allerdings wirklich aufwändig, da Sie die ganzen Daten zusammenstellen und die Pfade korrigieren müssten etc. Daher sieht Delphi dafür eine Hilfestellung, den Deployment Wizard vor, den Sie im Menü TOOLS finden. Nachdem Sie ihn gestartet haben, müssen Sie ihm nur noch mitteilen, wohin die Daten kopiert werden sollen. Den Rest erledigt der Wizard von alleine, sodass Sie die Daten danach direkt auf den Server überspielen können.

To Delphi or not to Delphi, that is the question

Die Frage ob man Delphi nutzen sollte oder nicht, ist sicher nicht ganz einfach zu beantworten. Ich persönlich denke, dass es dringend an der Zeit ist ,RAD-Tools im PHP-Umfeld zu etablieren. Und ich muss auch sagen, dass ich wirklich sehr angenehm überrascht war, wie einfach und unkompliziert man Anwendungen mit Delphi erstellen kann. Die Komplexität der VCL-Objekte dürfte allerdings dazu führen, dass man keine hoch hochperformanten Anwendungen auf dieser Basis erstellen kann. Ich kann mir allerdings gut vorstellen, dass kleinere Anwendungen oder Applikationen – mit wenigen parallelen Usern, wie CMS-Backends o.ä. – gut damit erstellt werden können.

Ein Punkt, für den ich Dephi gerne nutze ist es, eine Beispiel-Anwendung zu erstellen, damit Kunden eine bessere Vorstellung von der angebotenen Applikation haben. Nichtsdestotrotz muss CodeGear noch einiges an Delphi und VCL nachbessern. Zwar läuft die eigentliche IDE sogar unter Windows Vista stabil, aber sie lässt noch ein wenig Komfort vermissen, den man vielleicht vom Zend Studio oder Eclipse gewohnt ist. Hier hat CodeGear aber schon angekündigt, dass in der nächsten Version nachgebessert werden soll und dann vor allem auch das Remote-Debugging möglich sein soll. VCL weist zugegebenermaßen noch eine ganze Menge Bugs auf, die in den nächsten Versionen hoffentlich eliminiert werden.

Wenn Sie die Zeit haben, kann ich Ihnen aber nur wärmstens empfehlen sich mal ein wenig mit Delphi for PHP zu beschäftigen. Es lohnt sich.

Unsere Redaktion empfiehlt:

Relevante Beiträge

Meinungen zu diesem Beitrag

X
- Gib Deinen Standort ein -
- or -