Hinweis: Dieses Video und der Podcast wurde mithilfe von KI erstellt auf Grundlage der ursprünglichen Inhalten sowie den technischen Erkenntnissen des Autors des Blogartikels.

Die digitalen Schafe sind die Softwareartefakte, die wir entwickeln und ausliefern. Nun erhalten KI-Agenten Tools, mit denen sie Dateien lesen, Befehle ausführen und auf unsere Infrastruktur zugreifen können. Doch sind die Freiheiten, die wir ihnen damit einräumen, ausreichend abgesichert? Der Artikel zeigt, welche Sicherheitsrisiken solche Tool-Zugriffe im Softwareentwicklungslebenszyklus schaffen und wie Sie ihnen mit begrenzten Berechtigungen, Isolation, Validierung und Monitoring begegnen. Das Model Context Protocol (MCP) spielt dabei als nützlicher Standard mit eigener Angriffsfläche eine Rolle.

von Brett Smith

Lust auf Crossplatform IoT Web and Cloud?

Entdecke Workshops vom 23. - 25. November in Düsseldorf

Mehr Infos

Lassen Sie uns hier präzise sein, denn der Begriff „Agent“ wird inzwischen für alles verwendet: vom Chatbot mit einem System-Prompt bis zum vollständig autonomen Pipeline-Orchestrator.

In der Praxis ist ein Agent ein Programm, das mit Hilfe eines Sprachmodells Entscheidungen trifft, Tools aufruft, um diese Entscheidungen umzusetzen, die Ergebnisse beobachtet und diesen Ablauf wiederholt, bis die Aufgabe erledigt ist oder etwas schiefgeht. Die Standardbeschreibung lautet: „Autonome KI, die mehrstufige Aufgaben ausführt.“ Tatsächlich handelt es sich um ein Programm mit einer while-Schleife, einem Modell in der Mitte und Zugriff auf Dinge, die bei Missbrauch Schaden anrichten können.

Das LLM ist nicht der Agent, sondern dessen Gehirn: die Schicht für Schlussfolgerungen und Planung, die entscheidet, was als Nächstes zu tun ist. Der Harness umfasst alles andere: die Ausführungsumgebung, das Gedächtnis, den Tool-Zugriff und die Sicherheitsschicht, die verhindert, dass das Ganze etwas Katastrophales anrichtet. Im Zentrum steht die Tool-Registry, die jeden Tool-Aufruf durch einen einzigen Kontrollpunkt leitet, bevor irgendetwas ausgeführt wird. Genau dieser Kontrollpunkt ist in den meisten Harness-Implementierungen völlig unzureichend ausgebaut.

Das Herzstück des Harness ist die Ausführungsschleife. Der Harness bündelt Gesprächsverlauf, System-Prompt und verfügbare Tools, sendet dieses Paket an das Modell und wartet auf dessen Antwort: Text, einen Tool-Aufruf oder beides. Tool-Aufrufe werden abgefangen, validiert und ausgeführt; ihre Ergebnisse fließen anschließend als Beobachtungen in den Gesprächsverlauf ein, bevor die Schleife erneut beginnt. Die Zustandsmaschine folgt dabei strikt den Zuständen untätig, denkend, ausführend, abgeschlossen und fehlgeschlagen. Sowohl die Anzahl der Iterationen als auch der Umfang des Kontexts müssen begrenzt werden. Fehlen feste Obergrenzen für beides, kann ein Agent unbegrenzt weiterlaufen oder unkontrolliert abstürzen, wenn das Token-Budget erschöpft ist. Das sind Anforderungen, keine Optimierungen.

Tool-Aufrufe: lokal und über MCP

Beim ersten Kontakt mit MCP sorgt häufig eines für Verwirrung: Tool-Aufrufe in einem Agent-Harness und Tool-Aufrufe über einen MCP-Server beruhen auf demselben Konzept, nur auf unterschiedlichen Abstraktionsebenen.

In einem lokalen Harness fordert das Modell einen Tool-Aufruf an. Ihr Code ruft daraufhin eine lokale Funktion auf und übermittelt deren Rückgabewert als Tool-Ergebnis an das Modell. Das Tool ist Code, den Sie selbst geschrieben haben und der im selben Prozess oder höchstens in einem von Ihnen kontrollierten Unterprozess läuft. Sie können diesen Code lesen, prüfen und verändern.

MCP erweitert dieses Muster nach außen: Statt eine lokale Funktion aufzurufen, sendet der Agent eine JSON-RPC-2.0-Anfrage an einen MCP-Server, der lokal, auf einem anderen Rechner oder als Remote-Service laufen kann. Für das Modell macht das keinen Unterschied: Aus seiner Sicht hat es ein Tool angefordert und ein Ergebnis erhalten. Die Protokollabstraktion bleibt für die Schlussfolgerungsschicht vollständig unsichtbar – und genau das ist das Problem.

Das macht MCP so leistungsfähig und zugleich so gefährlich: Das Vertrauen des Modells in das Tool verändert sich beim Wechsel von der lokalen Ausführung zu einem Remote-Server nicht, wohl aber Ihre Kontrolle darüber, was dieses Tool tatsächlich tut – und zwar erheblich. Ein lokaler Funktionsaufruf gehört zu Ihrer Codebase und wird überprüft. Ein entfernter MCP-Server ist dagegen ein Netzwerkendpunkt mit eigenem Code, eigener Angriffsfläche und eigenen Vertrauensannahmen.

Prompt Injection, kompromittierte Tools und übermäßige Rechte

Wenn Sie von der lokalen Tool-Ausführung zu MCP wechseln, übernehmen Sie das gesamte Bedrohungsmodell eines Netzwerkdienstes. Das Modell bekommt von diesem Wechsel nichts mit und vertraut den Tool-Ergebnissen weiterhin genauso wie zuvor Ihren lokalen Funktionen. Genau diese Kluft zwischen dem Vertrauen des Modells und dem tatsächlichen Sicherheitsniveau führt zu Problemen.

Der gefährlichste Angriffsvektor ist hier Prompt Injection über Tool-Ergebnisse. Das Modell ruft ein Tool auf, etwa einen Suchserver oder ein Tool zum Lesen von Dateien, und erhält ein Ergebnis, in dessen Inhalt bösartige Anweisungen eingebettet sind. Da das Modell nicht zwischen „Daten, die ich abgerufen habe“ und „Anweisungen, denen ich folgen sollte“ unterscheiden kann, verarbeitet es den eingeschleusten Inhalt als Teil seines Schlussfolgerungskontexts. Das ist kein hypothetisches Szenario, sondern wurde wiederholt an Produktivsystemen demonstriert: Wer beeinflussen kann, was ein Tool zurückgibt, kann auch beeinflussen, was der Agent als Nächstes tut.

Supply-Chain-Angriffe auf MCP-Server folgen demselben Muster, das wir überall sonst beobachten. Hinzu kommt, dass ein kompromittierter Tool-Server Kontext exfiltrieren, Anweisungen einschleusen und sich Zugriff auf die Infrastruktur verschaffen kann – alles über den normalen Ablauf von Tool-Aufrufen, auf dessen Vertrauenswürdigkeit Ihr Harness ausgelegt ist.

Übermäßige Handlungsfreiheit entsteht, wenn wir einem Agenten Autonomie einräumen, ohne ihre Risiken zu berücksichtigen. Dann verfügt er über ein run_command-Tool, doch keine Richtlinie begrenzt die zulässigen Befehle; er hat Datenbankzugangsdaten, doch niemand erzwingt einen ausschließlich lesenden Zugriff. Das sind keine KI-Probleme, sondern Autorisierungsprobleme. Wir haben schlicht vergessen, dieselben Kontrollen anzuwenden, die wir bei jedem anderen automatisierten System anwenden würden.

Trotzdem bauen wir irgendwann alle etwas, das beliebige Befehle in unseren Pipelines ausführt. Passwortloses SSH gefällig? Ansible, Sie sind gemeint. Fügen Sie nun nichtdeterministisches Schlussfolgern und uneingeschränkten Zugriff auf Ihre Infrastruktur hinzu. Sind die digitalen Schafe sicher?

Lerne die Speaker kennen

Die Konferenz zu Delphi & mehr vom 23. - 25. November in Düsseldorf

Mehr erfahren

Agenten, MCP und die tödliche Dreierkombination

Die „tödliche Dreierkombination“ besteht aus drei Fähigkeiten:

• Zugriff auf private Daten → Tools, die Secrets, Repositorys und Dateien lesen können
• Kontakt mit nicht vertrauenswürdigen Inhalten → von Angreifenden kontrollierte Eingaben (Issues, Pull Requests (PRs), Webinhalte)
• externe Kommunikation → jeder Kanal, über den Daten exfiltriert werden können (PRs, WebHooks, E-Mail)

Kommen alle drei zusammen, können Angreifende das System dazu verleiten, private Daten zu lesen und nach außen zu senden. Diese Konstellation ist als „the lethal trifecta for AI agents“ bekannt. Meiner Ansicht nach gilt das für alle unsere Tools, einschließlich MCP-Servern. Die Gefahr entsteht durch die Kombination: Jede Fähigkeit für sich ist beherrschbar, doch zusammen ermöglichen sie es, Daten ohne großen Aufwand zu exfiltrieren. Ein solcher Angriff wurde kürzlich anhand des GitHub-MCP-Exploits demonstriert: Ein Angreifer kann sensible Daten aus einem GitHub-Repository exfiltrieren, indem er einen Prompt in einen KI-Agenten einschleust, der auf das Repository zugreifen kann.

Verankern Sie vorbeugende Maßnahmen wie Isolation und Richtlinien bereits im Systementwurf und sorgen Sie dafür, dass Angriffe auch im laufenden Betrieb erkannt werden. Warnmeldungen und Rate-Limits ergänzen diese Absicherung. Die Gegenmaßnahmen im Überblick:

• Setzen Sie das Prinzip der geringsten Rechte durch: Trennen Sie Tools, die private Daten lesen, von Tools, die Inhalte nach außen veröffentlichen können.
• Behandeln Sie nicht vertrauenswürdige Eingaben als feindlich: Validieren, bereinigen und isolieren Sie sie, bevor Sie sie Agenten zugänglich machen.
• Blockieren Sie ausgehende Kommunikationskanäle von Tools, die auf sensible Daten zugreifen, oder kontrollieren Sie diese Kanäle streng.
• Achten Sie auf verdächtige Muster: Unerwartete Lesezugriffe in Verbindung mit ausgehenden Aktionen müssen Warnmeldungen auslösen.

Den Agenten unter Kontrolle halten

Ein autonomer Agent bietet faktisch die Ausführung von Code aus der Ferne als Funktion – also Remote Code Execution. Wenn Ihnen diese Sichtweise Unbehagen bereitet, dann zu Recht. Ohne robuste Sicherheitsschicht kann ein LLM Dateien löschen, Daten exfiltrieren, interne Dienste ausforschen oder das Hostsystem zum Absturz bringen und Ihnen dabei hilfsbereit erklären, dass es versucht, Ihre Aufgabe zu erledigen. Ein Harness für den Produktiveinsatz braucht wirksame Sicherheitskontrollen, die direkt in den Ausführungspfad eingebaut sind.

Befehlsvalidierung

Jeder Befehl muss vor der Ausführung geprüft werden, und zwar im Harness, nicht nach dem Ermessen des Modells. Dazu gehören eine Denylist für grundsätzlich verbotene Operationen wie rekursives Löschen, das Formatieren von Datenträgern oder das Herunterfahren des Systems sowie eine Allowlist für Befehle, die für die konkrete Aufgabe als sicher gelten. Hinzu kommt ein Musterabgleich mit regulären Ausdrücken, um gefährliche Flags zu erkennen, denn die offensichtlichen Fälle sind offensichtlich, die weniger offensichtlichen eben nicht. Bei Befehlen, deren Zulässigkeit unklar ist, sollte vor der Ausführung eine ausdrückliche menschliche Freigabe erforderlich sein. Ein Mensch braucht Sekunden, um einen Befehl abzulehnen. Löscht ein Befehl dagegen das falsche Verzeichnis, dauert die Wiederherstellung Stunden – sofern sie überhaupt möglich ist.

Pfadvalidierung und Sandbox

Der Dateisystemzugriff muss auf ein festgelegtes Arbeitsverzeichnis beschränkt sein. Jeder Pfad, auf den der Agent zugreifen will, muss zunächst in seine kanonische absolute Form aufgelöst werden; anschließend ist zu prüfen, ob er innerhalb des Wurzelverzeichnisses der Sandbox liegt. Das verhindert Directory-Traversal-Angriffe, bei denen ein Modell versucht, auf etwas zuzugreifen, das zwei oder drei Verzeichnisebenen über dem vorgesehenen Suchbereich liegt – sei es, weil es verwirrt ist, manipuliert wurde oder mit seinem Versuch zu helfen schlicht in die falsche Richtung geht.

Die Kanonisierung muss vor der Prüfung erfolgen, nicht danach. Ein harmlos wirkender relativer Pfad kann nach der Auflösung symbolischer Links auf etwas Gefährliches zeigen: Ein symbolischer Link innerhalb der Sandbox kann auf ein Ziel außerhalb verweisen, ohne dass eine naive Präfixprüfung des noch nicht aufgelösten Pfads das erkennt. Deshalb gilt bei jedem Zugriff: zuerst auflösen, dann den aufgelösten Pfad prüfen – beide Schritte, in genau dieser Reihenfolge.

Human-in-the-Loop

Bei sensiblen Operationen sollte der Harness pausieren und eine ausdrückliche menschliche Freigabe verlangen. Im interaktiven Modus fragt er bei jedem Tool-Aufruf nach: maximale Transparenz, maximale Reibung. Im autonomen Modus werden Lesezugriffe automatisch freigegeben, während Schreibzugriffe und die Ausführung von Befehlen bestätigt werden müssen – die richtige Standardeinstellung für die meisten Workloads im Produktivbetrieb. Der vollautomatische Modus gibt alles ohne menschliche Beteiligung frei. Dafür gibt es berechtigte Einsatzfälle, doch die meisten Produktivsysteme, in denen es zu schweren Vorfällen kam, liefen ohne Monitoring in diesem Modus. Das ist ungefähr so, als würden Sie jemandem die Schlüssel zu Ihrer Infrastruktur überlassen und sich ins Wochenende verabschieden.

Netzwerksicherheit

Wenn der Agent über ein Fetch-Tool verfügt, muss dieses gegen Server-Side Request Forgery geschützt sein. Der Harness muss localhost und Loopback-Adressen blockieren, Anfragen an Ziele ablehnen, deren Namen in private IP-Adressen aufgelöst werden, und die zulässigen Protokolle auf HTTP und HTTPS beschränken. Die Validierung der IP-Adressen muss nach der Domain-Name-System-Auflösung (DNS) erfolgen. Beim DNS-Rebinding wird bei der ersten Abfrage eine öffentliche und bei späteren Abfragen eine private IP-Adresse zurückgegeben – eine Prüfung, die sich nur auf den Hostnamen bezieht, übersieht das jedes Mal.

Ressourcenlimits

Iterationslimits begrenzen die Denkschleifen, während Kontextlimits eine Kürzung nach dem First-in-first-out-Prinzip (FIFO) auslösen, sobald sich der Gesprächsverlauf dem Token-Budget nähert. Ausgabelimits kürzen Tool-Ergebnisse, damit eine riesige Logdatei den Kontext nicht überflutet und die Systemanweisungen verdrängt, denen der Agent folgen soll; ein gekürztes Log ist fast immer nützlicher als ein abgestürzter Agent. Ausführungs-Time-outs beenden Shellbefehle, die deutlich länger laufen, als es die Aufgabe rechtfertigt. Alle vier Mechanismen gehören in die Ausführungs-Engine, nicht in einzelne Tool-Implementierungen. Wird ihre Einhaltung den Tools überlassen, wird irgendwann jemand eines schreiben, das die Begrenzungen nicht durchsetzt.

MCP: nützlicher Standard, neue Angriffsfläche

MCP ist die richtige Idee: Es standardisiert, wie Agenten externe Tools finden und aufrufen. Das Protokoll – JSON-RPC 2.0 über HTTP oder stdio – ist einfach genug, dass seine Implementierung nicht zwangsläufig gefährlich ist. Allerdings zeigt sich auch hier ein vertrautes Problem neuer Integrationsmuster: Entwickler übernehmen das Muster schneller als das dazugehörige Sicherheitsmodell.

In dieser Architektur steht ein MCP-Server zwischen dem KI-Client und Ihren Tools und Daten. Der Client ermittelt, welche Tools verfügbar sind, ruft sie über ihren Namen auf und verarbeitet die Ergebnisse. Dieser Ansatz ist sauber, und seine Komponenten lassen sich gut miteinander kombinieren. Behandeln Sie einen MCP-Server wie jeden anderen Server in Ihrer Pipeline: mit derselben Sicherheitsprüfung, derselben Analyse der Zugriffskontrollen und demselben Monitoring. Auch ein Server mit dem Etikett „KI“ braucht grundlegende Härtung.

Die einzelnen Bedrohungsvektoren sind konkret genug, um sie näher zu beschreiben:

• Beim Tool-Poisoning werden bösartige Anweisungen in Tool-Beschreibungen eingebettet. Das Modell liest diese Beschreibungen, um zu verstehen, was das jeweilige Tool tut. Wer einen Tool-Server kontrolliert, kann dort Anweisungen unterbringen, die vor, während oder nach der vorgesehenen Operation ausgeführt werden. Das Modell kann legitime Dokumentation nicht von bösartigen Anweisungen unterscheiden. Die Spezifikation vom 25.11.2025 legt ausdrücklich fest, dass Tool-Beschreibungen als nicht vertrauenswürdig behandelt werden sollten, sofern sie nicht von einem verifizierten Server stammen – damit wird nun auch formal anerkannt, was Angreifende seit Monaten ausnutzen.
• Das Confused-Deputy-Problem entsteht, wenn ein MCP-Server als Proxy für ein API eines Drittanbieters fungiert. Der Angriff funktioniert, wenn eine statische Client-ID mit dynamischer Client-Registrierung kombiniert wird: Angreifende erstellen eine Anfrage mit einem bösartigen Redirect-URI. Da im Browser bereits ein Zustimmungs-Cookie aus einer früheren legitimen Autorisierung vorliegt, landet der Autorisierungscode auf dem Server der Angreifenden statt auf dem legitimen Server. Die Spezifikation verlangt nun für jeden Client eine gesonderte Zustimmung, die serverseitig gespeichert und vor Beginn jedes Autorisierungsablaufs bei einem Drittanbieter geprüft wird. OAuth-State-Parameter müssen sicher erzeugt, erst nach erteilter Zustimmung gespeichert und als nur einmal verwendbare Werte mit kurzer Gültigkeitsdauer behandelt werden. Wer den Zustimmungs-Cookie schon vor der eigentlichen Zustimmung setzt – eine verbreitete Abkürzung –, macht den Schutz vollständig zunichte.
• Token Passthrough war ein verbreitetes Antipattern: Der MCP-Server akzeptiert Client-Tokens ohne Validierung und reicht sie an nachgelagerte APIs weiter. Die Spezifikation verbietet das nun ausdrücklich mit der Formulierung „MUST NOT“: Server dürfen keine Tokens akzeptieren, die nicht ausdrücklich für sie ausgestellt wurden. Passthrough umgeht das Rate-Limiting, das auf korrekter Tokenvalidierung beruht, macht Audit-Trails unzuverlässig, weil der Server nicht zwischen Aufrufenden unterscheiden kann, und führt dazu, dass ein einziges kompromittiertes Token bei jedem Dienst in der Kette funktioniert.
• Session Hijacking tritt in zwei Formen auf. Bei der Prompt-Injection-Variante senden Angreifende mit Hilfe einer gestohlenen Session-ID ein bösartiges Ereignis an einen zweiten Server. Dieser stellt die Payload in eine Warteschlange, woraufhin der erste Server sie an den legitimen Client ausliefert, der die Anweisungen der Angreifenden ausführt. Bei der zweiten Variante täuschen Angreifende mit der gestohlenen Session-ID eine fremde Identität vor und führen damit direkte Aufrufe aus. Die Spezifikation verlangt, dass Session-IDs kryptografisch sicher und nichtdeterministisch sind und an nutzerspezifische Informationen gebunden werden. Eine Session-ID zur Authentifizierung statt zur Zustandsverwaltung zu verwenden, ist ausdrücklich verboten.
• Die Kompromittierung lokaler Server ist die jüngste Ergänzung des Bedrohungskatalogs. Lokale MCP-Server laufen auf dem Rechner der Nutzer und haben direkten Systemzugriff, was sie zu einem attraktiven Ziel macht. Angreifende betten bösartige Startbefehle in Serverkonfigurationen ein, verteilen Payloads in scheinbar legitimen Paketen oder greifen per DNS-Rebinding auf unsichere localhost-Server zu. Nutzer haben in der Regel keinen Einblick darin, welche Befehle ausgeführt werden, und durch Verschleierung wirken bösartige Befehle unauffällig. Die Spezifikation verlangt nun für die Ein-Klick-Konfiguration Zustimmungsdialoge, die vor der Ausführung den genauen Befehl vollständig und ungekürzt anzeigen.
• Eine unzureichende Scope-Minimierung liegt vor, wenn MCP-Server von Anfang an weitreichende Berechtigungen oder Wildcard-Berechtigungen bereitstellen. Ein einziges gestohlenes Token mit dem Scope files:* oder admin:* ermöglicht Zugriffe weit über die ursprüngliche Operation hinaus. Einzelne Berechtigungen lassen sich dann nicht widerrufen, ohne zugleich alles andere zu beeinträchtigen; außerdem entsteht in den Auditlogs so viel Rauschen, dass kaum noch erkennbar ist, was Nutzer tatsächlich tun wollten. Die Spezifikation verlangt nun eine schrittweise Scope-Erweiterung: mit minimalen Basis-Scopes beginnen und Berechtigungen erst dann erweitern, wenn konkrete privilegierte Operationen erforderlich sind. Das begrenzt das Schadensausmaß, wenn Tokens kompromittiert werden, und macht die Absicht der Nutzer in den Auditlogs nachvollziehbar.

Orchestratoren und Subagenten

In agentischen Systemen im Produktivbetrieb zeichnet sich ein Orchestrator-Modell ab: Ein Agent plant und verteilt die Arbeit, während mehrere spezialisierte Subagenten bestimmte Arten von Aufgaben ausführen – jeweils mit eigenem Tool-Zugriff und eigenem Berechtigungsumfang.

Der Orchestrator kennt das Ziel und weiß, welcher Subagent welchen Teil übernehmen sollte. Er hat keinen direkten Zugriff auf Produktivsysteme, sondern kommuniziert mit Subagenten, die diesen Zugriff haben: Ein Coding-Subagent kann auf Repositorys und Test-Runner zugreifen, ein Such-Subagent auf die Retrieval-Infrastruktur, und ein Infrastruktur-Subagent verfügt über Deployment-Zugangsdaten mit begrenztem Berechtigungsumfang. Der Orchestrator selbst hat auf nichts davon direkten Zugriff.

Dieses Muster überträgt die Trennung von Zuständigkeiten, die wir überall sonst in der Softwarearchitektur anwenden, auf Agentensysteme. Es begrenzt das Schadensausmaß, wenn etwas schiefgeht – und in autonomen Systemen mit externem Tool-Zugriff wird irgendwann etwas schiefgehen. Jeder Subagent erhält nur die wenigen Tools, die er für seine Rolle benötigt. Wo immer möglich, sind die Grenzen strukturell verankert und nicht allein durch Richtlinien festgelegt: Richtlinien lassen sich umgehen, strukturelle Grenzen dagegen nur durch gezieltes Aushebeln.

Tool-Aufrufe überwachen und Auffälligkeiten erkennen

Ein agentisches System zu überwachen bedeutet, seine Tool-Aufrufe zu überwachen, denn sie sind die entscheidenden Handlungsschritte. Protokollieren Sie jeden Tool-Aufruf mit dem Tool-Namen, den Eingaben, einer Zusammenfassung des Ergebnisses und der vorausgegangenen Modellantwort. So erhalten Sie einen vollständigen Audit-Trail, der nachvollziehbar macht, wozu sich der Agent entschieden hat und was bei der Ausführung passiert ist.

Achten Sie auf Muster von Tool-Aufrufen, die nicht zur vorgesehenen Aufgabe passen. Ein Agent, der mitten in einer Codereview plötzlich Dateisystem-Tools aufruft, ist entweder verwirrt oder kompromittiert. Rate-Limiting für Tool-Aufrufe dient nicht nur der Kostenkontrolle, sondern auch der Anomalieerkennung: Steigt die Zahl der Tool-Aufrufe plötzlich stark an, sollten Sie dem nachgehen.

Auch Änderungen an Tool-Definitionen sollten Warnmeldungen auslösen. Gibt ein MCP-Server andere Tool-Beschreibungen zurück als am Vortag, ist das eine Veränderung, die Sie überprüfen sollten. Auf diese Weise lässt sich Tool-Poisoning erkennen – vorausgesetzt, Sie achten darauf.

Versuche zur Scope-Erweiterung – also Versuche des Agenten, auf Ressourcen außerhalb seines zulässigen Berechtigungsumfangs zuzugreifen – sollten Warnmeldungen auslösen, statt lediglich mit einer Zugriffsverweigerung zu enden. Der verweigerte Zugriff zeigt, dass die Sicherheitskontrolle funktioniert; die Warnmeldung macht Sie darauf aufmerksam, dass jemand Ihre Grenzen austestet, das Modell verwirrt ist oder sich in einem vorgelagerten Teil des Systems etwas verändert hat.

Fazit

Agentische KI im SDLC ist längst Gegenwart. Entwicklungsteams bauen und betreiben schon heute Agent-Harnesses, binden MCP-Server ein und verbinden die Harnesses mit Produktivsystemen. Die Sicherheitsanalyse für diese Systeme folgt den vertrauten Prinzipien, die wir schon immer auf automatisierte Systeme mit externem Zugriff angewandt haben. Neu sind die Angriffsfläche, die durch das Vertrauen des Modells in Tool-Ergebnisse entsteht, und die Neigung von Entwicklern, zuerst auszuliefern und erst danach über Autorisierung nachzudenken.

Verstehen Sie die Ausführungsschleife, bevor Sie das System ausliefern, und statten Sie jeden Agenten mit den Tools aus, die er für seine konkrete Rolle tatsächlich benötigt. Validieren Sie Tool-Ergebnisse, bevor Sie auf ihrer Grundlage handeln, und bauen Sie die Sicherheitskontrollen so in die Ausführungs-Engine ein, dass sie nicht umgangen werden können. Behandeln Sie MCP-Server wie die Netzwerkdienste, die sie sind, und konzentrieren Sie sich beim Monitoring auf Tool-Aufrufe: Sie sind die maßgeblichen Handlungsschritte, die sich protokollieren und nachvollziehen lassen.

Die digitalen Schafe sind nur so sicher wie die Hirten, die über sie wachen – und die Hirten müssen wissen, welche Tools sie den Gremlins in die Hand gegeben haben, bevor diese in die Infrastruktur gelangen.

The post KI-Agenten im Entwicklungsprozess absichern appeared first on Entwickler Konferenz.

Masoud Kamali hatte ursprünglich nicht unbedingt vor, in der Informatik zu arbeiten. Er studierte Philosophie und Informatik und lernte während seines Philosophiestudiums in Frankfurt Sebastian Meyen kennen.

„Ich habe zusammen mit Sebastian Meyen in Frankfurt Philosophie studiert. Dort habe ich ihn kennengelernt.“

Die politische Welt veränderte sich zu dieser Zeit grundlegend. Der Kalte Krieg ging zu Ende, vieles geriet in Bewegung. Masoud begann schließlich als Informatiker zu arbeiten – bei dem amerikanischen Softwareunternehmen Borland. Dort lernte er die Softwarebranche kennen. Auch Markus Hebach und Stefan Germer waren zu dieser Zeit bei Borland und wurden später Teil des gemeinsamen Weges.

Doch Borland wurde verkauft, viele Mitarbeiter verließen das Unternehmen – und für Masoud und seine Mitstreiter begann ein neuer Abschnitt. Für sie war das genau die richtige Zeit, um selbst etwas auf die Beine zu stellen. 

Der erste Schritt war noch keine Konferenz.

Es war ein Magazin.

Das Magazin hieß „Der Entwickler – Das Magazin für Delphi, Pascal, C++, Paradox und dBASE Entwickler:innen“ 

Der Name war damals durchaus bewusst gewählt. Masoud und seine Mitstreiter kamen aus dem universitären Umfeld und hatten eine klare Vorstellung davon, wie sie miteinander arbeiten wollten.

„Für uns war es selbstverständlich, dass Frauen respektiert werden, dass es gleiche Gehälter gibt und dass Männer und Frauen gleich behandelt werden.“

Eine solche Haltung war in der Arbeitswelt der damaligen Zeit keineswegs selbstverständlich. Für Masoud und seine Mitstreiter war sie jedoch von Anfang an Teil der Unternehmenskultur, die sie gemeinsam aufbauen wollten.

Das Magazin erschien zunächst alle zwei Monate. In den ersten Ausgaben war Masoud noch stark selbst beteiligt.

„Bei der ersten Ausgabe habe ich ungefähr 40 Prozent selbst geschrieben. Gleichzeitig habe ich Anzeigen verkauft und mich um den Vertrieb gekümmert. Im Grunde hatte ich damals drei Jobs gleichzeitig.“

Das Magazin war der erste Baustein. Weitere Publikationen folgten: 1998 startete das Java Magazin, später kamen weitere Magazine und Konferenzen hinzu.

Eine Veranstaltung sollte dabei eine ganz besondere Rolle spielen: die Entwickler-Konferenz EKON.

Die ersten Jahre der EKON

Heute lassen sich Konferenzen weitgehend digital organisieren. Speaker werden per Mail kontaktiert, Tickets online verkauft und die Community über Social Media erreicht.

In den 1990er-Jahren funktionierte das anders.

Die Entwickler-Community war kleiner und vieles lief über persönliche Kontakte. Genau davon profitierte Masoud auch bei der Entwicklung der EKON. Er hatte während seiner Zeit bei Borland selbst Konferenzen besucht und dort viele Menschen kennengelernt, die später als Autor:innen oder Speaker aktiv wurden.

„Ich war selbst auf Konferenzen, als ich noch bei Borland gearbeitet habe. Da habe ich die Speaker kennengelernt. Man ist zusammen ein Bier trinken gegangen und hat sich unterhalten. Und dann habe ich gefragt: Wir machen ein Magazin – hast du Lust, etwas zu schreiben?“

Auch bei den Autor:innen gab es unterschiedliche Motive. Manche wollten für ihre Artikel bezahlt werden, andere schrieben einfach, weil sie Spaß daran hatten oder sich intensiv mit einem Thema beschäftigten.

Die EKON entstand damit aus persönlichen Kontakten – und aus einem Netzwerk, das Masoud über Jahre aufgebaut hatte.

1996 fand die erste EKON mit 500 Teilnehmenden statt – eine beachtliche Zahl für eine Konferenz, die aus der damals noch überschaubaren Entwickler-Community heraus entstanden war. Insgesamt fanden 70 Sessions statt, außerdem waren 14 Aussteller mit ihren Ständen vertreten. Teilnehmende, Aussteller und Journalisten reisten nicht nur aus Deutschland, sondern unter anderem auch aus den USA, den Niederlanden und der Schweiz an.

In den folgenden Jahren wuchs die Veranstaltung weiter. Dabei ging es Masoud und seinem Team nie ausschließlich um die Vorträge.

„Wir waren eigentlich sehr an dem Umfeld interessiert. Nachts haben wir immer eine Poolparty gemacht – in dem Hotel, wo die Konferenz war.“

Es ging also nicht nur um die Sessions, sondern auch um das Zusammensein nach dem offiziellen Programm. Heute gibt es zwar keine Poolparty mehr wie damals. Aber die Idee dahinter ist geblieben: Die EKON sollte ein Ort sein, an dem Menschen sich treffen, austauschen und gemeinsam Zeit verbringen.

Masoud erinnert sich an eine Situation aus dem Jahr 2001 besonders gut. Er war gerade in Kuba, als ihn eine Nachricht aus dem Büro erreichte.

„Unsere Faxmaschine ist kaputt, weil wir so viele Anmeldungen bekommen.“

Die Resonanz auf die Konferenz war offenbar so groß, dass selbst die Faxmaschine dem Ansturm nicht mehr gewachsen war. Und irgendwann wurde das Wachstum auch bei den Veranstaltungsorten spürbar.

„Das ist so groß geworden, dass das Hotel gesagt hat: Wissen Sie was? Ich erweitere das Hotel für Sie.“

Ein ungewöhnliches Zeichen dafür, wie stark die Konferenz inzwischen gewachsen war.

Irgendwann war aber auch diese Kapazität ausgeschöpft. Die EKON zog weiter und entwickelte sich an verschiedenen Standorten und mit unterschiedlichen Formaten weiter.

Mit der Entwicklerwelt im Wandel

Die EKON entwickelte sich dabei gemeinsam mit der Entwicklerwelt weiter.

Delphi blieb über die Jahre der Kern der EKON. Gleichzeitig veränderte sich die Technologie – und mit ihr die Themen, die Entwickler:innen beschäftigten.

Auch die Konferenzlandschaft von Software & Support Media wurde größer. Neben der EKON entstanden weitere Veranstaltungen – unter anderem JAX, PHP-Konferenzen und weitere Formate rund um neue Technologien.

Masoud beschreibt die Entwicklung als einen Kreislauf: Aus neuen Magazinen entstanden Konferenzen, aus Konferenzen neue Kontakte und daraus wiederum neue Themen und Communities.

Für die EKON blieb Delphi jedoch der Kern. Denn die EKON musste sich nicht jedes Jahr neu erfinden. Sie musste sich vielmehr immer wieder verändern, ohne ihre Verbindung zur Delphi-Community zu verlieren.

Dass die EKON heute 30 Jahre alt wird, lässt sich nur verstehen, wenn man sich vor Augen hält, wie Entwickler:innen damals gearbeitet haben.

Masoud muss darüber lachen, wenn er die heutigen Möglichkeiten mit früher vergleicht.

„Heute hast du ein Problem und googelst es. Damals hatten wir hier 30, 40, 50 Bücher.“

Selbst bei einer einfachen technischen Frage musste man damals zunächst herausfinden, welcher Befehl der richtige war, wie die Syntax lautete und welche Parameter zur Verfügung standen. Antworten fanden sich in Büchern, Handbüchern und Dokumentationen.

Heute reicht dafür oft eine Suchmaschine – oder inzwischen ein KI-Tool.

Für Masoud gibt es dabei sogar eine überraschende Parallele zwischen damals und heute:

„Wir kommen auch ein bisschen zurück wie früher. Damals hast du ls-Befehle geschrieben, heute schreibst du einen Prompt oder einen Agenten. Von der Art und Weise sieht das ziemlich ähnlich aus.“

Die Werkzeuge haben sich verändert. Das Bedürfnis, einem Computer eine Aufgabe zu geben und ein Ergebnis zu bekommen, ist dagegen geblieben.

Auch die EKON selbst hat diese Entwicklung mitgemacht. Im Laufe der Jahre kamen immer neue Themen hinzu. Cloud, REST und Machine Learning wurden wichtiger. 2019 fanden erstmals agile Themen außerhalb des klassischen Delphi-Fokus ihren Weg ins Programm. 2023 bekam auch KI einen festen Platz.

Nicht jede Technologie ist geblieben. Nicht jede Technologie wurde zum großen Trend. Aber die Fragen haben sich immer wieder verändert.

Und genau das zeigt sich auch bei der Jubiläumsausgabe.

30 Jahre später: Was kommt nach dem Programmieren?

Auf der EKON 30 stehen heute Themen auf dem Programm, die Masoud in den Anfangsjahren wahrscheinlich noch nicht erwartet hätte: GitHub Copilot, Coding Agents, Agentic AI, AI-gestützte Entwicklung und AI Squads.

Gleichzeitig bleiben klassische Delphi-Themen Teil des Programms.

Für Masoud wirft die Entwicklung rund um AI aber auch eine grundsätzliche Frage auf:

„Ich glaube schon, dass AI die Chance für eine neue Revolution hat. Nur die Frage ist: Braucht man Programmiersprachen insgesamt noch? Wenn alles für dich programmiert wird, wozu brauchst du dann noch Programmieren?“

Denn wenn KI immer mehr Code erzeugen kann, verändert sich auch die Rolle der Entwickler:innen. Vielleicht geht es in Zukunft weniger darum, jede Zeile Code selbst zu schreiben. Dafür wird es umso wichtiger, zu verstehen, was ein System eigentlich tut, Ergebnisse zu prüfen und Fehler oder falsche Annahmen zu erkennen.

Die Aufgabe verschiebt sich vom Schreiben zum Verstehen, Prüfen und Steuern.

Und damit sind wir wieder bei der Frage, was Softwareentwicklung eigentlich ausmacht.

Was bleibt, wenn sich alles verändert?

Dass die EKON 30 Jahre lang bestehen konnte, hat nicht nur mit Delphi oder einzelnen Technologien zu tun. Es liegt auch daran, dass Menschen Verantwortung übernommen, die Community weitergeführt und immer wieder neue Themen auf die Konferenz gebracht haben.

Masoud bringt es auf den Punkt:

„Bei der EKON ist es eine sehr große Community, die wiederkommt.“

Vielleicht liegt genau darin der wichtigste Teil der Geschichte: Die EKON lebt nicht nur von ihren Themen, sondern von den Menschen, die immer wieder zusammenkommen.

Die Technologie kann sich verändern. Das Bedürfnis nach Austausch bleibt.

2026 feiert die EKON ihr 30-jähriges Jubiläum. Vom 23. bis 27. November 2026 kommt die Delphi-Community in Düsseldorf zusammen. Das Programm verbindet sechs Themenbereiche – von agiler Entwicklung und DevOps über Web, Cloud und Crossplatform bis zu Delphi, Frameworks, Softwarearchitektur und KI. Dazu kommen drei Workshop-Tage und zwei Deep-Dive-Bootcamps.

30 Jahre EKON sind damit auch 30 Jahre Entwicklergeschichte.

Masoud hätte damals nicht erwartet, dass die Konferenz drei Jahrzehnte später noch existiert. Heute steht die EKON 30 vor einer neuen Entwicklungsphase – mit AI, Coding Agents und einer neuen Generation von Entwickler:innen.

Was bleibt, ist das, womit die Geschichte angefangen hat:

Menschen, die zusammenkommen, ihr Wissen teilen und gemeinsam darüber sprechen, wie Softwareentwicklung weitergeht.

The post 30 Jahre EKON – von den Anfängen bis heute appeared first on Entwickler Konferenz.

Hinweis: Dieses Video und dieser Podcast wurden mithilfe von KI erstellt auf Grundlage der ursprünglichen Inhalte sowie den technischen Erkenntnissen des Autors des Blogartikels.

Dieser Bericht untersucht einen spezifischen methodischen Rahmen, der auf der Integration von fünf zentralen APIs basiert, die der Extraktion, Übersetzung und Analyse von Informationen aus Karten und Bildmaterial dienen. Diese Analyse verdeutlicht den Wandel von der einfachen statischen Objekterkennung hin zu „echter Intelligenz“ – der Fähigkeit, Objektwahrscheinlichkeiten durch Korrelation zu bestätigen.

Das Feld entwickelt sich über einfache Computervision hinaus hin zu umfassenden Umweltanalysen, einschließlich Trendidentifizierung und Anomalieerkennung in Umweltzeitreihen ( Abb. 1 ).

Geospatiale künstliche Intelligenz (GeoAI) ist als Integration von Geodaten und KI zu einem der sich am schnellsten entwickelnden Forschungsbereiche in der räumlichen Datenwissenschaft und Geografie geworden. Die Analyse von Geodaten dient dazu, Erkenntnisse über Objekte und Ereignisse in Bezug auf Raum und Zeit zu gewinnen, etwa das Auswerten potenzieller Solaranlagen auf Hausflächen.

Wir fokussieren uns hier auf fünf APIs zur Informationsgewinnung aus Karten oder Bildern:

1. Objekterkennungs-API (Similarity DB) bietet schnelle Bilderkennung mit Hilfe fortschrittlicher neuronaler Netze. Gibt Labels, Konfidenzwerte und Begrenzungsrahmenkoordinaten zurück.

2. Bild-zu-Text-API nutzt Algorithmen zur optischen Zeichenerkennung (OCR), um Text aus Bildern zu extrahieren, einschließlich unterschiedlicher Größen, Schriftarten und Handschrift.

3. Sprachübersetzer-Shell übersetzt extrahierten Text (z. B. von einem Bildschild) in verschiedene Sprachen oder in Symbole.

4. Länder- und Hauptstadt-API stellt geografische, demografische und wirtschaftliche Statistiken zu Ländern und Städten bereit, basierend auf erkannten Standorten oder GEO-Koordinaten.

5. Zufallsgenerator für Bilder (zum Trainieren/Testen von Daten) generiert szenische Bilder für Trainingsdaten, Platzhalter und Designzwecke und unterstützt benutzerdefinierte Kategorien und Größen.

Diese APIs bzw. Komponenten ermöglichen die Objekterkennung, die Ähnlichkeitssuche und die Extraktion geografischer Statistiken zur Bestimmung des standortbezogenen Kontexts.

Das Objekterkennungs-API filtert Ergebnisse anhand eines Konfidenzschwellenwerts. Objekte mit einem Konfidenzwert unter 0,3 (30 Prozent) werden ausgeschlossen. Die Ausgabe ist typischerweise ein JSON-Array mit folgenden Informationen:

• Label: der identifizierte Objekttyp (z. B. „Auto“, „Zaun“)

• Konfidenzwert: die Wahrscheinlichkeit der Richtigkeit (z. B. 0,78)

• Begrenzungsrahmen (BoundingBox): Koordinaten (x1, y1, x2, y2), die die Position des Objekts im Bild definieren

Das Konzept korrelierter Objekte

Echte Intelligenz im GEOINT-Kontext bedeutet, die Wahrscheinlichkeit eines Objekts durch die Identifizierung eines zweiten, korrelierten Objekts zu bestätigen. Ein Beispiel: In einer Szene mit einem Zaun erhöht die Anwesenheit von Autos vor diesem Zaun die statistische Wahrscheinlichkeit, dass es sich beim ersten Objekt tatsächlich um einen zugehörigen Zaun handelt (Abb. 2).

Szenenanalyse: In einer „standardisierten Szene“ identifizieren Systeme Häuser, Autos, Zäune, Menschen, Wolken, Bäume und nicht identifizierte Objekte wie Bahnschranken oder weiß-rote Fackeln.

API-Anfragekonfiguration

Für eine erfolgreiche Datenextraktion sind bestimmte Headerkonfigurationen erforderlich, insbesondere für die Authentifizierung und Autorisierung. Das Headerformat lautet:  headers.add(‚X-Api-Key:‘ + aAPIKey) ; Die Autorisierung wird durch einen User-Agent im Header deklariert.

Fehlerbehandlung: Häufige Fehlerquellen sind fehlende oder unvollständige Header oder Syntaxfehler in Dateipfaden (z. B. unerwartete Zeichen nach Zeilenumbrüchen) sowie unpassende Formatierung des mit  get  oder  post  zu sendenden URL zu  encode  und  decode . Beispielsweise müssen Dateipfade in  ExecStr  korrekt maskiert werden, um Syntaxfehler zu vermeiden, wie der Code in Listing 1 [3] als Funktionsblock zeigt.

Eintrag 1

function APIGetGeoCountry(AURL,url_name, aAPIKey: string): string;
var encodedURL:String;  cnt: integer; ajt:TJson;  JObj: TJSonObject2; JArr: TJSonArray2;
  begin
    encodedURL:= Format(AURL,[urlencode(url_name)]);
    with THttpRequestC.create(self) do
      try
        writ('geo_reqsend: '+encodedurl)
        headers.add('X-Api-Key:'+aAPIkey);
        if Get(encodedURL) then begin
          result:= (Response.ContentAsString)
          ajt:= TJson.create();
          ajt.parse(Response.ContentAsString);
          Jarr:= ajt.JsonArray;
          jobj:= jarr[0].asobject;
          for cnt:= 0 to Jobj.count-1 do
            writ(jobj.items[cnt].name);
          writ('surface_area: '+(jobj.values['surface_area'].asstring));    
        end 
          else Writeln('APIError '+inttostr(Response.StatusCode2));
      except
        writeln('HTTPS: '+ExceptiontoString(exceptiontype,exceptionparam));
      finally
        ajt.Free;
        free;
      end;
  end;

 

GEOINT hat sich in den vergangenen Jahren deutlich weiterentwickelt. In früheren Anwendungen gab es eine spezielle Computervision mit Fokus auf Mustererkennung in Luft- und Bahndaten sowie Klassifizierung von Punktwolken. Das Spektrum hat sich mittlerweile erweitert und umfasst nun:

• Auswertung von Umweltzeitreihen

• Identifizierung geografischer Trends

• meteorologische Analysen (Wetter oder Katastrophen)

• Klimaanalyse und Bevölkerungsstimmung

• Anomalieerkennung und Warnungen

Fazit

Die Integration von KI in geografische Informationssysteme hat sich von spezialisierten Nischenanwendungen zu einem breiten Spektrum innovativer Technologien entwickelt. Durch die Nutzung spezieller APIs – von OCR bis zu wirtschafts- und demografischen Daten – können GEOINT-Systeme Rohbilder in verwertbare räumliche Informationen umwandeln.

Die Zukunft des Fachgebiets liegt in seiner Fähigkeit, komplexe Zeitreihen zu verarbeiten und global wie lokale Anomalien mit zunehmender Präzision zu identifizieren.

The post KI hilft Geodaten auf die Sprünge appeared first on Entwickler Konferenz.

Alternativen und Optionen

Es gibt folgende Alternativen zur vorgestellten Konfiguration:

• RAD Studio kann unmittelbar auf einem Windows-PC, d. h. ohne Virtualisierung ausgeführt werden. Der Zugriff auf einen iOS-Simulator kann dann über das lokale Netzwerk erfolgen. Ein Android-Emulator kann auf dem Windows-PC ausgeführt werden (x64-Architektur, langsam).

• Hilfsweise kann statt eines physischen Macs auch ein Cloud-Service genutzt werden. Auf diesem können dann Xcode und der Simulator installiert werden. Ein geeigneter Service ist beispielsweise [5]. Auf diesen Cloud-Computer wird in diesem Fall via Remote-Desktop zugegriffen. Ein physisches iPhone kann dann jedoch nicht zum Testen genutzt werden.

In jedem Fall gilt: Ab einem gewissen Fortschritt in der Entwicklung der Mobile-App muss diese regelmäßig auf physischen Geräten, d. h. Android-Smartphones und iPhones, getestet werden. Einige Features, wie beispielsweise die Sensibilität von Sensoren, lassen sich nur bedingt mit Hilfe von Emulation bzw. Simulation prüfen. Im Idealfall stehen in einem professionellen Entwickler-Set-up zum Testen mehrere Geräte mit unterschiedlicher Hard- und Softwareausstattung (Betriebssystemversionen) zur Verfügung.

Hinweis (bzw. eine ganz persönliche Anmerkung): Bitte lassen Sie sich bei der Konfiguration nicht frustrieren. Die Einrichtung der Developer-Pipeline für die Mobile-Entwicklung (Android, iOS) ist nicht trivial. Versionen und Tools müssen zueinander passen und die richtigen Befehle müssen auf der Kommandozeile eingegeben werden. Wenn man sich mit Konsole und Netzwerk nicht auskennt, ist es eine Herausforderung und es ist ganz normal, dass man einiges ausprobieren muss. Der Autor hat die Schritte zusammengestellt, um Android und iOS aus RAD Studio auf einer Maschine nutzbar zu machen. Das liest sich im Ergebnis einfach und logisch, doch der Weg bis zur Erkenntnis war bedeutend länger.

Mobile-Apps mit Delphi – Projektstart

Eine Mobile-Delphi-Anwendung startet man in der IDE typischerweise über Datei | Neu | Multi-Device-Anwendung (Abb. 9).

Es stehen verschiedene Projektvorlagen bereit (z. B. leere Anwendung oder Tabbed Template), die bereits eine Grundstruktur für Android und iOS enthalten. Die Projektgruppe enthält von Anfang an Einträge für beide Zielplattformen, und im Projektmanager kann man zwischen Android und iOS Device 64-bit (bzw. iOS Simulator, falls ein Apple Silicon Mac verfügbar ist) umschalten. Praktisch gesehen unterscheidet sich die Projektanlage kaum von einer VCL-Anwendung – abgesehen von der Auswahl eines FireMonkey-Projekts. Delphi legt eine Unit mit einer Formularklasse (einer Ableitung von TForm) an, die für Mobile-Apps üblicherweise zunächst die Namen Unit1.pas/Form1.fmx trägt. Darin befindet sich der gemeinsame Quelltext für beide Plattformen. Plattformspezifische Anpassungen kann man über Compilerdirektiven vornehmen (z. B. mit {IFDEF ANDROID} / {IFDEF IOS}). Soll beispielsweise unter iOS ein abweichender Programmablauf erfolgen, lässt sich das zur Not mit solchen Direktiven im Code lösen. Doch in vielen Fällen ist das gar nicht notwendig. Im Idealfall bleibt die Codebasis vollständig plattformneutral.

RAD Studio bietet viele abstrakte Klassen und Services, die Android und iOS vereinheitlichen – vom Dateisystemzugriff über HTTP-Anfragen bis hin zu Threading oder GUI-Komponenten. So kann man den Großteil der App-Logik ohne besondere Berücksichtigung des Ziel-OS entwickeln. Erst bei wirklich systemspezifischen Funktionen kommt man an einen Punkt, an dem man gezielt Code für eine Plattform schreiben muss.

Bevor die App erstmals gestartet wird, müssen einige Projekteinstellungen überprüft werden. Im Options-Dialog des Projekts wird der Application Identifier (Bundle-ID) festgelegt und es werden gegebenenfalls die benötigten Berechtigungen hinterlegt. So müssen für die Nutzung des Gerätestandorts (GPS) beispielsweise in Android die entsprechenden Berechtigungen (ACCESS_FINE_LOCATION etc.) aktiviert werden, damit Delphi sie in die Android-Manifest-Datei einträgt. Unter iOS wiederum muss sichergestellt werden, dass in der Datei Info.plist ein Eintrag für NSLocationWhenInUseUsageDescription vorhanden ist. Das kann ebenfalls über die Delphi-Projekteinstellungen konfiguriert werden. RAD Studio kümmert sich dann um die richtige Einbindung dieser Parameter ins Deployment. Für viele Standardfälle bringt Delphi bereits sinnvolle Voreinstellungen mit. Beispielsweise werden bei Verwendung der TCameraComponent automatisch die Kameraberechtigungen angefordert. Entwickler:innen behalten dennoch die Flexibilität, diese Einstellungen an ihre eigenen Erfordernisse anzupassen.

UI-Design mit FireMonkey

Die Benutzeroberfläche wird mit dem FireMonkey-Framework gestaltet, das einen grafischen Multi-Device-Designer (Abb. 10) bereitstellt.

Alle visuellen Komponenten, beispielsweise Buttons, Listen oder Eingabefelder, werden per Drag and Drop auf das Formular gezogen und dort ausgerichtet. Der Clou dabei ist, dass dieses eine Formular als Master-Form für alle Geräte dient. Das UI wird also einmal entworfen – und anschließend werden die gerätespezifischen Verfeinerungen vorgenommen, ohne dass der Code aufgespalten werden muss. Dabei erlaubt Delphi, sogenannte View-Varianten für unterschiedliche Auflösungen oder Formfaktoren anzulegen. So kann man beispielsweise eine spezielle iPhone-Ansicht definieren, in der bestimmte Elemente speziell angeordnet oder skaliert sind. Diese Varianten erben sämtliche Elemente und Logik von der Master-Form, lassen sich aber im Layout getrennt anpassen. In der Praxis bedeutet das: Ein Großteil des UI-Designs wird plattformübergreifend entworfen und nur dort nachjustiert, wo es nötig ist, beispielsweise bei größeren Bildschirmen, einem anderen Seitenverhältnis oder der Ausrichtung im Hoch- oder Querformat. Delphi bietet darüber hinaus eine Multi-Device-Vorschau an. Im Designer kann man sich das Formular parallel auf verschiedenen Gerätedummies anzeigen lassen, z. B. als iPhone 14 und als Android-Tablet. Das ist sehr hilfreich, um das responsive Design der Oberfläche früh zu überprüfen.

FireMonkey selbst setzt auf hardwarebeschleunigtes Rendering. Anders als die VCL (die auf nativen Windows-Controls basiert) zeichnet FMX sämtliche Steuerelemente selbst – plattformunabhängig und mittels GPU. Dadurch sind flüssige Animationen und aufwendige Grafikeffekte möglich, die von der Grafikkarte des Geräts profitieren. Standard-Controls wie Buttons oder Listboxen folgen dem Style-Prinzip, d. h. sie werden durch Style-Vorlagen dem jeweiligen Betriebssystem optisch nachempfunden. FMX bringt für Android und iOS eigene Style-Sets mit, sodass z. B. ein TSwitch-Schalter unter iOS wie ein nativer iOS-Umschalter aussieht. Über den Behavior Service passen sich zudem gewisse Verhaltensweisen automatisch an. So werden Tabs auf iOS am unteren Bildschirmrand, auf Android hingegen oben angezeigt.

Entwickler:innen können das Look and Feel auch vollständig selbst gestalten: Über den FMX Style Designer oder durch Zuweisung von alternativen Styles (Dark/Light Theme etc.) erhält man volle Kontrolle über die Optik. Auch plattformnative Controls lassen sich in FireMonkey einbinden.

Moderne FireMonkey-Oberflächen sind durch die GPU-Nutzung in der Regel sehr performant, allerdings erkauft durch einen initialen Overhead beim App-Start. Das Starten einer FMX-App dauert erfahrungsgemäß etwas länger als das Starten einer minimalistischen nativen App, da zunächst die FMX-Bibliothek geladen werden muss. In der Praxis bewegt sich das auf aktuellen Geräten jedoch im Rahmen von ein bis zwei Sekunden. Die Laufzeitperformance der Anwendung, beispielsweise beim Scrollen durch Listen, dem Öffnen von Formularen oder dem Durchführen von Berechnungen ist dagegen nahezu identisch mit der von nativen Apps, da der übersetzte Maschinencode ohne Zwischenschicht auf der CPU läuft. Durch die statische Verlinkung aller benötigten Bibliotheken liegt die App-Größe meist etwas über der von vergleichbaren nativen Apps. Angesichts heutiger Gerätespeicher ist das jedoch selten ein Problem. Insgesamt lässt sich festhalten, dass FireMonkey-UIs bei korrekter Verwendung hinreichend performant sind und den Nutzer:innen ein zeitgemäßes Nutzungserlebnis bieten.

Nutzung von Gerätesensoren

Eine Stärke von Delphi für Mobile ist der einfache Zugriff auf Gerätesensoren. Die RTL (Run Time Library) umfasst dafür vordefinierten Komponenten und Klassen, die die Sensorhardware abstrahieren. So gibt es beispielsweise eine Komponente TLocationSensor, die GPS-Geodaten liefert, einen TMotionSensor (für Beschleunigungssensor/Gyroskop), einen TOrientationSensor (Lagesensor/Kompass) sowie die TCameraComponent für den Zugriff auf die Kamera (Abb. 11).

Diese nicht visuellen Komponenten werden bei Bedarf auf das Formular gezogen. Anschließend kann dann über Ereignisse und Methoden auf die Sensordaten zugegriffen werden. Ein Beispiel: Durch Setzen von LocationSensor.Active := True startet die Standorterfassung. Über das Ereignis OnLocationChanged liefert die Komponente anschließend die aktuellen Breiten- und Längengrade, auf die im Code reagiert werden kann, beispielsweise um die Position auf einer Karte anzuzeigen.

Delphi kapselt hierbei die Unterschiede der Plattformen. Ob die Positionsdaten nun vom iOS-Dienst oder vom Android-Location-Provider stammen, braucht Entwickler:innen nicht zu kümmern. Ähnlich funktioniert TMotionSensor für Beschleunigungs- und Rotationsdaten, die beispielsweise zur Erkennung von Bewegungen oder zur Steuerung eines Spiels genutzt werden können. Auch auf die Gerätekamera kann mit wenig Aufwand zugegriffen werden. Die einfachste Methode stellt die Action TTakePhotoFromCameraAction dar: Platziert man diese Aktion und verknüpft sie mit einem Button, öffnet ein Tipp darauf direkt die native Kamera-App des Geräts, erlaubt das Aufnehmen eines Fotos und liefert das Bild anschließend zurück in die Delphi-Anwendung. Will man mehr Kontrolle, verwendet man die TCameraComponent. Diese bietet Funktionen, um die Kamera direkt im eigenen App-Fenster zu aktivieren, Fotos oder Videos aufzunehmen und z. B. zwischen Front- und Rückkamera umzuschalten. Einstellungen wie Auflösung oder Fokusmodus können ebenfalls gesetzt werden. So lassen sich umfangreiche Kamerafunktionen bis hin zu QR-Code-Scannern oder AR-Anwendungen realisieren, wobei für spezialisierte Anforderungen ggf. ein plattformspezifischer API-Aufruf nötig ist.

Neben GPS, Bewegungssensoren und Kamera unterstützt Delphi zahlreiche weitere Hardwarefeatures. Erwähnenswert ist die Bluetooth/BLE-Unterstützung: In RAD Studio gibt es also Komponenten sowohl für klassisches Bluetooth als auch für Bluetooth Low Energy.

Ein Aspekt, den es bei der Nutzung von Sensoren zu beachten gilt, sind die Berechtigungen. Wie zuvor erwähnt, müssen bestimmte Berechtigungen deklariert werden, wenn sie benötigt werden. Darüber hinaus erfordern neuere Android- und iOS-Versionen oft auch eine Bestätigung durch den Nutzer zur Laufzeit (Runtime Permission). Delphi stellt Hilfsfunktionen bereit, um diese Berechtigungen zur Laufzeit abzufragen und zu verarbeiten. Entwickler:innen sollten also beim ersten Zugriff auf Kamera, Mikrofon, Standort etc. überprüfen, ob die App bereits die entsprechende Freigabe hat. Falls dies nicht der Fall ist, sollte eine Anfrage an den User gestellt werden. Dies lässt sich mit wenigen Codezeilen umsetzen und entspricht dem Vorgehen in anderen Entwicklungsumgebungen.

Einbindung von System-APIs

Trotz des breiten Spektrums an vorkonfektionierten Komponenten kommt es in der Mobile-Entwicklung gelegentlich vor, dass eine sehr spezifische Plattformfunktion benötigt wird, sei es eine besondere Apple- oder Google-API, die (noch) nicht Teil von FireMonkey oder einer Drittanbieter-Bibliothek ist. Ein großer Vorteil von Delphi ist, dass man in solchen Fällen direkt auf die nativen APIs der Zielplattform zugreifen kann. Delphi bietet zu diesem Zweck sogenannte Bridge Units und Header-Übersetzungen an. Für iOS existieren in Delphi beispielsweise Namespaces wie iOSapi.Foundation oder iOSapi.UIKit, die die Objective-C-Klassen und -Funktionen des Apple SDK verfügbar machen. Darüber lassen sich beliebige iOS-Frameworks ansprechen, als würde man in Swift oder Objective-C programmieren.

Ein Beispiel: Möchte man Touch ID bzw. Face ID nutzen, kann man die entsprechenden Routinen aus Apples LocalAuthentication-Framework über Delphi aufrufen, entweder indem man die mitgelieferten Header-Übersetzungen verwendet oder indem man bei neueren APIs selbst Interfacedefinitionen schreibt. Ähnlich verhält es sich bei Android: Hierfür stellt Embarcadero den Java2OP-Converter bereit, der Java-Bibliotheken in Delphi-Code (Interfaceklassen) umwandelt. So kann man beispielsweise eine spezielle Android-SDK-Funktion nutzen, die nicht im FMX-Standardumfang enthalten ist, indem man die Java-Methode nach Delphi importiert. Delphi kompiliert im Hintergrund die entsprechenden JNI-Aufrufe, sodass die App zur Laufzeit die Android-JVM nutzen kann, um diese Funktionen auszuführen. Dieser Weg, direkt mit nativen APIs zu arbeiten, erfordert zwar etwas zusätzlichen Aufwand, gewährleistet aber, dass keine Funktionalität der Plattform unerreichbar bleibt.

In der Praxis gibt es dafür auch Communityunterstützung: Es stehen einige Open-Source-Projekte und Bibliotheken zur Verfügung, die gängige Mobile-Dienste kapseln und erweiterte System-APIs für Delphi bereitstellen.

Geeignete Use Cases und Grenzen

Es zeigt sich, dass Delphi (RAD Studio) im Jahr 2025 ein ausgereiftes Ökosystem für die Mobile-Entwicklung bietet. Die Stärken liegen vor allem in der Produktivität: schnelles visuelles Entwickeln, Wiederverwendung von Code und Komponenten sowie eine Codebasis für alle Plattformen. Diese Vorteile kommen insbesondere in folgenden Anwendungsfällen zum Tragen:

• Business- und Enterprise-Apps: Delphi eignet sich hervorragend, um datenbankgetriebene Anwendungen oder Unternehmenssoftware für mobile Endgeräte bereitzustellen. Bestehende Delphi-/VCL-Kenntnisse und -Code (z. B. Datenmodule mit FireDAC oder Logik aus einer Windows-Anwendung) lassen sich wiederverwenden, um eine passende Mobile-App als Ergänzung zu entwickeln. Wenn eine Firma bereits über eine umfangreiche Delphi-Codebasis verfügt, ist der Schritt zu Android-/iOS-Apps effizient umzusetzen.

• Cross-Plattform-Projekte mit knapper Timeline: Wenn man „schnell“ eine App für Android und iOS gleichzeitig benötigt, ermöglichen die RAD-Prinzipien von Delphi ein rasches Vorgehen. Mit einem kleinen Team erreicht man Ergebnisse, für die man nativ eventuell zwei Teams bräuchte. Gerade Prototypen für Start-ups oder Pilotprojekte können so in kurzer Zeit umgesetzt werden, ohne dass man sich von Beginn an auf eine Plattform festlegen muss.

• Industrie und spezialisierte Hardware: In Fällen, in denen Geräte mit besonderer Hardware angesteuert werden, etwa Barcodescanner, Messgeräte oder Spezialsensoren auf Android-Geräten, fällt Delphis Nähe zur Hardware besonders ins Gewicht. Man kann native Bibliotheken der Hardwarehersteller einbinden und hat volle Kontrolle über serielle Schnittstellen, Bluetooth-Protokolle usw. – und das alles in Delphi, ohne auf C++ oder Java wechseln zu müssen.

• Multi-Platform-Desktop-Mobile-Kombinationsprojekte: Wenn eine Anwendung nicht nur auf Mobile-Geräten, sondern auch auf Windows-, macOS- und Linux-Desktops laufen soll, bietet Delphi den Vorteil, dass FireMonkey auch Desktopplattformen bedienen kann. Weite Teile der Codebasis können für Desktop und Mobile gemeinsam genutzt werden, es müssen nur das UI und Details angepasst werden. Diese „Write once, compile everywhere“-Fähigkeit ist ein Leistungsmerkmal.

Selbstverständlich gibt es auch Grenzen und Szenarien, in denen Delphi weniger geeignet ist. Grafikintensive Spiele etwa werden meist in spezialisierten Engines (Unreal, Unity etc.) entwickelt. Zwar unterstützt Delphi 2D-/3D-Grafik mit FMX, die Developer-Community in diesem Bereich ist jedoch kleiner. Anwendungen, die zu 100 Prozent an die nativen UI-Richtlinien einer Plattform angepasst sein müssen, können mit Delphi zwar umgesetzt werden, erfordern aber mitunter zusätzlichen Feinschliff beim Styling, damit sie pixelgenau wie eine typische iOS- oder Android-App aussehen. Wenn das oberste Ziel darin besteht, dass niemand einen Unterschied zu den Apple Human Interface Guidelines oder zum Material Design erkennen kann, muss man in der Delphi-Entwicklung bewusst mit Styles und gegebenenfalls mit nativen Controls arbeiten.

Ein weiterer Punkt sind externe Frameworks und Ökosystemabhängigkeiten. Für Android und iOS existiert eine Fülle an Open-Source-Bibliotheken, deren Direktverwendung in Delphi jedoch nicht immer trivial ist. Zwar lassen sich nichtvisuelle Bibliotheken meist problemlos einbinden, doch bei komplexen UI-Komponenten oder plattformspezifischen Cloud-SDKs kann die Integration aufwendiger werden.

Auch das Tooling rund um die App (Build-Pipelines, CI/CD, UI-Testautomation) ist für Delphi weniger standardisiert verfügbar als für Xcode bzw. Android Studio. Eine Rolle spielen dabei nicht zuletzt der Kostenfaktor und die strategische Ausrichtung: RAD Studio ist ein kommerzielles Produkt und auf dem Markt gibt es weniger Entwickler:innen für Delphi Mobile als für die großen Plattformsprachen. Für lange Projektlaufzeiten und sehr große Teams kann das ein Kriterium sein.

Praxisbeispiel

Nun zeigen wir, wie eine Mobile-App mit Delphi und FireMonkey entwickelt werden kann. Am Beispiel wird praxisnah demonstriert, wie die typischen Anforderungen einer Mobile-App – Zugriff auf Kamera, Sensoren, lokale Datenhaltung und UI-Darstellung – mit Delphi umgesetzt werden können. Die App soll die folgenden Kernfunktionen bereitstellen:

• Fotoaufnahme direkt über die integrierte Kamera oder das System-Kamera-Interface,

• Geodatenerfassung zum Zeitpunkt der Aufnahme,

• Zusatznotizen pro Bild zur kontextuellen Dokumentation,

• Speicherung der Metadaten lokal auf dem mobilen Device,

• Galerieansicht, in der alle Fotos mit Miniaturansicht, Aufnahmezeit und Standortinformationen gelistet werden,

• ggf. Detailansicht und Teilen-Funktion, um Bilder samt Metadaten über die native Share-Sheet-Funktion des Betriebssystems weiterzugeben.

Einen ersten Eindruck vom geplanten Vorhaben liefert der folgende Prototyp (Abb. 12).

Sehen wir uns wesentliche Schritte der Umsetzung an:

1. Man kann beispielsweise die Vorlage Geräteübergreifende Anwendung mit Kopf- und Fußzeile auf der Basis von FireMonkey wählen. So erhält man ein Grundgerüst zur Gestaltung des User Interfaces auf mobilen Geräten.

2. Gestalten wir nun das User Interface des Hauptformulars: Dazu platzieren wir eine Kopf- und eine Fußzeile (TToolBar) sowie einen Layoutcontainer, der den restlichen Platz für die Medienliste (Content) einnimmt.

3. Als dynamische Liste verwenden wir eine TListView-Komponente. Diese können wir individuell gestalten, d. h., wir können festlegen, wie die einzelnen Listenelemente angezeigt werden.

4. Für die Datenhaltung definieren wir eine Klasse TPhoto, die die Daten zu den Bildern, Orten und Merkmalswerten verwaltet. Die Liste der Objekte wird in einem Datentyp nach dem Schema FPhotos: TObjectList<TPhoto> gespeichert.

5. Zum Aufnehmen von Bildern mit der Kamera bietet RAD Studio die Schnittstelle FMX.MediaLibrary.IFMXCameraService. Mit Hilfe dieser Schnittstelle kann die Kamera plattformübergreifend auf iOS und Android genutzt werden [6]. Denken Sie daran, die entsprechenden Berechtigungen für die Plattformen gemäß Dokumentation zu setzen.

6. Zur Ermittlung des Standorts steht die Komponente System.Sensors.Components.TLocationSensor zur Verfügung. Sie kapselt den Zugriff auf die Ortungsdienste für die Zielsysteme [7]. Auch hier sind Berechtigungen in den Projekteigenschaften erforderlich.

7. Die Datenspeicherung auf dem mobilen Device kann in einer lokalen SQLite-Datenbank erfolgen. Dazu wird aus Delphi die FireDAC-Bibliothek genutzt [8].

Mit diesen Schritten ist das grundsätzliche Vorgehen zur Programmierung unserer Beispiel-App für Android und iOS skizziert. Einen ersten Eindruck von der App auf iOS und Android vermitteln Abbildung 13 und 14.

Während der laufenden Entwicklung ist es oft sinnvoll, die Funktionsweise schnell zu überprüfen. Das kann in vielen Fällen dadurch geschehen, dass man die App direkt als Windows-Applikation ausführt. Dank der Cross-Platform-Fähigkeit ist das kein Problem.

Fazit

Im Jahr 2025 eignet sich Delphi für geschäftliche Apps, Prototypen und alle Projekte, bei denen eine schnelle Entwicklung für mehrere Plattformen gefragt ist und die volle native Performance wichtig ist. Die Möglichkeiten reichen von klassischen Formular- und Datenbank-Apps über multimediale Anwendungen bis hin zu IoT-nahen Lösungen mit Sensorintegration. Die Grenzen liegen vor allem dort, wo extreme Plattformtreue im UI oder die maximale Nutzung des jeweiligen nativen Ökosystems verlangt wird – in diesen Fällen kann Delphi zwar mithalten, es ist jedoch mehr Handarbeit erforderlich. Für viele Anwendungen im üblichen Rahmen bietet Delphi jedoch einen ausgewogenen Kompromiss aus Entwicklungstempo, Codeeffizienz und Anwendungsleistung, wodurch es zu einer attraktiven Option für Mobile-Entwickler:innen wird.

Frequently Asked Questions (FAQ)

1. Wofür eignet sich Delphi 2025 in der Mobile-Entwicklung?
   Delphi eignet sich insbesondere für geschäftliche Apps, Prototypen und Cross-Plattform-Projekte, bei denen schnelle Entwicklung und native Performance gefragt sind. Es unterstützt Android, iOS und in Kombination auch Desktop-Plattformen.
2. Wie startet man ein Mobile-Projekt in Delphi?
   Ein Mobile-Projekt wird in der IDE über „Datei | Neu | Multi-Device-Anwendung“ angelegt. Vorlagen wie leere Anwendungen oder Tabbed Templates liefern eine Grundstruktur für Android und iOS.
3. Wie wird das User Interface mit FireMonkey gestaltet?
   Die UI wird im grafischen Multi-Device-Designer per Drag-and-Drop erstellt. Master-Formulare dienen allen Geräten, während View-Varianten für unterschiedliche Auflösungen und Formfaktoren nachjustiert werden können.
4. Wie erfolgt der Zugriff auf Gerätesensoren?
   Delphi stellt Komponenten wie TLocationSensor, TMotionSensor, TOrientationSensor und TCameraComponent bereit. Diese abstrahieren die Plattformunterschiede und erlauben den Zugriff auf GPS, Bewegungssensoren, Kamera und weitere Hardware.
5. Welche Berechtigungen müssen Entwickler berücksichtigen?
   Für Sensoren wie Kamera, GPS oder Mikrofon müssen Berechtigungen in den Projekteinstellungen hinterlegt werden. Neuere Android- und iOS-Versionen erfordern zusätzlich Runtime Permissions, die Delphi unterstützt.
6. Kann Delphi auf plattformspezifische APIs zugreifen?
   Ja, über Bridge Units, Header-Übersetzungen und Namespaces wie iOSapi.Foundation oder Java2OP können native Funktionen direkt genutzt werden. So lassen sich Apple- oder Android-spezifische Features in Delphi einbinden.
7. Welche Projektarten profitieren besonders von Delphi?
   Delphi eignet sich für Business- und Enterprise-Apps, Cross-Plattform-Projekte mit knapper Timeline, Industrieanwendungen mit spezieller Hardware und Multi-Platform-Desktop-Mobile-Kombinationsprojekte.
8. Wo liegen die Grenzen von Delphi in der Mobile-Entwicklung?
   Delphi ist weniger geeignet für grafikintensive Spiele, extrem plattformtreue UI-Anforderungen oder komplexe Drittanbieter-Frameworks. Auch das Tooling und die Community sind im Vergleich zu Xcode oder Android Studio begrenzter.

Links & Literatur

[1] https://www.embarcadero.com/products/rad-studio/whats-new-in-12-athens

[2] https://docwiki.embarcadero.com/RADStudio/Athens/en/Running_Your_iOS_Application_on_the_iOS_Simulator

[3] https://www.embarcadero.com/starthere/xe7/mobdevsetup/android/en/running_your_android_application_on_an_android_emulator.html

[4] https://docwiki.embarcadero.com/RADStudio/Athens/de/Installieren_des_Platform_Assistant_auf_dem_Mac.

[5] https://www.macincloud.com

[6] https://docwiki.embarcadero.com/RADStudio/Athens/en/Taking_Pictures_Using_FireMonkey_Interfaces

[7] https://docwiki.embarcadero.com/RADStudio/Sydney/en/Mobile_Tutorial:_Using_Location_Sensors_(iOS_and_Android)

[8] https://docwiki.embarcadero.com/RADStudio/Sydney/de/Mobile-Tutorial:_Verwenden_von_FireDAC_in_mobilen_Anwendungen_(iOS_und_Android)

[9] https://github.com/veikkoEF/PhotoAndLocation/settings

[10] https://entwickler-konferenz.de/bootcamp-delphi-cross-platform-entwicklung-fuer-ios-und-android

The post Entwicklungspraxis, Sensorik und Bewertung von Delphi Mobile appeared first on Entwickler Konferenz.

Set-up und Konfiguration für iOS-Apps

Der iOS-Simulator läuft unter macOS. Dieser soll aus RAD Studio (Windows) angesprochen werden, d. h., wir möchten das App-Package darauf installieren.

1. Installation unter macOS: Zunächst ist es notwendig, unter macOS die integrierte Entwicklungsumgebung Xcode (kostenfrei im App-Store erhältlich) zu installieren. Der Simulator für iOS wird im Zusammenhang mit Xcode eingerichtet. Über die Einstellungen von Xcode können auch unterschiedliche Versionen des Simulators (iPhone, iPad, verschiedene iOS-Versionen) installiert werden. Nach der Installation können Sie die Funktionsfähigkeit des Simulators eigenständig prüfen. Eventuell werden beim ersten Start noch notwendige Befehlszeilentools nachträglich eingerichtet. Um den iOS-Simulator aus RAD Studio über das Netzwerk fernzusteuern, wird das Tool PAServer (Platform Assistent Server) benötigt. Dieses können Sie von der Embarcadero-Webseite (RAD Studio) herunterladen. Die passende PAServer-Version zur entsprechenden RAD-Studio-Version finden Sie unter [4]. Achten Sie insgesamt darauf, dass die Versionen von iOS, Xcode, RAD Studio und PAServer miteinander kompatibel sind. Wenn etwas nicht funktioniert und die Fehlermeldung nicht eindeutig ist bzw. die Ursache unklar ist, kann eine neue Version eines Tools bereits die Lösung sein. Das Problem der Kompatibilität unterschiedlicher Softwareversionen tritt bei allen plattformübergreifenden Ansätzen zutage. Es kann also problematisch werden, wenn man unbedacht ein Update anstößt. Ein Beispiel: Man aktualisiert die iOS-Version auf seinem Endgerät. Um Apps für diese neue Version zu erstellen, ist auch ein Update von Xcode notwendig. So weit, so gut. Gleichzeitig muss jedoch auch die IDE RAD Studio mit den neuen Versionen von Xcode und iOS kompatibel sein. Hier gilt also: Nicht jedes Update sollte unmittelbar – ohne Prüfung der Auswirkungen auf die gesamte Entwicklungsumgebung – installiert werden. Etwas Sorgfalt zahlt sich hier oftmals aus. Mit diesen Schritten ist die Einrichtung auf macOS abgeschlossen. Wir notieren (kopieren) noch die IP-Adresse des Macs, um diesen über das Netzwerk erreichen zu können. Zum Abschluss starten wir PAServer. Bei aktivierter Instanz bleibt das zugehörige Terminalfenster geöffnet (Abb. 1).

1. Installation unter Windows: In RAD Studio aktivieren wir das Ziel iOS-Simulator im Projektmappen-Explorer. Anschließend müssen wir das entsprechende iOS-SDK zuweisen und installieren. Außerdem soll eine Verbindung zum Mac hergestellt werden. Dazu ist die IP-Adresse im entsprechenden Dialogfeld von RAD Studio einzugeben (Abb. 2). Sind diese Schritte abgeschlossen, werden die verfügbaren iOS-Simulatoren im Projektmappen-Explorer angezeigt (Abb. 3). Nun kann die aktive App auf dem ausgewählten Gerät installiert, ausgeführt und bei Bedarf auch debuggt werden.

Set-up und Konfiguration für Android-Apps

Wir sollen einen Android-Emulator unter macOS (ARM) einrichten und ihn über eine Netzwerkverbindung aus der virtuellen Maschine heraus mit RAD Studio nutzen. Dazu müssen wir die folgenden Schritte ausführen:

Installation des Emulators unter macOS: Am besten laden Sie Android Studio für macOS/ARM herunter und installieren es. Über das Startmenü von Android Studio kann man unmittelbar den Virtual Device Manager für die virtuellen Geräte aufrufen und mit dessen Hilfe einen Android-Emulator einrichten (Abb. 4).

Ist das erfolgt, testen Sie direkt den Start des Emulators. Sie werden die gute Performance auf einem ARM-Gerät spüren. Für den Zugriff auf den Emulator von „außen“ (Netzwerk) benötigen wir das Tool ADB (Android Debug Bridge). ADB ist ein zentrales Entwicklerwerkzeug im Android-Ökosystem, das eine direkte Schnittstelle zwischen einem Computer und einem Android-Gerät bereitstellt. Es ermöglicht die Verbindung von Geräten über USB oder ein Netzwerk und die Ausführung vielfältiger Aktionen – vom Installieren und Testen von Apps über den Zugriff auf Systemlogs bis hin zur Steuerung des Geräts per Kommandozeile. Typische Anwendungsfälle sind die Installation von APK-Dateien, das Auslesen von Logdaten zur Fehlersuche oder der Start einer interaktiven Shell, um direkt mit dem Android-Betriebssystem zu arbeiten. ADB installieren Sie (wenn noch nicht geschehen) über den SDK-Manager. Diesen erreichen Sie am einfachsten auch über Android Studio. Installieren Sie die Android SDK Platform-Tools. Ist das erfolgreich erledigt, dann können wir über die Konsole mit der ADB arbeiten.

Arbeiten auf macOS: Suchen Sie auf macOS den Pfad, unter dem die Android-SDK-Platform-Tools installiert sind. Das ist üblicherweise der Ordner ~/Library/Android/sdk/platform-tools. Öffnen Sie diesen Pfad in einem Terminal auf macOS. Starten Sie ebenfalls den zuvor installierten Emulator. Mit dem Befehl

./adb devices

 

sollte eine Liste der aktuellen (laufenden) Emulatoren angezeigt werden (Abb. 5).

Prüfen Sie dies, da die nächsten Schritte sonst nicht funktionieren. Damit der Emulator über das Netzwerk erreichbar ist, muss der ADB-Server gestartet und so konfiguriert werden, dass er auf eingehende Netzwerkabfragen lauscht. Das erreichen Sie folgendermaßen: Zuerst muss ein möglicherweise laufender Server mit dem folgenden Befehl beendet werden:

./adb kill-server

 

Nun können wir den Server neu starten und so konfigurieren, dass er auf eingehende Netzwerkverbindungen lauscht. Geben Sie dazu im Terminal ein:

./adb -a -P 5037 nodaemon server

 

Sie erhalten verschiedene Logging-Meldungen und das Terminalfenster bleibt intern blockiert. Das ist der Hinweis, dass der Server läuft (Abb. 6).

Lassen Sie das Terminalfenster unbedingt geöffnet. Öffnen Sie auf macOS ein zweites Terminal-Fenster und prüfen Sie den Status des Servers mit folgendem Befehl:

sudo lsof -nP -iTCP:5037 -sTCP:LISTEN

 

Sie werden zur Passworteingabe aufgefordert und erhalten eine Ausgabe, die angibt, auf welchen Netzwerkkanälen der ADB-Server lauscht. Wichtig ist der Verweis auf TCP/IP und den Port 5037. In der Standardkonfiguration lauscht der Server auf localhost (127.0.0.1). Mit unserem Befehl haben wir ihn dazu gebracht auch auf die eingehende Netzwerkverbindung zu achten. Ist das geschafft, ist die Konfiguration auf Seiten von macOS abgeschlossen. Weiter geht es mit Windows in unserer virtuellen Maschine.

Arbeiten unter Windows: Mit der Installation von RAD Studio wurde die Plattform Android hinzugefügt. Auch unter Windows benötigen wir die Android-SDK-Tools. Sofern die Installation vollständig ist, finden sich die SDK-Tools in der Regel im folgenden Verzeichnis: C:\Users\Public\Documents\Embarcadero\Studio\23.0\CatalogRepository\AndroidSDK-2525-23.0.55362.2017\platform-tools>.

Wechseln Sie in der Windows PowerShell in dieses Verzeichnis. Ebenso benötigen wir die IP-Adresse des Macs. Wechseln Sie dazu erneut auf den Mac und notieren bzw. kopieren Sie die IP-Adresse aus den Netzwerkeinstellungen. Geben Sie in der PowerShell-Konsole folgenden Befehl ein:

setx ADB_SERVER_SOCKET "tcp:192.168.2.128:5037"

 

Ersetzen Sie diese IP-Adresse durch die IP-Adresse Ihres Macs. Den Port belassen Sie auf 5037. Damit weisen Sie die ADB unter Windows an, die verfügbaren Geräte über das Netzwerk abzurufen. Anschließend sollten Sie die folgende Meldung erhalten: „ERFOLGREICH: Angegebener Wert wurde gespeichert.“

Nun folgt der spannende Test, ob wir den laufenden Android-Emulator von macOS von Windows aus sehen können. Geben Sie dazu in die PowerShell-Konsole ein:

./adb -H 192.168.2.128 -P 5037 Devise

 

Bitte ersetzen Sie wieder den Wert der IP-Adresse. Das Ergebnis sollte eine Liste der Android-Emulatoren von macOS sein (Abb. 7).

Android Emulator in RAD Studio verwenden: Starten Sie RAD Studio neu und öffnen Sie ein Multi-Device-Projekt, das unter anderem Android als Zielsystem hat. Im Projektmappen-Explorer wechseln Sie zu Zielsysteme | Android 64-Bit. Beim ersten Aufruf müssen Sie hier ggf. noch das Android-SDK zuweisen. Aktualisieren Sie anschließend den Pfadziel (Abb. 8).

Darunter sollte der Emulator, also das virtuelle Android-Gerät, erscheinen. Wenn das der Fall ist, haben Sie einen wichtigen Schritt gemeistert. Nun können Sie Ihre App aus RAD Studio auf dem Android-Emulator unter macOS ausführen. Herzlichen Glückwunsch!

Im dritten Teil unserer Serie zeigen wir ein praxisnahes Beispiel für die Umsetzung einer Mobile-App mit Delphi, inklusive Kamera, Geodaten und lokaler Datenspeicherung.

 Frequently Asked Questions (FAQ)

1. Welche Voraussetzungen sind notwendig, um einen iOS-Simulator unter macOS einzurichten?
   Man benötigt Xcode, das kostenlos im Mac App Store erhältlich ist, sowie die Installation der gewünschten Simulator-Versionen über die Xcode-Einstellungen. Zusätzlich müssen eventuelle Befehlszeilentools installiert und PAServer für die Netzwerkverbindung zu RAD Studio eingerichtet werden.
2. Wie stellt RAD Studio auf Windows eine Verbindung zum iOS-Simulator auf dem Mac her?
   In RAD Studio wird das iOS-SDK zugewiesen, das Ziel iOS-Simulator aktiviert und die IP-Adresse des Macs eingegeben. Nach Abschluss werden die verfügbaren Simulatoren im Projektmappen-Explorer angezeigt.
3. Was ist PAServer und welche Funktion erfüllt es?
   PAServer (Platform Assistant Server) ermöglicht die Fernsteuerung des iOS-Simulators über das Netzwerk von RAD Studio aus. Es muss auf dem Mac gestartet und eine aktive Terminalinstanz geöffnet bleiben.
4. Wie wird ein Android-Emulator unter macOS installiert und getestet?
   Android Studio wird installiert, anschließend über den Virtual Device Manager ein Emulator erstellt. Der Start des Emulators sollte direkt überprüft werden, um die Funktion und Performance zu testen.
5. Welche Rolle spielt ADB bei der Nutzung eines Android-Emulators von externen Systemen?
   ADB (Android Debug Bridge) stellt eine Schnittstelle zwischen Computer und Android-Gerät bereit, ermöglicht Installation, Test und Debugging von Apps sowie Zugriff auf Systemlogs. Für die Netzwerkverbindung muss der ADB-Server gestartet und für eingehende Verbindungen konfiguriert werden.
6. Wie wird der Android-Emulator von macOS aus in einer Windows-Umgebung zugänglich gemacht?
   Unter Windows wird die IP-Adresse des Macs in der PowerShell mit setx ADB_SERVER_SOCKET eingetragen. Anschließend kann der Emulator über den Befehl ./adb -H <IP> -P 5037 devices aufgelistet werden.
7. Wie kann der Android-Emulator in RAD Studio genutzt werden?
   Nach Neustart von RAD Studio wird das Multi-Device-Projekt geöffnet, das Android als Zielsystem enthält. Der Pfad zum Android-SDK wird ggf. zugewiesen, danach erscheint der Emulator im Projektmappen-Explorer und kann zum Ausführen von Apps verwendet werden.
8. Welche Kompatibilitätsaspekte sind bei plattformübergreifender Entwicklung zu beachten?
   Versionen von iOS, Xcode, RAD Studio und PAServer müssen miteinander kompatibel sein. Updates sollten nur nach Prüfung der Auswirkungen auf die gesamte Entwicklungsumgebung durchgeführt werden, um Probleme zu vermeiden.

Links & Literatur

[1] https://www.embarcadero.com/products/rad-studio/whats-new-in-12-athens

[2] https://docwiki.embarcadero.com/RADStudio/Athens/en/Running_Your_iOS_Application_on_the_iOS_Simulator

[3] https://www.embarcadero.com/starthere/xe7/mobdevsetup/android/en/running_your_android_application_on_an_android_emulator.html

[4] https://docwiki.embarcadero.com/RADStudio/Athens/de/Installieren_des_Platform_Assistant_auf_dem_Mac.

[5] https://www.macincloud.com

[6] https://docwiki.embarcadero.com/RADStudio/Athens/en/Taking_Pictures_Using_FireMonkey_Interfaces

[7] https://docwiki.embarcadero.com/RADStudio/Sydney/en/Mobile_Tutorial:_Using_Location_Sensors_(iOS_and_Android)

[8] https://docwiki.embarcadero.com/RADStudio/Sydney/de/Mobile-Tutorial:_Verwenden_von_FireDAC_in_mobilen_Anwendungen_(iOS_und_Android)

[9] https://github.com/veikkoEF/PhotoAndLocation/settings

[10] https://entwickler-konferenz.de/bootcamp-delphi-cross-platform-entwicklung-fuer-ios-und-android

The post Cross-Platform-Setup – iOS- und Android-Entwicklung mit RAD Studio appeared first on Entwickler Konferenz.

Zielplattformen und Anforderungen

Mit Blick auf die Mobile-Plattformen unterstützt RAD Studio seit dem Update auf Version 12.3 iOS 18 und Android 15 mit API-Level 35 [1]. Delphi läuft ausschließlich auf einem Windows-Betriebssystem. Für die plattformspezifische Entwicklung (Android, iOS) sind daher spezifische Build-Schritte notwendig. Für iOS bedeutet das: Kompilierung, Signierung und Deployment erfolgen über einen Mac mit installiertem Xcode und PAServer. Delphi unterstützt den iOS-Simulator, jedoch ausschließlich auf ARM-basierten Macs, d. h. den neueren Prozessoren Apple Silicon M1 bis M4. Im Umkehrschluss bedeutet das, dass eine entwickelte iOS-App nicht auf dem Simulator eines Intel-Macs gestartet werden kann [2]. In diesem Fall bleibt nur der Test auf physischen Geräten, d. h., man muss ein iPhone via WLAN oder USB mit dem Mac koppeln.

Für Android ist die vollständige Toolchain (SDK, NDK, Gradle und Emulatoren) direkt in die IDE integriert. Zwar lassen sich Apps auch im Android-Emulator ausführen, dieser ist jedoch oft sehr langsam und bietet nur eingeschränkten Support für Hardwarefunktionen wie GPS, Kamera oder Sensoren. Embarcadero, das Unternehmen, das Delphi entwickelt und vertreibt, empfiehlt deshalb, für Tests ein physisches Android-Gerät zu verwenden [3]. Auf diesen Punkt kommen wir im Laufe des Artikels nochmals zurück. Die Kombination aus Entwicklung auf einem Windows-Rechner und plattformspezifischer Build-Infrastruktur ist durch die Nutzung von mehreren Betriebssystemen (Windows, macOS, Android, iOS) durchaus komplex, jedoch auch ein typisches Merkmal der plattformübergreifenden Programmierung.

Systemumgebung aufsetzen

Die Entwicklung von Cross-Platform-Apps, d. h. in diesem Fall von Apps für mobile Geräte mit den Betriebssystemen iOS und Android, erfordert einige Überlegungen und gelegentlich auch etwas „Bastelarbeit“. Im Folgenden wird eine Konfiguration vorgestellt, die eine gute Ausgangsbasis für die Entwicklung von Mobile-Apps darstellt und die Nutzung von Emulator (Android) und Simulator (iOS) ermöglicht. Wir gehen auf die folgenden Punkte ein:

• Systemumgebung: Windows mit RAD Studio

• Verbindung zu einem iOS-Simulator

• Verbindung zu einem Android-Emulator

Entwicklermaschine mit RAD Studio auf Windows in einer virtuellen Maschine

Als Entwicklermaschine haben wir einen leistungsstarken Mac, beispielsweise ein MacBook Pro, gewählt. Damit ist eine Entwicklung für beide Zielsysteme (iOS und Android) möglich. Prinzipiell ist auch eine Entwicklung für die Desktopsysteme Windows, macOS und Linux möglich, die hier jedoch außen vor bleibt. Es kommt ein Mac mit einem ARM-Prozessor (M1 bis M4) und ausreichend Arbeitsspeicher sowie CPU-Leistung zum Einsatz.

Für diese Wahl gibt es mehrere Gründe. Zum einen kann der iOS-Simulator aus RAD Studio nur in der ARM-Version genutzt werden (siehe oben). Auch der Android-Emulator arbeitet auf einem ARM-Prozessor besser. Delphi kompiliert native Android-Apps, die unmittelbar auf den Android-Geräten installiert und ausgeführt werden. Um traditionell einen Android-Emulator auf einem Desktop-PC (x64-Architektur) nutzen zu können, musste beim Aufsetzen des Emulators ein entsprechendes x64-Image gewählt werden. Wurde ein ARM-Image gewählt, musste der Hostcomputer die Übersetzung zwischen den Betriebssystemen (x64 nach ARM) aufwendig durchführen. Das führte zu einer sehr langsamen Ausführungsgeschwindigkeit des Android-Emulators.

Da Delphi native, ARM-basierte Android-Apps kompiliert, konnten diese nicht vernünftig auf einem Emulator getestet werden. In der Dokumentation wurde daher darauf hingewiesen, dass man zum Testen besser direkt ein physisches Gerät einsetzt. Mit den neuen ARM-Prozessoren von Macs sieht die Sache anders aus. Hier entfällt die Übersetzung zwischen ARM- und x64-Architekturen, da sowohl macOS als auch Android auf der ARM-Architektur basieren.

Zur Einrichtung der Entwicklungsumgebung nutzen wir die Virtualisierungslösung Parallels unter macOS. In Parallels können wir ein Windows-System installieren. Dabei installiert Parallels die ARM-Version von Windows. Die Installation und Einrichtung erfolgen zügig und werden durch einen Assistenten von Parallels unterstützt. Auf dem ARM-basierten Windows kann anschließend RAD Studio nach bekanntem Muster installiert werden. Windows ARM kann auch x64-Programme ausführen.

Es gelten jedoch folgende Zusammenhänge: RAD Studio selbst existiert derzeit nicht als native ARM64-Version für Windows, sondern ausschließlich für klassische x86- und x64-Systeme. Auf einem Windows-on-ARM-Gerät (hier eine virtuelle Maschine) wird die IDE daher über die integrierte Emulationsschicht von Windows 11 ausgeführt. Diese Emulation ermöglicht die Ausführung von 32- und 64-Bit-x86-Anwendungen und stellt somit eine hohe Kompatibilität sicher. Ist die Hardwareplattform ausreichend leistungsfähig, sind Einschränkungen in der Ausführungsgeschwindigkeit nicht störend bzw. nicht bemerkbar. Insbesondere bei rechenintensiven Aufgaben und größeren Projekten kann dieser Umstand jedoch von Bedeutung sein. Auch die mit RAD Studio erzeugten Windows-Anwendungen liegen standardmäßig als Win32- oder Win64-Binarys vor und laufen auf Windows-on-ARM ebenfalls nur über die Emulation. Eine direkte Unterstützung der Zielplattform Windows ARM64 ist derzeit nicht vorgesehen, anders als bei iOS, Android oder Linux, wo RAD Studio bereits native ARM-Compiler anbietet. Das bedeutet für Entwickler:innen, dass ihre Delphi- oder C++Builder-Anwendungen auf ARM-basierten Windows-Geräten zwar grundsätzlich lauffähig sind, jedoch nicht die Performance erreichen, die mit einer nativen ARM64-Build-Toolchain möglich wäre.

Zusammenfassend können wir festhalten, dass wir RAD Studio zur Entwicklung auf einem ARM-basierten Windows ausführen können und keine größeren Einschränkungen festgestellt haben. Auch Windows-Apps (hier nur für Tests interessant) lassen sich damit erstellen.

Kommen wir nun zur Einrichtung der Systemkonfiguration für die Erstellung von Mobile-Apps für iOS (Simulator) und Android (Emulator). Beginnen wir mit iOS.

Dies ist der erste Teil unserer Artikelserie „Mobile-Apps mit Delphi – eine Review über Möglichkeiten und Grenzen“. Im nächsten Artikel erfährst du mehr über die konkrete Projektanlage, das UI-Design mit FireMonkey und die Nutzung von Gerätesensoren. Anschließend folgt der dritte Teil mit einem praxisnahen Beispiel für die App-Entwicklung.

Frequently Asked Questions (FAQ)

1. Was ist Delphi for Mobile und wofür wird es verwendet?
   Delphi for Mobile ist eine Entwicklungsumgebung für native Mobile-Apps, die es ermöglicht, Android- und iOS-Anwendungen aus einer gemeinsamen Codebasis zu erstellen. Der Fokus liegt auf schneller Entwicklung (Rapid Application Development) und nativer Performance.
2. Welche Plattformen und Betriebssysteme werden unterstützt?
   RAD Studio 12.3 unterstützt Android 15 (API-Level 35) und iOS 18. Die Entwicklungsumgebung selbst läuft ausschließlich auf Windows, für iOS-Builds wird zusätzlich ein Mac mit Xcode und PAServer benötigt.
3. Wie funktioniert die plattformübergreifende Entwicklung mit Delphi?
   Mit dem FireMonkey-Framework (FMX) lassen sich Benutzeroberflächen für Android und iOS gleichzeitig grafisch gestalten. Object Pascal wird direkt zu nativen Binarys kompiliert, wodurch keine Laufzeitumgebungen oder virtuelle Maschinen auf den Zielgeräten benötigt werden.
4. Welche Voraussetzungen gelten für die Nutzung von Simulatoren und Emulatoren?
   iOS-Simulatoren werden nur auf ARM-basierten Macs (Apple Silicon M1–M4) unterstützt; Intel-Macs benötigen physische Geräte. Android-Emulatoren sind in der IDE integriert, laufen aber oft langsam, weshalb für Tests physische Android-Geräte empfohlen werden.
5. Wie wird die Entwicklungsumgebung für Mobile-Apps eingerichtet?
   Die Basis ist ein Windows-Rechner mit RAD Studio, der über Parallels auf einem ARM-basierten Mac virtualisiert werden kann. So lassen sich sowohl der iOS-Simulator als auch der Android-Emulator nutzen, wobei die Emulation von x86/x64 auf ARM erfolgt.
6. Welche Einschränkungen bestehen bei der Nutzung von Windows-on-ARM?
   RAD Studio läuft auf Windows-on-ARM nur über die integrierte Emulation für x86- und x64-Programme. Native ARM64-Builds für Windows werden derzeit nicht unterstützt, was die Performance bei rechenintensiven Projekten begrenzen kann.
7. Welche Komponenten und Tools beschleunigen die App-Entwicklung?
   FireMonkey für UI-Design, FireDAC für Datenzugriff und ein konfigurierbarer REST-Client ermöglichen schnelle Umsetzung. Komponentenwiederverwendung und visuelles Design tragen zusätzlich zur Entwicklungsbeschleunigung bei.
8. Für welche Szenarien eignet sich Delphi besonders? Delphi eignet sich für Projekte, die schnelle Markteinführung, native Performance und eine gemeinsame Codebasis für Android und iOS erfordern. Der gleiche Code könnte auch für Desktop-Systeme wie Windows, macOS oder Linux genutzt werden, wird hier aber nicht im Detail behandelt.

Links & Literatur

[1] https://www.embarcadero.com/products/rad-studio/whats-new-in-12-athens

[2] https://docwiki.embarcadero.com/RADStudio/Athens/en/Running_Your_iOS_Application_on_the_iOS_Simulator

[3] https://www.embarcadero.com/starthere/xe7/mobdevsetup/android/en/running_your_android_application_on_an_android_emulator.html

[4] https://docwiki.embarcadero.com/RADStudio/Athens/de/Installieren_des_Platform_Assistant_auf_dem_Mac.

[5] https://www.macincloud.com

[6] https://docwiki.embarcadero.com/RADStudio/Athens/en/Taking_Pictures_Using_FireMonkey_Interfaces

[7] https://docwiki.embarcadero.com/RADStudio/Sydney/en/Mobile_Tutorial:_Using_Location_Sensors_(iOS_and_Android)

[8] https://docwiki.embarcadero.com/RADStudio/Sydney/de/Mobile-Tutorial:_Verwenden_von_FireDAC_in_mobilen_Anwendungen_(iOS_und_Android)

[9] https://github.com/veikkoEF/PhotoAndLocation/settings

[10] https://entwickler-konferenz.de/bootcamp-delphi-cross-platform-entwicklung-fuer-ios-und-android

The post Delphi for Mobile – Grundlagen, Plattformen und Entwicklungsumgebung appeared first on Entwickler Konferenz.

In einer Zeit, in der sich Web-Entwicklungstrends ständig wandeln, erleben wir eine bemerkenswerte Rückkehr zu den Wurzeln: Server-Side Rendering (SSR) erlebt durch moderne Werkzeuge wie RAD Studio WebStencils eine Renaissance. In diesem Artikel werden Sie genau diese Technologie grundlegend kennenlernen, die Ihnen helfen wird, Ihre Webanwendungen schneller und effizienter zu entwickeln. Bevor wir in die Welt der WebStencils eintauchen, werfen wir einen Blick auf die Evolution der Web-Entwicklung und die Herausforderungen, die mit modernen Ansätzen verbunden sind. Anschließend werden die Grundlagen von WebStencils anhand

von einfachen Desktop-Anwendungen vermittelt – von der Komplexität einer Webanwendung sind wir hier noch weit entfernt. Abschließend werden wir eine simple Webseite mit Inhalten aus einer Datenbank mit WebStencils erstellen, um die Möglichkeiten dieser neuen Technologie zu demonstrieren.

Die Evolution der Web-Entwicklung

• Die Web-Entwicklung hat in den letzten Jahren einen interessanten Kreislauf durchlaufen. Während in den 2010er Jahren Client-Side Rendering mit Frameworks wie Angular und React dominierte, zeigen sich heute die Grenzen dieser Architektur:
  Längere First-Paint-Zeiten: Die Zeit, bis der Benutzer etwas sieht, ist oft recht lang.
• Herausforderungen bei der SEO-Optimierung: Suchmaschinen haben Schwierigkeiten, den Inhalt von SPAs zu indexieren.
• Hohe JavaScript-Bundle-Größen: Die Größe der JavaScript-Bundles kann die Ladezeiten erheblich beeinflussen. Gerade bei der Nutzung auf mobilen Geräten macht sich das schnell bemerkbar.
• Komplexe State-Management-Anforderungen: Die Verwaltung des Anwendungsstatus kann schnell unübersichtlich werden.

Ironischerweise gab es in den Anfangsjahren des Webs eine klare Trennung zwischen Server- und Client-Rendering. Mit der Einführung von SPAs verschwammen diese Grenzen zunehmend, was zu einer Vielzahl von Herausforderungen führte. Mit Delphi DataSnap und RAD Server wurden bereits vor vielen Jahren Lösungen für diese Probleme entwickelt. Allerdings waren diese Lösungen nicht in der Lage, die Vorteile von SSR zu nutzen. Insbesondere mit RAD Server wurden andere Ziele verfolgt. Es ging um die Entwicklung von REST-APIs und nicht um die Entwicklung von Webanwendungen. Mit RAD Studio WebStencils wird diese Lücke nun geschlossen. Zudem stellt Embarcadero mit WebStencils auch zahlreiche Beispiele für den Einsatz von HTMX auf der Client Seite bereit, die die Möglichkeiten von WebStencils eindrucksvoll demonstrieren. Ohne JavaScript-Frameworks, ohne Node.js und ohne Build-Prozesse kann so nun eine moderne Webanwendung entwickelt werden. Eine Erweiterung mit JavaScript-Frameworks ist jederzeit möglich. Selbstverständlich steht mit TypeScript auch eine typisierte Sprache im Web zur Verfügng, die immer mehr an Prägnanz gewinnt und ebenso mit WebStencils benutzt werden kann. Auch der Einsatz mit anderen Web Frameworks ist möglich. WebStencils kann z.B. auch mit TMS WEB Core genutzt werden. TMS WEB Core ist insbesondere für Delphi Entwickler interessant, da es die Entwicklung von SPAs mit Object Pascal ermöglicht und kein Erlernen einer neuen Programmiersprache erforderlich ist.

RAD Studio WebStencils: Die moderne Antwort mit einer bewährten Programmierumgebung

RAD Studio WebStencils vereint die Vorteile klassischer Server-Side Rendering-Ansätze mit modernen Entwicklungspraktiken. Das Framework ermöglicht:

• Schnellere initiale Seitenladezeiten: Es wird weniger bis gar kein JavaScript benötigt. Der Server liefert die Seite in Form von HTML und CSS direkt an den Client.
• Verbesserte Suchmaschinenoptimierung: Suchmaschinen können den Inhalt der Seite problemlos indexieren. Verschiedene Seiten werden mit unterschiedlichen URLs bereitgestellt.
• Reduzierte Client-Last: Der Client muss weniger JavaScript verarbeiten, was die Leistung auf mobilen Geräten verbessert.
• Optimierte Entwicklungszyklen: Die Entwicklung wird durch die Verwendung von Delphi und RAD Studio erheblich beschleunigt.
• Direktes Einbinden von Datenbankabfragen: Datenbankabfragen können auf dem Server direkt durchgeführt werden. Sie können bekannte Datenbankkomponenten und Frameworks in Delphi verwenden. Eine Implementierung einer REST API ist somit nicht erforderlich.
• Nutzung von CSS- und HTML-Templates: WebStencils wurden im Hinblick auf das Verwenden von CSS- und HTML-Templates entwickelt. Sie können Ihre bestehenden Templates problemlos integrieren.
• Einfache Integration von REST-APIs: REST-APIs können serverseitig integriert werden, um Daten zu laden und anzuzeigen. Selbstverständlich können Sie auch REST-APIs auf der Client-Seite verwenden.
• Unterstützung von HTMX: WebStencils wurden von Embarcadero im Hinblick auf die Verwendung mit HTMX konzipiert, um die Interaktivität der Anwendung zu erhöhen. Bei HTMX handelt es sich um eine Bibliothek, die zusätzliche HTML Attribute bereitstellt. Es ist keine Programmierung von JavaScript erforderlich. Trotzdem ermöglicht HTMX es Ihnen z.B., HTML-Elemente dynamisch zu aktualisieren, ohne die gesamte Seite neu laden zu müssen.

Der Trend zur Rückkehr zum Server-Side Rendering, auch “SSR Renaissance” genannt, zeigt sich nicht nur bei WebStencils. Frameworks wie Next.js, Remix und Nuxt.js folgen einem ähnlichen Ansatz. Dies unterstreicht die wachsende Erkenntnis, dass ein hybrider Ansatz aus Server- und Client-Rendering oft die beste Lösung darstellt.

Diese Evolution markiert einen wichtigen Wendepunkt in der Web-Entwicklung, bei dem RAD Studio Web-Stencils eine Schlüsselrolle einnimmt.

Und was passiert mit den Single Page Applications und dazugehörigen Frameworks?

WebStencils haben nicht das Ziel verfolgt, Single Page Applications (SPAs) zu ersetzen, sondern um sie zu ergänzen. WebStencils können problemlos in bestehende SPAs integriert werden. Sie können sie verwenden, um bestimmte Teile Ihrer Anwendung serverseitig zu rendern, während andere Teile weiterhin als SPAs funktionieren. Somit können Sie die Vorteile beider Ansätze nutzen
und ihr gewohntes Web Framework, wie z.B. TMS WEB Core, weiterhin verwenden.

In vielen Fällen ist eine hybride Lösung die beste Wahl. WebStencils ermöglicht es Entwicklern, die Vorteile beider Ansätze zu nutzen und maßgeschneiderte Lösungen für ihre spezifischen Anforderungen zu erstellen. Insbesondere in TMS WEB Core führt die Kombination von SSR und SPAs zu einer kürzeren und effizienteren Entwicklungszeit.

Loslegen mit WebStencils

RAD Studio WebStencils sind Bestandteil von RAD Studio bzw. Delphi 12 und erfordern keine besondere Installation. Erst kürzlich wurde Version 12.3 von RAD Studio vorgestellt, die auch neue Funktionen für WebStencils mitbringt. Sie können nach der Installation sofort loslegen und die Vorteile von Server-Side Rendering in Ihren Projekten nutzen. Embarcadero stellt leider nur wenige Beispiele zur Verfügung. Hier sei auf die zahlreichen Webinare von Embarcadero verwiesen, die auch nachträglich noch auf YouTube
angeschaut werden können. WebStencils wurden hier in den vergangenen Monaten thematisiert und mit zahlreichen Beispielen demonstriert.

Wie funktionieren WebStencils?

Im Kern erzeugt WebStencils Textinhalte basierend auf einer Vorlage. Sie können diese Vorlagen entweder als String definieren oder aus einer Datei laden. Es gibt keine zwingende Verbindung zu Webtechnologien. WebStencils kann in jedem Delphi-Projekt verwendet werden. Laut Marco Cantu, dem Produktmanager von Delphi, ist es von Natur aus kein meinungsstarkes (engl. opinionated) Framework. Dies öffnet es für die Verwendung in jedem Szenario und ermöglicht es auch Drittentwicklern, es in ihren eigenen Frameworks zu verwenden. Embarcadero hat daher alle Komponenten für WebStencils aus Klassen abgeleitet, die leicht mit WebBroker, DataSnap und RAD Server verwendet werden können. Dies impliziert auch den Hauptanwendungsfall für WebStencils: Einfache Erstellung von Webseiten oder anderen web-spezifischen Dateiformaten mit einer modernen Template-Engine. Die folgende Abbildung zeigt die drei Bausteine von WebStencils. Eine Vorlage wird in den Prozessor geladen, der an eine Engine gebunden werden kann. Sowohl für Prozessor (Processor) als auch Engine existieren Komponenten, die man einfach auf Formularen und Datenmodulen verwenden kann. Eine Engine kann dbaei mehrere Prozessoren mit gemeinsamen Einstellungen verwalten, ist jedoch völlig optional und kein zwingender Bestandteil der Prozesskette. Die folgenden Beispiele werden sich daher auf die Verwendung des Prozessors (Processor) beschränken. Jedes Textformat kann generiert werden. Heutzutage sind XML, HTML, JSON und Markdown wahrscheinlich die am häufigsten verwendeten Dateiformate. Wir erkennen nun direkt, dass es keinerlei Bindung an die exklusive Verwendung für Webanwendungen gibt. Es ist somit z.B. auch denkbar WebStencils für die Ertstellung von simplen ‘Serienbriefen’ in VCL Desktopanwendungen zu verwenden.

Der Prozessor erzeugt Inhalte basierend auf einer Vorlage. Eine Vorlage enthält Platzhalter, die
durch Text ersetzt werden können. Dieser Text kann durch Ereignisse, eine TDataSet-Instanz oder
Felder und Eigenschaften eines beliebigen Objekts (abgeleitet von TObject) bereitgestellt werden.
Der Prozessor akzeptiert eine einzelne Objektinstanz sowie ein Modul, das seine Eigenschaften
und Felder mithilfe eines benutzerdefinierten Attributs an den Prozessor veröffentlicht.

Zusätzlich zum Textersatz kann die Vorlage spezielle Schlüsselwörter enthalten. Das sind z.B. Aus-
drücke um simple Berechnungen durchzuführen sowie Bedingungen (@if), ob Teile der Vorlage einbezogen werden sollen oder nicht. Außerdem können Sie über alle Datensätze eines Datensets iterieren und bestimmte Passagen der Vorlage für jeden Datensatz generieren (@foreach).

Wenn Sie eine Vorlage angeben, kann sie spezielle Platzhalter enthalten, um Teile aus anderen Vorlagen zu laden bzw. importieren. Auf diese Weise können Sie leicht ein gemeinsames HTML-Dokument definieren und dann individuell mit dem Inhalt für den jeweiligen zu generierenden Inhalt füllen.

Figure 1: So funktionieren WebStencils

Stellen Sie sich eine Website vor, die in drei Hauptgruppen strukturiert ist: – Kopfzeile (Header) mit Navigationsleiste – Hauptinhalt (Main Content) – Fußzeile (Footer)

Sie können dann eine Vorlagendatei angeben, die die Kopf- und Fußzeile enthält, aber der Hauptinhalt wird jedes Mal ersetzt.

Die folgenden Beispiele führen in die Grundlagen der Vorlagenerstellung ein und zeigen, wie man Vorlagenplatzhalter mit Werten durch Ereignisse, Datasets und Objekte ersetzt. Weiterführende Beispiele verwenden die Edge-Webbrowser-Komponente, um responsive Webinhalte darzustellen. Die Vorlagen enthalten dann HTML, das mit Daten aus einer SQLite-Datenbank gefüllt wird. Eine Erstellung von Web Servern mit Web Broker ist ebenfalls möglich, wird aber in diesem Artikel nicht behandelt.

Formale Beschreibung von WebStencils

WebStencils ist ein ‘Textinhalt-Generator’, der für serverseitiges Scripting verwendet werden kann. Im Kontext von mehrschichtigen Anwendungen ermöglicht die Skriptsprache innerhalb einer Vorlage die Erstellung beliebiger Textformate im Backend. Die Tatsache, dass Sie sowohl HTML als auch JSON erstellen können, macht es sehr flexibel, sowohl eine API als auch sogenannte visuelle Serverkomponenten zu implementieren. Sie können die Stärke der Delphi-Datenbank-Frameworks nutzen, um Informationen aus Datenbanken einzubeziehen, aber auch Ihre Datenbanken mit Daten zu aktualisieren, die im Frontend eingegeben wurden. Es ist
jedoch nicht nur für mehrschichtige Szenarien geeignet. WebStencils kann auch in herkömmlichen Delphi Windows Desktop-Anwendungen verwendet werden, um Serienbriefe oder andere dynamische Textdokumente zu erstellen. Für Web-Anwendungsfälle kann es leicht in bestehende Web-Frameworks wie z.B. WebBroker, RAD Server, DataSnap und TMS WEB Core integriert werden, um die Erstellung von HTML-Seiten zu unterstützen, die auf Vorlagen basieren.

Hallo WebStencils!

Lassen Sie uns WebStencils mit einem sehr einfachen Beispiel kennenlernen. Es kann als das ‘Hello World’ von WebStencils bezeichnet werden. Ich habe eine Windows VCL-Anwendung erstellt. Das Web wird in diesem Beispiel noch keine Rolle spielen. Zuerst müssen wir verstehen, wie WebStencils funktionieren, und dann können wir dies auf Webtechnologien übertragen.

Das Hauptformular der Anwendung enthält eine einzelne Schaltfläche, um den WebStencils-Prozessor zu starten. Der Prozessor kann in der Werkzeugpalette als TWebStencilsProcessor gefunden werden.

Figure 2: Hauptformular des Beispiels im Formulardesigner.

Offensichtlich sehen wir zur Laufzeit nur die einzelne Schaltfläche. Innerhalb des Schaltflächenereignisses werden wir den Code implementieren, um WebStencils zu verwenden. Wenn Sie auf die Schaltfläche klicken, wird nur ein kurzes Nachrichtenfeld mit dem Text –Hello World– angezeigt.

Figure 3: Hauptformular des Beispiels im Formulardesigner.

Der WebStencils Prozessor benötigt eine Vorlage und mindestens ein Objekt, ein Dataset, ein Modul oder ein Ereignis, um auf die Vorlage angewendet zu werden.

Diese schließen sich nicht gegenseitig aus. Sie können gleichzeitig beliebige Eingabequellen anwenden. Das bedeutet, dass Sie einige Ersetzungen in Ihrer Vorlage sowohl mit einem Ereignis als auch mit einem Dataset bereitstellen können, zum Beispiel.

In diesem Beispiel werden wir ein Ereignis bereitstellen, das Text innerhalb der Vorlage ersetzt.

Eine Vorlage definieren

Eine Vorlage ist nichts anderes als reiner Text. Sie kann entweder als TStringList in der Eigenschaft InputLines oder als Dateiname angegeben werden. Die Datei wird dann geladen, bevor der Prozessor aufgefordert wird, die Vorlage zu verarbeiten.

Wenn Sie einen Dateinamen angeben, wird jeder andere Vorlageninhalt ignoriert. Nur der Inhalt der angegebenen Datei wird verwendet. Jeder Text im Inhalt bleibt unberührt und wird in die Ausgabe kopiert, es sei denn, Sie verwenden das @-Symbol. Dieses Symbol zeigt WebStencils an, dass Sie entweder eine zu ersetzende Variable oder ein Schlüsselwort definieren möchten. Schlüsselwörter sind zum Beispiel @if oder @foreach und werden später besprochen.

Konzentrieren wir uns darauf, Text innerhalb der Vorlage zu ersetzen.

Processor.InputLines.Text := ’–@Data.Text–’;

Die obige Zeile setzt die Vorlage innerhalb der Processor-Komponente. Die Eigenschaft InputLines ist vom Typ TStringList. Wie bereits erläutert, ist dies eine Alternative zur Angabe eines Pfads zu einer Datei, die die Vorlage enthält. Wir bemerken, dass die Vorlage das @-Symbol gefolgt von Data.Text verwendet. Data wird als Objekt und Text als Eigenschaft bezeichnet. Formal werden diese beiden vom Prozessor ausgewertet und ergeben einen Wert.

Das Objekt und die Eigenschaft sind beide symbolische lokale Namen und können mithilfe des OnValue-Ereignishandlers aufgelöst werden. Alternativ können wir Objekte, Datensätze und Module unter einem ‘Namen’ registrieren, den wir dann mit @ referenzieren können. Der resultierende Wert ist dann entweder eine Zeichenkette, die im OnValue-Ereignis übereinstimmt, eine Objekteigenschaft oder ein Feld eines Datasets.

Da wir in diesem Beispiel einen einfachen Ereignishandler verwenden möchten und keine Datensätze oder Objekte definiert haben, müssen wir ein OnValue-Ereignis für die Processor Komponente implementieren.

Schwierige Verwendung von @

Auf den ersten Blick erscheint alles ziemlich einfach zu sein. Wann immer Sie einen Marker definieren möchten, verwenden Sie das @-Symbol. Es gibt nur ein winziges Problem. Was ist, wenn Ihre Vorlage @-Symbole enthält? Es gibt mehrere Fälle, in denen dies passieren kann:

• Ihre Vorlage enthält eine E-Mail-Adresse: [email protected]
• Sie möchten einen X (Twitter)-Feed referenzieren: @hflickster
• Sie verwenden eine HTML-Vorlage, die CSS-Referenzen mit Versionsnummern enthält:
  <link href=“[email protected]/dist/css/bootstrap.min.css“>
• CSS-Animationsdefinitionen, die @keyframe verwenden.

Dies sind nur einige Beispiele, die mir in den letzten Monaten begegnet sind. Ich bin sicher, es gibt noch viele mehr.

Die Lösung besteht darin, ein zusätzliches @-Symbol hinzuzufügen. Wenn Sie das @-Symbol tatsächlich Teil Ihrer Vorlage machen möchten, müssen Sie zwei davon in Ihre Vorlage aufnehmen. Das bedeutet, wenn Sie @@ schreiben, wird es nach der Verarbeitung zu @. Angenommen, ich möchte meine E-Mail-Adresse in die Vorlage aufnehmen, würde ich die folgende Vorlagenzeichenkette
erstellen:

Email me at holger@@flixengineering.com !

Dies wird zu:

Email me at [email protected] !

Dies kann sehr mühsam sein, insbesondere wenn Sie Dateien von der Festplatte laden, die für andere Zwecke als die Verwendung mit der WebStencil-Vorlagen-Engine vorbereitet wurden. Stellen Sie sich vor, Sie greifen auf ein Repository von HTML-Vorlagen in Ihrem Unternehmen zu, das auch von anderen HTML-Anwendungen verwendet wird. Sie können diese Vorlagen nicht ändern, ohne es den anderen Anwendungen unmöglich zu machen, sie zu verwenden. Daher müssten Sie diese Vorlagen laden, die Änderungen vornehmen und sie dann an WebStencils übergeben. Obwohl dies möglich ist, ist es eine sehr unbefriedigende Lösung. Stattdessen hat WebStencils das @processing-Schlüsselwort eingeführt: – @processing on: Verarbeite Marker in dieser Vorlage. Dies ist die Standardeinstellung. – @processing off: Verarbeite Marker in dieser Vorlage nicht. Dies ermöglicht es, Vorlagen ‘wie sie sind’ an den Prozessor zu übergeben.

Das @processing-Schlüsselwort betrifft die gesamte Vorlage. Daher ist es ratsam, es in Verbindung mit kleineren Vorlagenschnipseln zu verwenden, die Sie mithilfe von @import in eine größere Vorlage laden.

Auf diese Weise kann jeder Schnipsel individuell Marker verarbeiten oder nicht.

Implementierung des Ereignisses

Wenn wir die Prozessor-Komponente auswählen und uns ihre Ereignisse ansehen, finden wir das Ereignis namens OnValue.

procedure TForm1.ProcessorValue(Sender: TObject; const AObjectName, APropName:
string; var AReplaceText: string; var AHandled: Boolean);
begin
if (AObjectName = ’Data’) and (APropName = ’Text’) then
begin
AReplaceText := ’Hello World’;
AHandled := True;
end;
end;

Wann immer der Prozessor auf ein @-Symbol gefolgt von einem Objekt und einem Wert stößt, wird OnValue ausgelöst. Im Parameter AObjectName wird der Name des Objekts sowie der Name des Werts in APropName übergeben. Der Codeausschnitt zeigt, dass wir einfach den Namen des Objekts und den Eigenschaftsnamen vergleichen können, ob sie mit dem übereinstimmen, wonach wir
suchen. In diesem Fall möchten wir Data.Text durch Hello World für das Objekt Data und seine Eigenschaft Text ersetzen. Dafür weisen wir den Ersetzungstext der Variablen AReplaceText zu. Diese wird an den Prozessor zurückgegeben, da sie mit var definiert ist. Gleiches gilt für den Parameter AHandled. Sie müssen ihn auf True setzen, wenn Sie eine Ersetzung vorgenommen haben. Auf diese Weise weiß der Prozessor, ob alle Symbolmarkierungen in der Vorlage ersetzt wurden oder nicht. Wenn nicht alle Markierungen behandelt werden, kann der Prozessor eine Exception werfen.

Starten des Prozessors

Um den Prozessor zu starten, lesen Sie den generierten Text mit der Content-Funktion. Es sieht aus wie eine Eigenschaft, ist aber tatsächlich eine Funktion:

TWebStencilsProcessor = class(TCustomContentProducer, IWebStencilsComponent)
public
constructor Create(Owner: TComponent); override;
destructor Destroy; override;
/// <summary> Produziert Inhalt aus der Vorlage, die durch InputFileName angegeben wird.
/// Wenn InputFileName leer ist, wird InputLines verwendet. </summary>
function Content: string; override;
Die vollständige Implementierung des Button.OnClick-Ereignisses ist wie folgt:
procedure TForm1.Button1Click(Sender: TObject);
begin
Processor.InputLines.Text := ‚–@Data.Text–‚;
ShowMessage(Processor.Content);
end;

Weisen Sie zuerst die Vorlage mit einem String zu. Zeigen Sie dann den generierten Inhalt mit ShowMessage an. Es wird das OnValue-Ereignis bei Bedarf implizit abgerufen. In diesem Fall wird es nur einmal ausgeführt, da wir nur einen Marker verwenden.

Es ist nicht notwendig, Leerzeichen zwischen Markern und dem Text, der Teil der Vorlage ist, zu lassen. Ich habe absichtlich führende und nachfolgende — Zeichen zur Vorlage hinzugefügt. Nur die Markerdeklaration wird ersetzt. Denken Sie auch daran, dass jedes Mal, wenn Sie Processer.Content lesen, die Vorlage erneut ausgewertet wird. Das bedeutet, dass Sie dieselbe Komponente für verschiedene Vorlagen oder flexiblere Ereignisimplementierungen wiederverwenden können.

Ja, es ist so einfach!

Herzlichen Glückwunsch! Dies sind die Grundlagen der Prozessor-Engine von WebStencils. Sie hätten nicht gedacht, dass es so einfach sein würde, oder?

Auf diese Weise können Sie bereits flexible Textinhalte erstellen, die sich beispielsweise auf berechnete Werte stützen.

Das Ersetzen aller Platzhalter im OnValue-Ereignis könnte für alle möglichen Ersetzungen verwendet werden, ist jedoch nicht sehr effizient. Stellen Sie sich vor, ein Dataset hat Dutzende von Feldern und Sie müssen für jedes Feld mehrere Codezeilen im Ereignishandler hinzufügen.

WebStencils bietet Mittel, um dies viel sauberer und effizienter zu handhaben. Daher zeigt das nächste Beispiel, wie man Datensätze aus einem TDataSetverwendet.

Verarbeitung von einzelnen Datensätzen und kompletten Datasets

Im ersten Beispiel haben wir gelernt, wie man einen Platzhalter in einer Vorlage mit dem OnValue-Ereignis ersetzt. Jetzt wird es etwas komplexer, da wir Datasets mit WebStencils einführen. Auch hier verwenden wir eine Windows VCL-Anwendung, um die Funktion zu demonstrieren. Zur Entwurfszeit platzieren wir zwei Schaltflächen auf dem Formular. Eine Schaltfläche wird ein Beispiel ausführen, dass eine Vorlage verwendet, um den aktuellen Datensatz des Datasets zu verarbeiten (Process current record). Die andere Schaltfläche startet ein Beispiel, das eine Vorlage erstellt, um das gesamte Dataset zu durchlaufen (Process ALL records). Der vom Prozessor generierte Text wird im Memo-Steuerelement namens txtResult angezeigt.

Figure 4: Hauptformular des Beispiels im Formulardesigner.

Die Daten werden in einem TFDMemTable gespeichert. Dies ist die FireDAC-Komponente, die ein Client Dataset mit vielen weiteren Funktionen als die traditionelle TCientDataset-Komponente kapselt. Die in diesem Dataset definierten Daten sind trivial. Wenn Sie den Feldeeditor öffnen, sehen Sie, dass es drei Felder mit primitiven Datentypen gibt.

Wir können den Vor- und Nachnamen einer Person sowie ihr Alter speichern. Die ersten beiden Felder sind natürlich vom Typ String, das letzte Feld ist ein Integer-Feld. Eine der großartigen Funktionen von FireDAC ist, dass Sie die Daten dieser Datensätze zur Entwurfszeit im Formular-Editor bearbeiten können. Klicken Sie einfach mit der rechten Maustaste auf die TFDMemTable-Komponente und wählen Sie Edit DataSet… aus, um den Entwurfszeit-Dateneditor zu öffnen.

Figure 5: Feld-Editor des FDMemTable

Figure 6: Daten können direkt zur Entwurfszeit bearbeitet werden.

Figure 7: Der Entwurfszeit-Dateneditor von FireDAC

Die Daten werden innerhalb des Formulars gespeichert und sind zur Laufzeit verfügbar. Dies macht das Erstellen von Demos mit FireDAC zu einer Freude, da Sie für einfache Beispiele wie dieses keine Datenbankdatei benötigen. Wenn Sie die Anwendung ausführen, können Sie entweder den aktuellen Datensatz (der der erste sein wird) oder alle Datensätze verarbeiten. Wenn Sie möchten, können Sie dieses Demo erweitern, indem Sie ein Navigator-Steuerelement hinzufügen, um durch das Datenset zu navigieren.

Zugriff auf den aktuellen Datensatz

Um auf einen Datensatz zuzugreifen, können Sie die Methode verwenden, die Sie im ersten Beispiel gelernt haben. Sie binden das Dataset an einen Objektnamen, und die Feldnamen werden als Werte verwendet. Schauen wir uns die verwendete Vorlage an:

procedure TForm1.btnProcessOneClick(Sender: TObject);
begin
Processor.InputLines.Text :=
“‘
Text is @People.LastName!
Text is @People.FirstName @(UpperCase(People.LastName))
“‘;
Process;
end;

Erneut weisen wir InputLines.Text einen String zu. Die erste Zeile der Vorlage bezieht sich auf People.LastName. Der Wert von People bezieht sich auf das Feld LastName. Wie können wir WebStencils mitteilen, People an das Dataset zu binden? Die Prozessorkomponente Processor hat eine Methode namens AddVar, die drei Parameter akzeptiert:

1. Einen Namen für das zu bindende Objekt.
2. Eine Objektreferenz auf ein Dataset.
3. Einen Boolean-Wert, ob diese Objektreferenz nach der Verarbeitung aus dem Speicher freigegeben werden soll.

Im Code sieht das so aus:

Processor.AddVar( ’People’, People, False );

Das bedeutet, wir binden das Dataset People an den Marker namens People. Beachten Sie, dass der Markername ein String ist. Der letzte Parameter ist False, da die VCL People freigibt, wenn die Anwendung beendet wird. Wenn Sie True angeben würden, würde das Dataset nach der Verarbeitung freigegeben, und Sie würden höchstwahrscheinlich eine Zugriffsverletzung erhalten, wenn die Anwendung beendet wird. Wenn Sie den Prozessor ein zweites Mal ausführen, wird er mit Sicherheit eine Zugriffsverletzung auslösen, da das Dataset nicht mehr verfügbar ist.

Zusammenfassend weist die Zeile das Dataset People allen @People-Vorkommen zu. Dies impliziert auch, dass jeder Wert ein Feld im Dataset sein muss. Betrachtet man @People.LastName, ist dies korrekt, und wir erwarten, dass der Nachname anstelle des Markers eingefügt wird, wenn er verarbeitet wird.

Die nächste Zeile der Vorlage fügt ebenfalls den Vornamen mit @People.FirstName ein. Anschließend wird die nächste Ersetzung etwas komplexer, zeigt jedoch, dass wir sogar Funktionen aus Delphi in unserer Vorlage verwenden können. WebStencils ist ziemlich intelligent und löst Funktionen mithilfe von RTTI auf.

Falls Sie nicht wissen, was RTTI ist, denken Sie einfach so darüber: Sie können Funktionsnamen eingeben, die für die Prozessorkomponente zugänglich sind, und dieser wird in der Lage sein, diese Funktionen aufzurufen.

Wenn Sie einen Ausdruck auswerten möchten, müssen Sie ihn in Klammern setzen. Anstelle von @People.LastName müssen Sie also @( Ausdruck ) verwenden. Die Klammern sind der Schlüssel, damit es funktioniert. So wird @( UpperCase( @People.LastName )) zuerst @People.LastName auswerten und das Ergebnis dann in UpperCase einfügen. Beachten Sie jedoch, dass Sie keine String-Helfer oder andere Dinge mit Duck Typing aufrufen können. Dies wird nicht funktionieren:

@People.LastName.toUpper

Das würde buchstäblich zu folgendem Ergebnis führen, wenn der Nachname des Datensatzes auf Reacher gesetzt ist:

Reacher.toUpper

Der .toUpper-Teil wird einfach zu Text und nicht zu einem Ausdruck. Außerdem ist es ratsam, Ausdrücke sehr kurz zu halten. Verwenden Sie berechnete Felder, wann immer Sie Datensätze mit WebStencils verwenden. Ihr Code wird dadurch viel sauberer, und Sie haben Zugriff auf die gesamte Vielfalt der Object Pascal-Sprache. Genau wie im ersten Beispiel ist dies bereits alles, was Sie tun müssen, um einen einzelnen Datensatz zu verarbeiten:

1. Legen Sie die Vorlage fest.
2. Verknüpfen Sie Marker mit einem Dataset.
3. Führen Sie den Prozessor aus.
4. Geben Sie das Ergebnis aus.

Beachten Sie, dass Sie den zweiten Schritt nur einmal implementieren müssen und die Vorlage so oft ändern können, wie Sie möchten. Die Referenz des Namens zum Dataset bleibt erhalten. Wir nutzen dies im Beispiel, da ich das Symbolmarker nur einmal für beide Anwendungsfälle binde, nachdem das Formular erstellt wurde:

procedure TForm1.FormCreate(Sender: TObject);
begin
txtResult.Clear;
Processor.AddVar( ‚People‘, People, False );
end;

Wie zuvor gezeigt, weisen wir im Button-Klick-Ereignis die Vorlage zu und führen den Prozessor aus, indem wir die Methode Process aufrufen. Die Methode Process weist den Inhalt der Memo-Komponente zu. Implizit wird dadurch die Vorlage verarbeitet.

procedure TForm1.Process;
begin
txtResult.Lines.Text := Processor.Content;
end;

Figure 8: Ausgabe des Beispiels für einen Datensatz

Iterieren aller Datensätze

Wenn wir alle Datensätze iterieren und eine Vorlage darauf anwenden möchten, müssen wir die Vorlage ändern und nicht wie man vielleicht denken könnte die Art und Weise, wie wir den Prozessor aufrufen. Genauer gesagt, kommt hier das Schlüsselwort @foreach ins Spiel. Wir werden zunächst die vereinfachte Variante des Schlüsselworts verwenden, bevor wir uns die formal korrekte und bessere Methode ansehen, eine Iteration in der WebStencils-Skriptsprache auszudrücken. Das Schlüsselwort @foreach funktioniert ähnlich wie Delphis relativ neue for-in-Schleife. Denken Sie an die Delphi-Schleife for var person in people. Wenn people eine Liste ist, iterieren wir die Liste, und jedes Element der Liste wird in person zurückgegeben. Genau so funktioniert @foreach. Der Name leitet sich tatsächlich von anderen Programmiersprachen ab, die keine for-in-Schleife, sondern ein foreach-Schlüsselwort haben. Schauen wir uns die Vorlage an, die wir verwenden können, um alle Datensätze in einem Dataset zu iterieren. Wie zuvor ist das Dataset an den Marker namens People gebunden.

procedure TForm1.btnProcessAllClick(Sender: TObject);
begin
Processor.InputLines.Text := “‘
@ForEach People {
Text is @loop.LastName!
Text is @loop.FirstName @loop.LastName
}
“‘;
Process;
end;

Das Schlüsselwort @foreach wird gefolgt vom Namen des Markers, der auf das Dataset verweist. In diesem Fall verwenden wir erneut People. Dann müssen wir den Teil der Vorlage, der für jeden Datensatz eingefügt werden soll, mit {…} umschließen. Betrachtet man das Beispiel, bedeutet das, dass der folgende Teil für jeden Datensatz eingefügt wird:

Text is @loop.LastName!
Text is @loop.FirstName @loop.LastName

Die Referenz wechselt von People zu @loop. Sie bezieht sich auf die aktuelle Instanz der Iteration. Wie zuvor können wir nun die Feldnamen als Werte verwenden. Somit bezieht sich @loop.LastName auf das Feld LastName des aktuellen Datensatzes des Iterationsschritts. WebStencils stellt sicher, dass es mit dem ersten Datensatz loslegt und mit dem letzten endet. Sie müssen nicht First aufrufen, um den Datensatzzeiger auf den ersten Datensatz zu setzen. WebStencils wird den Datensatzzeiger vor der Verarbeitung auf den ersten Datensatz setzen.

Bei Anwendung der Vorlage auf alle Datensätze wird der Text in der Memo-Komponente wie folgt angezeigt:

Erweiterte Nutzung von @ForEach

Das letzte Beispiel verwendet @ForEach, um über alle Datensätze eines Datasets zu iterieren. Jedes Element der Iteration kann mit @loop angesprochen werden. Dies ermöglicht es uns, über eine Liste zu iterieren. Sobald jedoch verschachtelte Schleifen benötigt werden, ist es nicht mehr möglich, auf das aktuelle Element einer der Schleifen zuzugreifen, weil beide Schleifen dann über @loop referenziert werden. Das bedeutet, dass Sie nicht mehr wissen, auf welches Element Sie sich beziehen. In diesem Fall müssen Sie die vollständige Definition von @ForEach verwenden.

Genauer gesagt ist @ForEach Object {} eine vereinfachte Syntax, die von WebStencils aus Komfortgründen bereitgestellt wird. Die vollständige Definition von @ForEach sieht etwas komplexer aus:

@ForEach ( var Object in List ) { … }
Das bedeutet, dass unser letztes Beispiel auch wie folgt ausgedrückt werden könnte:

Figure 9: Ausgabe des Beispiels für alle Datensätze

@ForEach ( var loop in People ) { … }
Angenommen, jeder Datensatz in People hätte mehrere Adressen. Sie könnten wie folgt iterieren:
@ForEach ( var person in People ) {
@ForEach ( var address in @person.addresses ) {
Text ist @address.street
Text ist @address.city
}
}

Wir schliessen diesen Artikel damit ab, uns anzuschauen, wie wir HTML-Inhalte mit WebStencils generieren können. Wir verwenden dazu die Edge-Browser-Komponente, um die HTML-Inhalte darzustellen. Die Edge-Browser-Komponente ist Bestandteil von RAD Studio 12.3 und kann in der Werkzeugpalette gefunden werden. Sie ist eine Wrapper-Komponente um den Microsoft Edge WebView2 Browser. Diese Komponente ist die einzige Möglichkeit, HTML-Inhalte in Delphi darzustellen, die auf dem neuesten Stand der Technik sind. Sie können sie verwenden, um HTML-Inhalte darzustellen, die mit WebStencils generiert wurden.

Generierung von HTML-Inhalten

Bisher enthielten alle Beispiele nur einfachen Text. Jetzt sind wir bereit, HTML-Tags zur Vorlage hinzuzufügen. Wie Sie sehen werden, ist daran nichts Besonderes. Wir fügen einfach die HTML-Tags zur Vorlage hinzu, und der Inhalt wird wie zuvor generiert. Auch wenn ich kein Tutorial zu HTML geben kann, denken Sie daran, dass HTML die Struktur eines Dokuments und dessen Inhalt bestimmt. Die Formatierung erfolgt in der Regel mit CSS. CSS ist eine Stylesheet-Sprache, die das Layout und die Formatierung von HTML-Dokumenten definiert. CSS wird in der Regel in einem separaten Stylesheet gespeichert, das dann in das HTML-Dokument eingebunden wird. Es ist jedoch auch möglich, CSS direkt im HTML-Dokument zu definieren. Falls Sie sich fragen, warum HTML-Dokumente auch ohne CSS in einem Webbrowser gerendert werden, liegt die Antwort in Ihrem Webbrowser. Jeder Browser hat einen Standardsatz von Stilen (engl. styles), die verwendet werden, wenn Ihr HTML-Dokument keine benutzerdefinierten Stile definiert.

Im Jahr 2024 sehen die Standardvorgaben, die formal als User Agent Style Sheets bezeichnet werden, immer noch ziemlich so aus wie im Jahr 2000. Um eine modern aussehende Webseite zu erstellen, sollten Sie daher immer CSS verwenden. Entweder nutzen Sie ein CSS-Framework wie Bootstrap oder Tailwind, oder Sie definieren Ihre eigenen Styles. In der Regel ist es eine gute Idee, mit einem CSS-Framework zu beginnen, anstatt zu versuchen, Ihre eigenen Styles von Grund auf zu definieren.

Dieses Beispiel verwendet dasselbe Dataset wie das letzte. Ich habe den Button und die Funktionalität entfernt, um nur Inhalte für den aktuellen Datensatz zu generieren. Der Prozessor wird immer das gesamte Dataset durchlaufen. Zu Beginn verwenden wir weiterhin eine Memo-Komponente, um den generierten HTML-Inhalt anzuzeigen. Das Hauptformular sieht jetzt so aus:

Figure 10: Hauptformular des Beispiels im Formulardesigner.

Um HTML zu generieren, müssen wir HTML-Elemente zur Vorlage hinzufügen. Beachten Sie, dass dies ein sehr einfaches Beispiel ist. Es enthält nicht einmal einen Datei-Header, der für eine vollständige Seite erforderlich ist. Der Edge Webbrowser (und auch Chrome) wird die Seite trotzdem rendern. Das Beispiel zeigt nur, dass Sie HTML-Elemente zur Vorlage hinzufügen können.

Schauen wir uns den Quellcode mit der Vorlage an, die diese Ausgabe generiert:

procedure TForm1.btnProcessAllClick(Sender: TObject);
begin
Processor.InputLines.Text := “‘
@ForEach People {
<h1>@loop.FirstName @loop.LastName</h1>
<p>@loop.FirstName is @loop.Age years old.</p>
}
“‘;
Process;
end;

Da wir über alle Datensätze iterieren und beabsichtigen, für jeden Datensatz das gleiche HTML-Snippet zu generieren, muss dieser Teil in @ForEach {} eingeschlossen werden. Dann drucken wir den Vor- und Nachnamen als Überschrift erster Ordnung mit <H1>. Die nächste Zeile wird als Absatz formatiert, indem der Text mit <P> eingeschlossen wird. Beachten Sie, dass die Komponente TMemo keine Funktionalität bietet, um das erstellte HTML-Snippet zu interpretieren. Es wird es als einfachen Text anzeigen.

Figure 11: Ergebnis der HTML-Vorlage in der TMemo-Komponente

Verwendung der Edge-Browser-Komponente

Im letzten Beispiel haben wir HTML-Inhalte erstellt, die als reiner Text angezeigt wurden. Kein Endbenutzer wird eine solche Ausgabe nutzen können. Wir benötigen eine Komponente, die HTML interpretiert und im Benutzerinterface visualisiert. In modernem Delphi können wir TEdgeBrowser verwenden, der den Chromium-Webbrowser nutzt, der in Microsoft Windows integriert ist.

Wenn Sie Kunde von TMS Software sind, erinnern Sie sich vielleicht daran, dass TMS eine eigene Implementierung für Delphi deutlich früher vorgestellt hat und Sie diese Komponente auch in älteren Delphi-Versionen verwenden können. Darüber hinaus bietet deren Steuerung, die TTMSFNCEdgeWebBrowser genannt wird, mehr Funktionen, um mit den im Browser angezeigten Inhalten zu interagieren. Ihre Brückenfunktionalität, um Daten zwischen Ihrer Anwendung und dem Browser auszutauschen, ermöglicht es Ihnen, Webtechnologie einfach in VCL-Anwendungen zu integrieren. Im Formulardesigner ist nur eine Änderung im Vergleich zum vorherigen Beispiel vorzunehmen. Wir müssen die TMemo-Komponente durch TEdgeBrowser ersetzen.

Figure 12: Hauptformular des Beispiels im Formulardesigner.

Das Template sowie der Prozessor können unverändert bleiben. Es sind keine Änderungen erforderlich.

Die einzigen Änderungen, die wir vornehmen müssen, sind:

1. Initialisieren Sie die Browser-Komponente. Dies kann im FormCreate-Ereignis erfolgen:
   procedure TForm1.FormCreate(Sender: TObject);
   begin
   Processor.AddVar( ’People’, People, False );
   Browser.CreateWebView;
   end;
   Bevor Sie Inhalte in die Webansicht laden können, müssen Sie diese erstellen. Daher muss die Methode CreateWebView aufgerufen werden.
2. Um das generierte HTML-Snippet in den Browser zu laden, müssen wir NavigateToString aufrufen:
   procedure TForm1.Process;
   begin
   Browser.NavigateToString( Processor.Content );
   end;

Das war’s schon!

Mit diesen Änderungen und Ergänzungen ist die Anwendung in der Lage, das HTML-Snippet in der Browser-Komponente anzuzeigen. Wie bereits erwähnt, sieht das gerenderte Ergebnis im Standardlayout nach heutigen Maßstäben recht unattraktiv aus.

Figure 13: Ergebnis der HTML-Vorlage in der TEdgeBrowser-Komponente

The post RAD Studio WebStencils: Die Delphi-Alternative zu Next.js & Co. appeared first on Entwickler Konferenz.

Ein Data Grid erfüllt mehrere essenzielle Funktionen, die die Verwaltung und Darstellung von Daten erheblich erleichtern. Es visualisiert Informationen in einer klar strukturierten, tabellarischen Form, die eine einfache Lesbarkeit und Nachvollziehbarkeit gewährleistet. Durch die Möglichkeit, Daten direkt innerhalb des Grids zu bearbeiten, können Benutzer neue Einträge hinzufügen, bestehende ändern oder löschen, ohne auf externe Bearbeitungstools angewiesen zu sein. Darüber hinaus bietet das Data Grid leistungsstarke Funktionen zum Sortieren, Filtern und Gruppieren von Daten, wodurch die Navigation und Analyse selbst großer Datenmengen effizienter wird. Ein weiteres zentrales Merkmal ist die nahtlose Integration mit externen Datenquellen wie Datenbanken oder APIs. Dadurch bleiben die angezeigten Informationen stets aktuell, ohne dass manuelle Aktualisierungen erforderlich sind.

Die Vorteile dieser Komponente sind vielseitig: Sie steigert die Effizienz von Arbeitsprozessen, reduziert Fehler durch interaktive Bearbeitungsmöglichkeiten und gewährleistet eine konsistente Darstellung von Daten auf verschiedenen Plattformen. In anspruchsvollen Geschäftsanwendungen bildet das Data Grid häufig das zentrale Element der Benutzeroberfläche und bietet den Nutzern eine leistungsfähige Kontroll- und Analysefunktion, die zur Optimierung betrieblicher Abläufe beiträgt.

TMSFNCDataGrid

In diesem Artikel analysieren wir das Data Grid von TMS Software, eine umfassende und vielseitige Komponente, die speziell für die Entwicklung datenintensiver Anwendungen in Delphi konzipiert wurde. Das TMSFNCDataGrid, ein zentraler Bestandteil des TMS FNC UI Packs, zeichnet sich durch eine Kombination aus Flexibilität, plattformübergreifender Unterstützung und benutzerfreundlicher Handhabung aus (siehe Textkasten „Framework-Neutral Components“).

FNC-Komponenten: Framework-Neutrale Entwicklung mit TMS Software

FNC steht für „Framework-Neutral Components“ und bezeichnet eine Technologie von TMS Software, die es ermöglicht, Benutzeroberflächenkomponenten unabhängig vom zugrunde liegenden Framework zu entwickeln. FNC-Komponenten sind so gestaltet, dass sie in verschiedenen Plattformen wie VCL (Windows), FireMonkey (Cross-Plattform), TMS WEB Core (Webanwendungen) und sogar Lazarus-Projekten nahtlos eingesetzt werden können. Der Vorteil von FNC-Komponenten liegt in ihrer Wiederverwendbarkeit und Flexibilität. Entwickler können mit einer einzigen Codebasis Anwendungen für unterschiedliche Zielplattformen erstellen, ohne den Code für jede Umgebung anpassen zu müssen. Dies spart Entwicklungszeit und reduziert den Wartungsaufwand erheblich. 

Darüber hinaus bieten FNC-Komponenten eine breite Palette von Funktionalitäten, darunter fortschrittliche Steuerelemente wie Grids, Diagramme, Editoren und vieles mehr, die alle auf konsistente Weise implementiert sind. 

./.

Es bietet eine Vielzahl von Funktionen, für die Datenvisualisierung und -verwaltung in Delphi-basierten Anwendungen. Die Hauptfunktionen sind:

• • Datenvisualisierung und Organisation: Filtern, Sortieren und Gruppieren von Daten über mehrere Spalten und Ebenen hinweg, dynamisches Zusammenführen und Teilen von Zellen für flexible Datenmanipulation und Ausblenden bzw. Verschieben von Spalten und Zeilen.

• Einfache Datenbindung: Unterstützung von Master-Detail-Beziehungen zur Darstellung komplexer Datenstrukturen, nahtlose Integration von Datenquellen für eine effiziente Datenverwaltung. 

• Vielfältige In-Place-Editoren: Breite Auswahl integrierter und benutzerdefinierter Editoren zur direkten Dateneingabe und -bearbeitung.
• Steuerelemente in Zellen: Einfügen und Anpassen interaktiver Steuerelemente direkt innerhalb von Zellen und Verbesserung der Benutzerfreundlichkeit durch eingebettete Bedienelemente.
• Import und Export: Unterstützung für verschiedene Datenformate wie HTML, CSV, XLSX, PDF und JSON und einfache Weitergabe und Sicherung von Daten durch vielseitige Import- und Exportoptionen.
• Erweiterte Gruppierung und Filterung: Komplexe Gruppierungsoptionen kombiniert mit leistungsstarken Filter- und Sortiermechanismen und eine hierarchische und strukturierte Darstellung von Datensätzen.
• Anpassbare Berechnungen: Durchführung von Spalten- und Zeilenberechnungen mit umfangreichen Anpassungsmöglichkeiten und damit die Unterstützung individueller Geschäftslogiken. 
• Intuitive Benutzeroberfläche: Anpassung des Erscheinungsbildes durch integrierte Layouts und benutzerdefinierte Ereignisse und die Nutzung verschiedener Zelllayouts für unterschiedliche Zustände.
• Effizientes Speichermanagement: Optimierung der Performance durch intelligentes Speicherhandling, besonders bei großen Datenmengen.

Zunächst beschreiben wir die Installation, danach werden ausgewählte Funktionen im Detail betrachtet.

Installation und erster Test in Delphi

Laden Sie von der Webseite des Herstellers das TMS FNC UI Pack für Ihre Delphi-Version herunter und installieren Sie diese Komponenten (eine Trial-Edition ist verfügbar). Der Installationsprozess integriert die Komponenten innerhalb der Tool-Palette in die Delphi IDE.

Kommen wir zu einem ersten Test:

1. Erstellen Sie ein neues Delphi-Projekt oder öffnen Sie ein bestehendes.
2. Ziehen Sie das TMSFNCDataGrid aus der Toolpalette auf das Formular Ihres Projekts.
3. Passen Sie die Eigenschaften des Grids an, beispielsweise die Anzahl der Spalten und Zeilen, die Breite der Spalten oder die Formatierung.

Das TMSFNCDataGrid unterstützt die Verbindung zu verschiedenen Datenquellen. Verwenden Sie beispielsweise Datenmodule und binden Sie das Grid an eine Datenbanktabelle. Sie können Daten ebenfalls programmatisch hinzufügen, beispielsweise durch Aufruf der Methoden AddRow(…) und SetCell(…).

Ein Beispiel für die Definition der Eigenschaften des DataGrid könnte wie folgt aussehen:

TMSFNCDataGrid1.BeginUpdate;

try

  TMSFNCDataGrid1.AddRow;

  TMSFNCDataGrid1.Cells[0, 0] := ‚Artikel-ID‘;

  TMSFNCDataGrid1.Cells[1, 0] := ‚Produktname‘;

  TMSFNCDataGrid1.Cells[2, 0] := ‚Preis‘;

finally

  TMSFNCDataGrid1.EndUpdate;

end;

Die Installation und Einrichtung des TMSFNCDataGrid sind intuitiv und schnell erledigt. Einen ersten Eindruck bekommen wir vom Data Grid, in dem wir es von der Tool-Palette auf das Formular, beispielsweise einer FireMonkey-Applikation ziehen und die Spalten der Tabelle über die Eigenschaft Columns definieren. Im Designer sehen wir sofort – wie gewohnt von Delphi – das Ergebnis. Wenn wir die Applikation (beispielsweise unter Windows) ausführen, wird das Data Grid in der App angezeigt (Abbildung 1).

Abbildung 1: Ein erstes Experiment mit dem TMSFNCDataGrid.

Uses Case: Webbasierte Kundenverwaltung 

Ein Unternehmen benötigt eine webbasierte Anwendung zur Verwaltung von Kunden, um Kundendaten zentral zu speichern, schnell durchsuchen und effizient bearbeiten zu können. Die Lösung soll plattformunabhängig in modernen Browsern laufen, eine intuitive Benutzeroberfläche bieten und einfach anpassbar sein. Zudem sollen Kundeninformationen exportiert und visuell ansprechend dargestellt werden können.

Das TMSFNCDataGrid wird dabei als zentrale Komponente der webbasierten Kundenverwaltungsanwendung verwendet. Es stellt die Kundendaten in einer tabellarischen Form dar und ermöglicht es, Spalten für Kundennummer, Name, Adresse, Telefonnummer und Kundenstatus flexibel zu konfigurieren. Anpassbare Spalten bieten die Möglichkeit, zusätzliche Informationen wie Umsatz oder die letzte Kontaktaufnahme übersichtlich darzustellen. Farbcodierungen sorgen dafür, dass verschiedene Kundenstatus wie „Aktiv„, „Inaktiv“ oder „VIP“ auf einen Blick erkennbar sind. Die Mitarbeiter können Kundendaten direkt im Grid bearbeiten, indem sie beispielsweise Adressen aktualisieren oder den Kundenstatus ändern. 

Zur komfortablen Dateneingabe stehen In-Place-Editoren wie Dropdown-Menüs für den Status oder numerische Eingabefelder für Kreditlimits zur Verfügung, wodurch eine schnelle und fehlerfreie Eingabe gewährleistet wird. Um Eingabefehler zu vermeiden, sind Datenvalidierungen wie die Überprüfung der Telefonnummer integriert. Mithilfe der integrierten Filterzeile können Benutzer gezielt nach Kunden suchen, indem sie Filter nach Namen, Status oder anderen Kriterien anwenden. 

Die Sortierfunktionen ermöglichen eine geordnete Anzeige nach Umsatz, Registrierungsdatum oder Postleitzahl. Kundendaten lassen sich nach verschiedenen Kategorien wie Region, Umsatzbereich oder Status gruppieren, wodurch eine bessere Übersichtlichkeit erreicht wird. Benutzer haben die Möglichkeit, Gruppierungen individuell per Drag & Drop anzupassen und ihre bevorzugte Ansicht zu speichern. Für die Weiterverarbeitung der Daten bietet das TMSFNCDataGrid umfangreiche Exportfunktionen. Kundendaten können in Formaten wie Excel, CSV oder PDF exportiert werden, wodurch sie sich ideal für Marketingkampagnen oder Berichte eignen. Der HTML-Export ermöglicht es zudem, die Daten in einer optisch ansprechenden Ansicht per E-Mail zu versenden. 

Die webbasierte Anwendung läuft in allen gängigen Browsern wie Chrome, Firefox und Edge und kann sowohl auf einem lokalen Server als auch in der Cloud bereitgestellt werden. Der Zugriff erfolgt bequem über URLs, wodurch eine flexible Nutzung gewährleistet ist.

./.

Daten filtern und sortieren

Das Data Grid bietet die einfache Integration von Filter- und Sortieroptionen. Im Bereich des Sortierens haben wir folgende Optionen:

• Programmgesteuertes Sortieren: Das Sort-Verfahren ermöglicht das Sortieren von Spalten nach Index und Richtung (aufsteigend oder absteigend). Beispielsweise sortiert Grid.Sort(0, gsdDescending); die erste Spalte in absteigender Reihenfolge.
• Mehrspaltensortierung: Es ist möglich, mehrere Spalten gleichzeitig zu sortieren, indem man Arrays für Spaltenindizes und entsprechende Sortierrichtungen definiert und an die Sort-Methode übergibt.
• Benutzerdefinierte Sortierlogik: Für komplexere Anforderungen kann das OnCustomCompare-Ereignis genutzt werden, um eigene Vergleichslogiken für Zellenwerte zu implementieren.
• Sortieren durch Interaktion: Die Sortierfunktion kann aktiviert werden, indem folgende Einstellung vorgenommen wird:

Grid.Options.Sorting.Enabled := True;

Das Data Grid überprüft dabei die aktuelle Sortierrichtung der angeklickten Spalte. Wenn die Spalte bereits in absteigender Reihenfolge sortiert ist, wird sie in aufsteigender Reihenfolge sortiert. Andernfalls wird die Spalte in absteigender Reihenfolge sortiert. Bei der interaktiven Sortierung haben wir ein entsprechendes Symbol (Pfeil nach oben, Pfeil nach unten) im Data Grid.

Kommen wir zum Filtern der Daten:

• Filterzeile: Das Data Grid bietet eine spezielle Filterzeile, in der Benutzer Kriterien eingeben können, um die angezeigten Daten zu filtern. Diese Zeile kann durch Setzen der Eigenschaft Filter.Visible auf True aktiviert werden (Abbildung 2).
• Programmgesteuertes Filtern: Entwickler können Filterbedingungen programmgesteuert festlegen, indem sie der Filter-Eigenschaft des Data Grids Bedingungen hinzufügen und anschließend ApplyFilter aufrufen, um den Filter anzuwenden.

Diese Funktionen ermöglichen es Daten effizient zu sortieren und zu filtern, was die Benutzerfreundlichkeit und Datenverwaltung in Anwendungen erheblich verbessert und vielfach für Standardaufgaben genutzt werden kann. 

Abbildung 2: Data Grid mit aktiver Filter-Funktion.

Daten importieren und exportieren

Das TMSFNCDataGrid bietet leistungsstarke Import- und Exportfunktionen. Diese erlauben es, Daten nahtlos zwischen verschiedenen Formaten wie CSV, Excel, JSON, HTML und PDF zu übertragen. Mit diesen Funktionen können Daten aus externen Quellen einfach in das Data Grid geladen und bearbeitete Daten für Berichte oder die Weitergabe exportiert werden. Im Einzelnen:

• • CSV (Import und Export): Das CSV-Format ist weit verbreitet und einfach zu handhaben. Das TMSFNCDataGrid ermöglicht den Import und Export von CSV-Daten mit den Methoden SaveToCSVData(…) und LoadFromCSVData(…). Entwickler können zudem Parameter wie Trennzeichen und Anführungszeichen flexibel anpassen. Beispielsweise können leere Zellen durch Anführungszeichen gekennzeichnet werden, oder es können alternative Trennzeichen definiert werden. Daten können ab einer beliebigen Zelle in das Data Grid geladen werden, was maximale Flexibilität bietet. 
  • JSON (nur Import): JSON ist ideal für strukturierte Daten, die aus Web- oder Konfigurationsquellen stammen. Mit der Methode LoadFromJSONData(…) lassen sich JSON-Dateien einfach in das Data Grid importieren. Man kann Schlüssel für Zeilen- und Spaltennamen definieren oder benutzerdefinierte Spaltennamen für die Darstellung im Data Grid festlegen.
  • HTML (nur Export): Durch den Export in das HTML-Format wird der Data Grid-Inhalt in eine stilisierte, strukturierte Tabelle umgewandelt, die in Webbrowsern angezeigt oder in Webseiten eingebettet werden kann. Optionen wie das Konvertieren von Sonderzeichen, das Exportieren von Farben, Bildern und Stilen sowie benutzerdefinierte Kopf- und Fußzeilen bieten umfangreiche Anpassungsmöglichkeiten. Dies macht einen HTML-Export ideal für Berichte und webbasierte Präsentationen. 

• PDF (nur Export): Das Data Grid unterstützt den Export nach PDF über das TTMSFNCDataGridPDFIO(…)-Steuerelement (ebenfalls nach der Installation auf der Toolpalette verfügbar). Neben standardmäßigen Daten- und Layoutoptionen können Margen, Kopf- und Fußzeilen sowie Metadaten wie Titel oder Autor definiert werden. Diese Funktion ist für die Erstellung professioneller Berichte geeignet, die unabhängig von der Plattform weitergegeben werden können.

• Excel (Import und Export): Das TTMSFNCDataGridExcelIO-Steuerelement ermöglicht den nahtlosen Import und Export von Excel-Dateien ohne die Notwendigkeit einer installierten Excel-Anwendung. Eigenschaften wie das automatische Anpassen der Data Grid-Dimensionen, das Beibehalten von Zellenformatierungen und das Exportieren von Bildern garantieren eine hohe Datenintegrität. Entwickler können zudem festlegen, von welcher Zeile und Spalte aus der Datenimport oder -export beginnen soll. 

• Benutzerdefinierte Textdateien: Mit den Methoden SaveToFileData(…) und LoadFromFileData(…) können Daten in einem proprietären, lesbaren Textformat gespeichert werden, das auch die Spaltenbreiten umfasst. Diese Funktion eignet sich hervorragend für benutzerdefinierte Datenprotokolle oder Szenarien, in denen Flexibilität bei der Datenstruktur erforderlich ist. Mit nur einer Codezeile, beispielsweise:

TMSFNCDataGrid1.LoadFromCSVData(‚CARS.csv‘);

können wir Daten aus einer Excel-Tabelle laden und im Data Grid anzeigen. Für einen Export der Daten benötigen wir ebenfalls nur eine Quellcodezeile, beispielsweise:

TMSFNCDataGridExcelIO1.XLSExport(‚gridexport.xls‘);

Die Daten werden aus dem Data Grid in ein valides Excel-Format geschrieben. Die Excel-Datei können wir daraufhin unmittelbar (ebenfalls beispielsweise mittels einer FNC-Komponente) öffnen (Abbildung 3):

TTMSFNCUtils.OpenFile(‚gridexport.xls‘);

Abbildung 3: Export der Daten in das Excel-Format.

Die Import- und Exportfunktionen steigern die Effizienz der Datenverwaltung in Anwendungen. Sie machen es einfach, externe Datenquellen zu nutzen und bearbeitete Daten in vielseitigen Formaten bereitzustellen. 

Use Case: Mobile App für Lagerverwaltung mit FireMonkey

Ein Unternehmen benötigt eine mobile Anwendung zur Lagerverwaltung, um Lagerbestände effizient zu überwachen, Artikel zu suchen, neue Waren zu erfassen und Umlagerungen vorzunehmen. Die App soll auf mobilen Geräten mit Android und iOS laufen und auch offline verfügbar sein, wobei die Synchronisation der Daten erfolgt, sobald eine Internetverbindung besteht. Das TMSFNCDataGrid dient als zentrale Komponente der mobilen App und ermöglicht eine effiziente, interaktive Benutzeroberfläche zur Verwaltung von Lagerbeständen. Durch die Flexibilität und plattformübergreifende Unterstützung von FireMonkey wird eine reibungslose Nutzung auf verschiedenen Geräten sichergestellt. Das Data Grid zeigt die Lagerbestände in einer tabellarischen Ansicht mit Spalten für Artikelnummer, Artikelname, Bestand, Standort und Mindestbestand an. Mitarbeiter haben die Möglichkeit, Bestandsmengen direkt im Grid zu aktualisieren, beispielsweise nach einer Inventur. Für eine intuitive und fehlerfreie Dateneingabe stehen In-Place-Editoren wie numerische Eingabefelder und Dropdown-Menüs zur Verfügung. Um den Arbeitsablauf weiter zu optimieren, ist ein Barcode-Scanner integriert, mit dem Artikel per Scan erfasst und deren Daten direkt im Grid angezeigt werden können.

Zur schnellen Suche nach Artikeln ermöglicht die Filterzeile die gezielte Eingabe von Suchkriterien wie Artikelnummer oder Standort. Die integrierten Sortierfunktionen erleichtern die Navigation durch umfangreiche Bestandslisten, indem sie beispielsweise eine Sortierung nach Lagerbestand oder Artikelname ermöglichen. Lagerbestände lassen sich nach Standort oder Produktkategorie gruppieren, was zu einer übersichtlicheren Darstellung führt. Mitarbeiter können Gruppierungsebenen flexibel per Drag & Drop anpassen, um schneller auf benötigte Daten zugreifen zu können. Die Anwendung funktioniert auch offline, indem alle Daten lokal auf dem Gerät gespeichert werden. Änderungen, die ohne bestehende Internetverbindung vorgenommen werden, werden in einer Warteschlange gespeichert und bei der nächsten verfügbaren Verbindung mit der zentralen Datenbank synchronisiert. Darüber hinaus stehen Exportoptionen zur Verfügung, die es ermöglichen, Lagerbestände in Formaten wie CSV oder Excel zu exportieren und direkt aus der App per E-Mail zu versenden. Diese mobile Lösung bietet eine effiziente Möglichkeit, Lagerbestände jederzeit und überall im Blick zu behalten. Die benutzerfreundliche Oberfläche in Kombination mit den leistungsstarken Funktionen des TMSFNCDataGrid sorgt für eine gute Unterstützung bei täglichen Lagerprozessen und steigert die Effizienz der Bestandsverwaltung erheblich.

./.

Master-Detail-Bindungen

Master-Detail-Beziehungen sind eine grundlegende Funktion in datenintensiven Anwendungen, die darauf abzielen, komplexe Datenstrukturen auf intuitive und synchronisierte Weise darzustellen. In diesem Ansatz dient ein „Master„-Data Grid als übergeordnete Ansicht, die eine Übersicht über Hauptdatensätze (beispielsweise Bestellungen) bietet. Ein „Detail„-Data Grid zeigt hingegen die zugehörigen Detailinformationen (beispielsweise Bestellpositionen), die mit dem aktuell ausgewählten Eintrag im Master- Data Grid verknüpft sind. 

Master-Detail-Ansichten erleichtern die Navigation und Analyse umfangreicher Datensätze erheblich. Sie bieten dem Benutzer eine übersichtliche Darstellung der Hauptdatensätze und ermöglichen bei Bedarf den direkten Zugriff auf zugehörige Detailinformationen. Änderungen im Master-Data-Grid werden automatisch im Detail-Data-Grid übernommen, wodurch eine nahtlose Navigation und eine konsistente Datenanzeige sichergestellt werden. Separate Datenabfragen sind nicht erforderlich, da die Verknüpfung zwischen Master- und Detaildaten automatisch erfolgt. Diese Funktion ist besonders vorteilhaft für Geschäftsanwendungen, die auf relationalen Datenbanken basieren, wie beispielsweise Bestell-, Kunden- oder Inventarverwaltungssysteme.

Die Implementierung von Master-Detail-Beziehungen ist dank der flexiblen Architektur der Komponente einfach umzusetzen. Es kann durch die folgende Schrittfolge beschrieben werden:

1. 1. Einrichten der Tabellen (Erstellen Sie zwei Datensätze): Es wird eine Master-Tabelle benötigt. Diese enthält die übergeordneten Einträge, beispielsweise eine Tabelle Customer mit Bestellinformationen. Es benötigt auch eine Detail-Tabelle. Diese Enthält die zugehörigen untergeordneten Einträge, beispielsweise eine Tabelle OrderDetails, die über einen Fremdschlüssel (CustomerID) mit der Master-Tabelle verknüpft ist.
   2. Datenbankkomponenten konfigurieren: Verwenden Sie TDataSource-Komponenten, um die Datensätze mit den Grids zu verbinden (beispielsweise dsMaster und dsDetail). Platzieren Sie zwei TTMSFNCDataGridDatabaseAdapter-Komponenten auf dem Formular und verbinden Sie diese mit den jeweiligen TDataSource-Komponenten.

• Master-Grid einrichten: Platzieren Sie ein TTMSFNCDataGrid auf dem Formular und verbinden Sie es mit dem MasterAdapter, um die Hauptdatensätze anzuzeigen.

• Detail-Grid einrichten: Fügen Sie ein weiteres TTMSFNCDataGrid hinzu und binden Sie es an den DetailAdapter. Stellen Sie sicher, dass die MasterSource-Eigenschaft des Detaildatensatzes auf den TDataSource der Master-Tabelle verweist und die MasterFields-Eigenschaft den Schlüssel (beispielsweise CustomerID ) definiert.

1. Synchronisierung der Daten: Bei Auswahl eines Eintrags im Master– Data Grid aktualisiert das Detail– Data Grid automatisch die zugehörigen Datensätze.

Beachten Sie: Die Komponenten sind aufeinander abgestimmt, d.h. wir können die Datenbindungen und Verknüpfungen mit Hilfe der Eigenschaften im Objekt Inspektor von Delphi vornehmen, was den Aufwand zum Schreiben von Quellcode maßgeblich reduziert. Beispielsweise können wir die Detail-Tabelle auf diese Weise über einen Adapter an die Datenquelle der Mastertabelle mittels Fremdschlüssel binden (Abbildung 4).

Abbildung 4: Verbindung von Master- und Detailtabelle über die Primär- und Fremdschlüssel.

Bei der Ausführung einer Applikation mit einer Verknüpfung von Master- und Detailtabelle werden die Detailinformationen korrekt innerhalb eines übergeordneten Datensatzes eingeblendet (Abbildung 5). 

Abbildung 5: Ausführung einer Applikation mit Master- und Detailtabelle.

Editierfunktionen 

Das Data Grid bietet flexible und erweiterbare Möglichkeiten zur Bearbeitung von Daten direkt innerhalb des Rasters. Diese sogenannten In-Place-Editoren ermöglichen eine intuitive Dateneingabe und Anpassung, ohne dass zusätzliche Fenster oder Dialoge erforderlich sind. Nachfolgend sind die Hauptmerkmale und Möglichkeiten der Editierfunktionen dargestellt:

Globale und spaltenweise Bearbeitungskontrolle:

• Globale Aktivierung der Bearbeitung: Über die Eigenschaft Options.Editing.Enabled kann die Bearbeitungsfunktion für das gesamte Data Grid ein- oder ausgeschaltet werden.

• Spaltenweise Bearbeitung: Über die ReadOnly-Eigenschaft in der Spaltenkonfiguration können einzelne Spalten vom Bearbeiten ausgenommen werden

• Zellweise Bearbeitung: Mithilfe des Ereignisses OnCanEditCell kann programmatisch festgelegt werden, ob eine spezifische Zelle bearbeitet werden darf.

Vorgefertigte In-Place-Editoren: 

Das Data Grid enthält eine Vielzahl von integrierten Editoren, die direkt genutzt werden können:

• Texteditoren: Für einfache Texteingabe mit Konfigurationsmöglichkeiten wie Groß-/ Kleinschreibung oder numerische Eingabe.
• Kombinationsfelder: Ermöglichen die Auswahl aus vordefinierten Werten. Die Werte können entweder in der Spaltenkonfiguration oder über das Ereignis OnGetInPlaceEditorProperties definiert werden.
• Datumsauswahl (Date Picker): Neben dem standardmäßigen Betriebssystem-Datumsauswahlfeld bietet das TMSFNCDatePicker-Steuerelement zusätzliche Anpassungsoptionen, beispielsweise für minimale und maximale Datumsgrenzen.
• Farbauswahl: Ein Color Picker erlaubt die Auswahl von Farben aus vordefinierten Paletten.
• HTML-Editor: Ermöglicht die Bearbeitung von HTML-Inhalten direkt innerhalb der Zelle.
• Trackbars: Bieten eine interaktive Möglichkeit zur Eingabe von Zahlenwerten über einen Schieberegler.

Das Data Grid erlaubt die Verwendung benutzerdefinierter Editoren, die auf spezifische Anforderungen zugeschnitten sind:

• Definition des Editor-Typs: Über das Ereignis OnGetInPlaceEditorType kann für jede Zelle oder Spalte ein individueller Editor-Typ festgelegt werden.
• Erstellung von benutzerdefinierten Editorklassen: Entwickler können ihre eigenen Steuerelemente, beispielsweise Panels oder Buttons, als Editor definieren. Diese müssen lediglich eine Value-Eigenschaft besitzen, damit das Data Grid die Werte automatisch synchronisieren kann.
• Dynamische Anpassung: Mit den Ereignissen OnEditGetData und OnEditSetData können Daten zwischen der Zelle und dem Editor dynamisch ausgetauscht werden.

Anpassung und Erweiterung:

• Eigenschaften der Editoren: Die vordefinierten Editoren lassen sich umfassend anpassen, beispielsweise durch die Festlegung von Werten für Kombinationsfelder, Farbpaletten oder Datumsgrenzen.

• Direkte Konfiguration zur Laufzeit: Alle Editor-Eigenschaften können auch zur Laufzeit programmgesteuert geändert werden.

• Interaktion: Über Ereignisse wie OnCellControlClick lassen sich spezifische Aktionen für jeden Editor implementieren.

Beispiele für In-Place-Editoren:

• Datumsauswahl: Mit dem TMSFNCDatePicker können Datumswerte nicht nur ausgewählt, sondern auch durch Eigenschaften wie Mindest- und Höchstdatum eingeschränkt werden.

• Kombinationsfelder: Mithilfe der EditorItems-Eigenschaft oder OnGetInPlaceEditorProperties können die angezeigten Optionen dynamisch festgelegt werden.

• Trackbars: Zur numerischen Eingabe über interaktive Schieberegler, ideal für Wertebereiche wie Bewertungen oder Prozentsätze.

• HTML-Editoren: Zelleninhalte können als HTML bearbeitet und direkt im Data Grid gerendert werden.

Die Editierfunktionen bieten eine hohe Flexibilität und Anpassbarkeit, zum Beispiel durch einfache Textbearbeitung, komplexe Datumsauswahl oder interaktive Schieberegler.

Weitere Funktionen 

Das TMSFNCDataGrid bietet eine Vielzahl weiterer Funktionen, die Entwicklern helfen, komplexe Daten effektiv zu verwalten und darzustellen. Eine zentrale Funktion ist die Datenbankbindung, die eine nahtlose Integration verschiedener Datenquellen ermöglicht. Mithilfe des TTMSFNCDataGridDatabaseAdapter lassen sich Datenquellen wie TDataSet einfach verknüpfen, sodass Änderungen automatisch zwischen Grid und Datenbank synchronisiert werden. Die Unterstützung von Master-Detail-Beziehungen erlaubt es, hierarchische Datenstrukturen übersichtlich abzubilden, indem Haupt- und Detaildatensätze miteinander verknüpft werden. Durch die flexible Architektur eignet sich das Grid sowohl für relationale Datenbanken als auch für andere Datenquellen und ermöglicht eine einfache Konfiguration mit minimalem Programmieraufwand.

Die Gruppierungsfunktion erleichtert die Organisation großer Datensätze, indem sie Daten nach einer oder mehreren Spalten strukturiert. Benutzer können Spalten per Drag & Drop in eine Gruppierungsleiste ziehen, um eine individuelle Darstellung zu erstellen. Entwickler haben zudem die Möglichkeit, Gruppierungen programmgesteuert zu konfigurieren und auf spezifische Anforderungen zuzuschneiden. Änderungen an den Daten werden automatisch in der gruppierten Ansicht aktualisiert, was die Benutzerfreundlichkeit erheblich steigert.

Ein weiteres leistungsstarkes Feature sind die Berechnungsfunktionen, die es ermöglichen, Summen, Durchschnitte oder andere statistische Werte automatisch für Spalten oder Zeilen berechnen zu lassen. Benutzerdefinierte Formeln können implementiert werden, um spezielle Anforderungen zu erfüllen, während Änderungen an den Daten sofort aktualisierte Berechnungsergebnisse liefern. Die Darstellung der Berechnungen kann flexibel in separaten Spalten, Fußzeilen oder Zellen erfolgen.

Das Erscheinungsbild des Grids lässt sich umfassend anpassen, um den individuellen Anforderungen verschiedener Anwendungen gerecht zu werden. Jede Zelle, Zeile oder Spalte kann mit individuellen Layouts, Farben und Schriftarten formatiert werden. Über ereignisgesteuerte Anpassungen lässt sich das Design dynamisch anpassen, sodass eine responsive Darstellung auf verschiedenen Bildschirmgrößen und Plattformen gewährleistet ist.

Dank der plattforübergreifenden Unterstützung kann das TMSFNCDataGrid in einer Vielzahl von Entwicklungsumgebungen eingesetzt werden. Ob Windows-Anwendungen mit VCL, plattformübergreifende Anwendungen mit FireMonkey oder Webanwendungen mit TMS WEB Core – die einheitliche Codebasis ermöglicht eine schnelle und effiziente Entwicklung auf unterschiedlichen Plattformen. Die nahtlose Integration in Entwicklungsumgebungen wie Delphi und C++ Builder erleichtert die Einbindung des Grids in bestehende Projekte und unterstützt eine reibungslose Arbeitsweise.

Beispiele

Eine umfassende Beispielsammlung wird durch den Hersteller bereitgestellt. Mit der Installation der beiden Bibliotheken TMS FNC UI Pack und TMS FNC Core Pack landen auch viele Beispiele zu den einzelnen FNC-Komponenten auf der Festplatte. Im Unterordner DataGrid findet man Beispiele für viele der Features der Datentabelle, u.a. auch das Zusammenspiel mit anderen Komponenten aus der FNC-Bibliothek. 

./.

Fazit und Ausblick

Das hier vorgestellte Data Grid erweist sich als eine leistungsstarke und flexible Komponente für Delphi-Entwickler, die mit datenintensiven Anwendungen arbeiten. Durch die Kombination von plattformübergreifender Unterstützung, einfacher Datenbankintegration und einer Vielzahl an Funktionen wie In-Place-Editoren, Master-Detail-Beziehungen sowie Import- und Exportmöglichkeiten wird es zu einem Werkzeug in der modernen Softwareentwicklung.

Die Flexibilität, Daten auf intuitive Weise zu visualisieren, interaktiv zu bearbeiten und dynamisch zu organisieren, bietet eine zentrale Lösung, um komplexe Geschäftsanforderungen effizient umzusetzen. Die Möglichkeit, eigene Editoren zu integrieren oder bestehende Funktionen individuell anzupassen, erhöht den Mehrwert des Data Grids erheblich.

Links & Literatur

[1] https://download.tmssoftware.com/doc/tmsfncuipack/components/ttmsfncgrid/

[2] https://www.tmssoftware.com/site/blog.asp?post=1256

The post Datenmanagement in Delphi: Das TMS Data Grid im Überblick appeared first on Entwickler Konferenz.

KI-Unterstützung bei der Codierung

Mit Version 12.2 führt RAD Studio neue KI-gestützte Funktionen für CodeInsight ein, die den Codevervollständigungs- und Optimierungsprozess unterstützen. Diese Funktionen basieren auf einer offenen Architektur, die es erlaubt, aus verschiedenen KI-Plugins zu wählen oder eigene Erweiterungen zu integrieren. RAD Studio bietet standardmäßig Unterstützung für die Online-KI-Lösungen von OpenAI, Gemini und Claude und den Offline KI-Service von Ollama für einen maximalen Datenschutz. Die Integration von KI in CodeInsight hat das Ziel, die Produktivität zu steigern, indem sie kontextbezogene Codevorschläge macht, Fehler im Code schneller erkennt und die Navigation im Code erleichtert. Diese neue Funktion ist optional und standardmäßig deaktiviert, um sicherzustellen, dass die Nutzung vollständig kontrollierbar ist und nach den individuellen Bedürfnissen des Entwicklungsteams gestaltet werden kann (Abbildung 1).

Abbildung 1: Auswahl und Konfiguration einer KI in die RAD Studio.

Für die Nutzung dieser KI-Dienste müssen Sie den Bedingungen des jeweiligen Anbieters zustimmen, einen API-Schlüssel erhalten, den Sie in die RAD Studio-Konfiguration eingeben können und dem KI-Unternehmen die fälligen Gebühren zahlen. Die Ausnahme ist der KI-Dienst Ollama, welcher ohne Servicegebühr offline genutzt und lokal oder auf einem Server Ihrer Wahl installiert werden kann. Es stehen nach der Auswahl und Konfiguration (API, URL, Key) folgende KI-basierte Funktionen in der IDE zur Unterstützung beim Programmieren zur Verfügung: 

• KI-Chat: Öffnen Sie die Chat-Ansicht.
• Fehler suchen: Versuchen Sie, potenzielle Fehler im ausgewählten Code zu finden.
• Code erklären: Erläutert den ausgewählten Code.
• Kommentar hinzufügen: Fügen Sie Kommentare zum ausgewählten Code hinzu.
• Code vervollständigen: Ergänzen Sie den ausgewählten Code.
• Code optimieren: Optimiert den ausgewählten Code.
• Komponententest hinzufügen: Fügen Sie einen Komponententest für den ausgewählten Code hinzu.
• In Assembly konvertieren: Konvertiert den ausgewählten Code in Assemblycode.
• In Delphi konvertieren: Konvertiert den ausgewählten Code in Delphi-Code (aus C++ oder Assembly).
• In C++ Builder konvertieren: Konvertiert den ausgewählten Code in C++ Builder-Code.

KI-Dienste im Überblick

• OpenAI: OpenAI stellt eine API für Sprachmodelle wie GPT bereit, die für die Codevervollständigung und -generierung genutzt werden kann. Die Modelle unterstützen bei der Codeerstellung, indem sie kontextbezogene Vorschläge und Muster für verschiedene Anwendungsfälle anbieten.
• Gemini (Google): Gemini von Google ist eine KI-Plattform, die maschinelles Lernen für Kontexterkennung und Codevorschläge nutzt. Sie ist in das Google-Ökosystem integriert und bietet eine breite Unterstützung für Entwicklungsaufgaben.
• Claude (Anthropic): Claude ist eine KI-Lösung von Anthropic, die sich auf Datenschutz und ethische Vorgaben konzentriert. Sie wurde für die sichere und kontextbewusste Unterstützung bei der Codeerstellung entwickelt und eignet sich besonders für Projekte mit hohen Anforderungen an Datensicherheit.
• Ollama: Ollama ermöglicht eine KI-basierte Codeunterstützung vollständig offline und richtet sich an Anwender, die ihre Daten lokal verarbeiten möchten. Dies bietet eine Möglichkeit, KI-Funktionen ohne externe Datenübertragung zu nutzen.

./.

Compiler Update für Windows

Mit RAD Studio 12.2 wurde eine 64-Bit-Binärversion des Delphi-Windows-Compilers eingeführt, die speziell für sehr große Anwendungen konzipiert ist. Diese Version ermöglicht es, sehr große Anwendungen als eine ausführbare Datei zu erstellen, da die neuen Compiler über 64-Bit-Speicher verfügen. Diese neuen Compiler sind derzeit über die Befehlszeile und über die IDE bei Verwendung der externen Kompilierung verfügbar. Sie sind nur in den Enterprise- und Architects-Editionen enthalten. Im Übrigen ist der aktuelle C++ Clang-Compiler seit seiner Veröffentlichung in RAD Studio 12.0 ebenfalls ein 64-Bit-Binary.

IDE-Fokusmodus und Scrollbar-Anmerkungen

RAD Studio enthält einen neuen Fokus-Modus für ein ungestörtes Arbeiten am Quellcode. Dieser wird mit der Tastenkombination Ctrl+Alt+Z aktiviert. Der Fokus-Modus bietet folgende Funktionen:

• In einem Editor für den Fokusmodus kann eine beliebige Anzahl von Registerkarten vorhanden sein.
• Die Anzahl der nebeneinander liegenden Editoren ist durch die Menge an verfügbarer horizontaler Bildschirmfläche begrenzt. 

Ebenso kann bestimmt werden, welche Optionen (Lesezeichen, Code Foldings, Debug-Infos, …) angezeigt werden sollen. In Kombination mit einer dunklen Einfärbung des Bildschirms kann auf diese Weise ein konzentrierter Arbeitsplatz für „schwierige Passagen“ am Quelltext konfiguriert werden (Abbildung 2). 

Abbildung 2: Fokusmodus in RAD Studio.

Eine weitere sehr nützliche Funktion sind die neuen Scrollbar-Anmerkungen: Die Scrollbar des Editors zeigt auf einen Blick die Codeabschnitte an, die geändert wurden, Lesezeichen haben, Fehler oder Warnungen enthalten und vieles mehr. Auch das sorgt für mehr Übersicht beim Schreiben des Quellcodes.

C++Builder Visual Assist Integration

Visual Assist ist ein Tool, dass die Aufgabe hat die Übersichtlichkeit und Wartbarkeit von C++-Code zu verbessern. Es unterstützt die Code-Navigation, bietet Funktionen zur automatischen Code-Vervollständigung und beinhaltet Werkzeuge zur Code-Analyse und Refaktorisierung. Visual Assist ist direkt in die IDE C++Builder integriert. Mit Version 12.2 von RAD Studio (C++ Builder) wurde die Integration um neue Funktionen erweitert, darunter drei neue Refactorings: Introduce Variable, Create From Usage und Extract Method. Hinweis: Visual Assist ist nicht für Delphi, sondern nur für die Programmiersprache C++ verfügbar. Als externes Tool kann es auch als Extension in Visual Studio für die Programmiersprachen C++ und C# eingesetzt werden. 

Entwicklung von Apps für die mobilen Systeme 

 Bekanntermaßen kann man mit Delphi und der Grafikbibliothek FireMonkey (FMX) Apps für die mobilen Geräte, d.h. die Betriebssysteme iOS und Android erstellen. Ein besonderes Merkmal ist dabei die Nutzung der visuellen Controls für das effizientere Gestalten der Benutzeroberfläche, inklusive des Einsatzes des grafischen Designers. Die aktuelle Version von RAD Studio 12.2 bietet Verbesserungen für die mobile Entwicklung mit Delphi, sowohl für iOS als auch für Android. Um Apple-Plattformen besser zu unterstützen, wurde der Linker auf die neueste Version aktualisiert, so dass es jetzt möglich ist, in Xcode geschriebene statische iOS-Bibliotheken zu verknüpfen, wie zum Beispiel das Firebase iOS SDK. Um mehr Kontrolle über die Paketierung und Bereitstellung zu geben, wurden in Android-Projektoptionen hinzugefügt, dass *.Dex-Dateien komprimiert und native Bibliotheksdateien in der Toolchain komprimiert werden können. Darüber hinaus kann für Android die TargetSdkVersion der Android-Manifest-Datei jetzt im Dialogfeld Projektoptionen konfiguriert werden. Ebenso besteht die Möglichkeit, Android-Bibliotheken (*.aar-Dateien) zu importieren, was zum Beispiel mit dem Facebook SDK für Android und Firebase Analytics funktioniert.

Dateitypen in Android

DEX-Dateien (Dalvik Executable Files) sind Dateien im Bytecode-Format, das speziell für die Android-Plattform entwickelt wurde. Sie enthalten kompilierte Java-Code-Bestandteile, die von der Dalvik Virtual Machine (DVM) oder der neueren Android Runtime (ART) auf Android-Geräten ausgeführt werden. Bei der Entwicklung einer Android-App wird der Java- oder Kotlin-Code zuerst in Bytecode kompiliert und anschließend in DEX-Dateien umgewandelt, die die Anwendung für die Android-Plattform lauffähig machen. Eine typische Android-App enthält mindestens eine DEX-Datei, die alle Klassen und Methoden enthält, die für den Betrieb der App erforderlich sind. Diese Dateien werden im APK (Android Package) der App gebündelt und auf das Android-Gerät übertragen, wo sie zur Laufzeit interpretiert oder vorab in Maschinencode übersetzt werden. 

AAR-Dateien (Android Archive Files) sind Archive, die Bibliotheken und Ressourcen für die Entwicklung von Android-Apps enthalten. Sie werden häufig verwendet, um wiederverwendbare Android-Bibliotheken zu bündeln, die dann in anderen Projekten integriert werden können. Eine AAR-Datei kann neben kompiliertem Code (DEX-Dateien) auch Ressourcen wie XML-Dateien, Bilder, Layouts, Assets, und Manifest-Dateien enthalten. Im Gegensatz zu JAR-Dateien, die nur Java-Klassen beinhalten, können AAR-Dateien zusätzlich Ressourcen und native Bibliotheken enthalten, was sie vielseitiger für Android-spezifische Anforderungen macht. Entwickler fügen eine AAR-Datei zu ihrem Projekt hinzu, um die enthaltenen Funktionen und Ressourcen in ihrer Anwendung zu nutzen, ohne die Bibliothek selbst entwickeln oder kompilieren zu müssen.

./.

WebStencils Template Library

RAD Studio bietet verschiedene Werkzeuge und Frameworks für die Webentwicklung, die speziell darauf ausgelegt sind, serverseitige Anwendungen zu erstellen und APIs bereitzustellen, u.a. das WebBroker-Framework. WebBroker ist ein serverseitiges Framework in RAD Studio, das es ermöglicht, HTTP-Anfragen zu verarbeiten und HTML-Inhalte, JSON oder andere Formate zurückzugeben. Es eignet sich gut für die Entwicklung von Webanwendungen und APIs, die auf einer serverseitigen Logik basieren. RAD Studio Version 12.2 führt WebStencils ein, eine serverseitige skriptbasierte Integration und Verarbeitung von HTML-Dateien in WebBroker- und RAD Server-Technologien. Mit dieser flexiblen Funktion können Sie Websites entwickeln, die auf beliebigen JavaScript-Bibliotheken basieren und mit den von einer RAD Studio-Serveranwendung extrahierten und verarbeiteten Daten betrieben werden. Das Hauptziel von WebStencils ist die Unterstützung bei der Navigation von Websites durch die Übernahme von Webtechnologien (WebBroker, DataSnap, RAD Server) und die Bereitstellung von serverseitigem Scripting. Beispielsweise können Sie mit WebStencils HTML-Seiten mit Standardwerkzeugen generieren und beliebige CSS- und JavaScript-Bibliotheken übernehmen, während Sie gleichzeitig die Möglichkeit haben, Daten aus den generierten Seiten hinzuzufügen, die aus der Delphi- oder C++Builder-Anwendung stammen, wie zum Beispiel das Ergebnis einer Datenbankabfrage. Darüber hinaus können WebStencils eine gute Grundlage für HTMX als Webentwicklungslösung sein. HTMX-Seiten profitieren von der serverseitigen Codegenerierung und der Einbindung in REST-Server für die Aktualisierung von Inhalten. 

HTMX – Was ist das?

HTMX ist eine JavaScript-Bibliothek, die es ermöglicht, HTML direkt durch einfache Attribute interaktiv und dynamisch zu machen, ohne dass umfangreiche JavaScript-Logik erforderlich ist. Mit HTMX lassen sich asynchrone Funktionen (AJAX) nutzen, um Teile einer Website ohne komplettes Neuladen zu aktualisieren. Es basiert auf der Idee von „Hypertext-Driven Applications“ und erweitert HTML um eine Reihe von Attributen, mit denen Benutzeroberflächen auf den Server reagieren können. Die Hauptfunktionen von HTMX sind:

• AJAX-Anfragen: Mit HTMX lassen sich serverseitige Daten anfordern und direkt in HTML-Elemente einfügen. Beispielsweise kann ein Button konfiguriert werden, um einen Teil der Seite zu aktualisieren, ohne das gesamte Dokument neu zu laden.
• Server-Events: HTMX kann Ereignisse auf der Serverseite überwachen, z.B. durch WebSockets, und die Benutzeroberfläche in Echtzeit anpassen. Dies ist nützlich für Anwendungen, die auf dynamische Daten angewiesen sind.
• Interaktive Funktionen ohne JavaScript: Durch den Einsatz von HTMX-Attributen wie `hx-get`, `hx-post`, `hx-swap` und `hx-trigger` können Entwickler:innen interaktive Komponenten erstellen, ohne JavaScript manuell schreiben zu müssen.

HTMX ist ideal für Anwendungszwecke, wo serverseitige Logik in die Webanwendungen integriert werden soll, ohne dabei komplexe Frontend-Frameworks wie React oder Angular zu verwenden. Es eignet sich gut für serverseitig gerenderte Webseiten und ermöglicht ein einfacheres Entwicklungsmodell, das auf HTML und serverseitigen Daten basiert.

./.

Qualitätsverbesserungen

RAD Studio Version 12.2 beinhaltet auch einige Qualitätsverbesserungen, die die Stabilität und Effizienz der Entwicklungsumgebung erhöhen. Dazu zählen:

• Debugger-Qualität: Verschiedene Verbesserungen wurden an den Debuggern vorgenommen, insbesondere im Bereich der Fehlerbehandlung und bei Kommunikations-Timeouts der Remote-Debugger. Der Delphi-Debugger kann nun auch wiederholte Inline-Variablen mit demselben Namen korrekt verarbeiten.
• Delphi Language Server Protocol (LSP): Die LSP-Engine, die CodeInsight antreibt, wurde erweitert, um eine bessere Symbolauflösung und Navigation zu gewährleisten, insbesondere in Klassenschnittstellen und bei Variablen. Mit der neuen 64-Bit-Version der LSP-Engine wird zudem die Arbeit mit großen Codebasen unterstützt, allerdings ist diese Funktion auf die Enterprise- und Architect-Editionen beschränkt.
• Verbesserungen an Delphi RTL, VCL und FireMonkey: Die RTL-Bibliothek erhielt neue Klassen wie TParallelArray und TOrderedDictionary. Die VCL-Bibliothek wurde in Bezug auf Skalierung, Styling und High-DPI-Anpassungen verbessert. Im FireMonkey-Bereich wurden verschiedene Optimierungen vorgenommen, insbesondere bei Edit Controls für mobile Geräte.
• RAD Server: Die Swagger-Dokumentation in RAD Server wurde durch zusätzliche Metadaten, API-Filtermöglichkeiten, das YAML-Format und Unterstützung für mehrzeilige Delphi-Stringliterale erweitert.

SKIA in Delphi

Auch wenn dieser Artikel sich auf die Neuerungen von RAD Studio 12.2 konzentriert, verdient ein Feature aus der Vorversion besondere Erwähnung: die Integration der Grafikbibliothek Skia ab Version 11 in Delphi. Skia ist eine leistungsstarke Grafikbibliothek, die ursprünglich von Google entwickelt wurde und in zahlreichen Anwendungen wie Chrome und Android verwendet wird. Durch die Integration in Delphi und C++Builder ermöglicht Skia hochqualitatives Grafik-Rendering auf allen unterstützten Plattformen und bringt leistungsstarke visuelle Effekte sowie bessere Performance für Multimedia- und grafikreiche-Anwendungen. Die Bibliothek ist sowohl in VCL (für Windows) als auch in FMX (plattformübergreifend) nutzbar und ermöglicht die effiziente Erstellung visueller Anwendungen mit modernen Grafikstandards. Skia unterstützt die Darstellung von Vektor- und Rastergrafiken sowie komplexen Animationen und ist für ihre Effizienz und Flexibilität bekannt. Die Skia-Bibliothek bietet Funktionen wie Antialiasing zur Glättung von Kanten, Farbverläufe, Shading-Effekte und Text-Rendering, das auch für RTL-Sprachen (Right-to-Left) wie Arabisch und Hebräisch geeignet ist. Außerdem unterstützt Skia verschiedene Grafikformate wie BMP, PNG, JPEG und animierte Formate wie GIF, WebP und Lottie-Animationen. Ein entscheidender Vorteil von Skia ist das hardwarebeschleunigte Rendering über die GPU, das besonders bei grafikintensiven Anwendungen zu flüssigen Animationen und einer geringen CPU-Belastung führt. 

Die Integration von Skia in RAD Studio eröffnet in Delphi neue Möglichkeiten zur Erstellung grafisch anspruchsvoller Anwendungen. Skia4Delphi, eine speziell für Delphi angepasste Variante von Skia, ermöglicht hochqualitatives Rendering für VCL- und FMX-Anwendungen. Dies umfasst das Zeichnen von Vektorgrafiken, die Manipulation von Text und das Rendern von SVG-Dateien. Der Vorteil dieser Integration ist, dass Entwickler moderne Grafiktechniken anwenden können, ohne separate Bibliotheken nutzen oder zusätzliche Hardwareanforderungen berücksichtigen zu müssen. Durch die Einbindung in RAD Studio lassen sich Skia-Features direkt über die IDE steuern und konfigurieren, was die Anwendung für anspruchsvolle Designs und interaktive Benutzeroberflächen vereinfacht.

Skia bringt spezielle Steuerelemente (Controls) für die VCL- und FMX-Frameworks in Delphi mit, die die Implementierung von Grafikfunktionen vereinfachen (Abbildung 3)

• TSkAnimatedImage: Dieses Control ermöglicht das Einbinden und Abspielen animierter Bilder wie Lottie-Animationen, GIFs und WebP. Die Animationen lassen sich in hoher Qualität und mit weichen Übergängen darstellen.
• TSkLabel: Ein vielseitiges Text-Control, das erweiterte Textstile und Formatierungen erlaubt, etwa die Darstellung mehrerer Schriftarten und Farben innerhalb eines Labels. Dieses Control ist besonders nützlich für anpassbare UI-Designs und Überschriften.
• TSkPaintBox: Ermöglicht das Zeichnen und Rendern benutzerdefinierter Grafiken im OnDraw-Ereignis, sodass die volle Leistung und Flexibilität der Skia-API direkt im Delphi- oder C++-Code nutzbar sind.
• TSkSvg: Ermöglicht das Laden und Rendern von SVG-Dateien. Es unterstützt die Skalierung und Färbung der Vektorgrafiken und ist besonders nützlich für skalierbare Icons und grafisch anspruchsvolle Benutzeroberflächen.

Abbildung 3: SKIA-Controls in RAD Studio.

Die Integration von Skia in FireMonkey (FMX) bringt erhebliche Verbesserungen für das plattformübergreifende Rendering in RAD Studio. Durch die Aktivierung von Skia als Standard-Canvas in FMX-Anwendungen können Entwickler:innen die Qualität und Leistung der grafischen Darstellung erhöhen. Das gilt insbesondere für die mobilen Plattformen. Die Skia-Engine ersetzt dabei das Standard-Rendering von FMX und bietet Vorteile wie (Abbildung 4):

• Antialiasing auf allen Plattformen: Glättet Kanten und sorgt für eine professionelle Darstellung ohne visuelle Artefakte.
• Erhöhte Zeichenleistung: Bis zu 50 % Performance-Steigerung durch GPU-Beschleunigung, was besonders auf mobilen Geräten und bei grafisch aufwendigen Anwendungen Vorteile bringt.
• Optimierte Bildskalierung: Vermeidet Verzerrungen und gewährleistet eine gleichbleibend hohe Bildqualität.
• Unterstützung von RTL-Text und Emojis: Behebt Inkonsistenzen und verbessert die Textdarstellung bei speziellen Zeichen und Schriftarten.

Abbildung 4: Kernfeatures der Skia4Delphi-Bibliothek.

Diese Optimierungen wirken sich besonders positiv auf Multimedia-Apps und grafikintensive Anwendungen aus, die auf unterschiedlichen Plattformen (Windows, macOS, iOS, Android) eingesetzt werden. Dabei ist die Aktivierung denkbar einfach. Mit einem Klick über den Projektmappen-Explorer lässt sich die Nutzung der Grafikbibliothek sehr einfach aktivieren (Abbildung 5).

Abbildung 5: Skia über die Projekteigenschaften in einem RAD Studio-Projekt aktivieren.

In RAD Studio 12 ist zusätzlich ein Multi Device Icon Generator integriert, der auf Skia basiert und die plattformübergreifende Erstellung von Icons und Grafiken für verschiedene Geräte erleichtert. Mit diesem Tool können Entwickler Icons und Grafiken in den benötigten Auflösungen und Formaten für verschiedene Plattformen generieren. Der Generator verwendet eine Bildquelle und bietet Optionen für manuelle Anpassungen wie Zoom und Hintergrundfarben. Nach der Konfiguration können alle notwendigen Bildelemente für die Zielplattformen automatisch generiert und bereitgestellt werden. Dieses Tool reduziert die Zeit und den Aufwand für die finale Bildbereitstellung, insbesondere bei plattformübergreifenden Anwendungen, erheblich und trägt zur Vereinheitlichung des visuellen Designs bei.

RAD Studio-Editions

RAD Studio ist eine integrierte Entwicklungsumgebung (IDE) von Embarcadero Technologies, die es ermöglicht, plattformübergreifende Anwendungen für Windows, macOS, iOS, Android und Linux zu erstellen. Die aktuelle Version, RAD Studio 12.2, bietet verschiedene Editionen, die auf unterschiedliche Bedürfnisse und Anforderungen zugeschnitten sind:

• Community Edition: Die Community Edition richtet sich an Hobbyentwickler, Studenten und Start-ups. Sie ermöglicht die Entwicklung plattformübergreifender Anwendungen mit einer einzigen Codebasis für Windows, macOS, iOS und Android. Diese Edition ist kostenlos verfügbar und bietet grundlegende Funktionen für die App-Entwicklung. Allerdings unterliegt sie bestimmten Einschränkungen, wie einer jährlichen Lizenzlaufzeit, die kostenlos verlängert werden kann, und einer beschränkten kommerziellen Nutzung bis zu einem Jahresumsatz von 5.000 USD. Zudem fehlen einige Features wie Remote-Datenbankunterstützung und RAD Server-Backend-Unterstützung.
• Professional Edition: Die Professional Edition ist für professionelle Entwickler konzipiert, die robuste Anwendungen für verschiedene Plattformen erstellen möchten. Sie umfasst alle Funktionen der Community Edition und bietet zusätzlich erweiterte Tools und Bibliotheken. Dazu gehören die InterBase Developer Edition und IBLite für lokale und eingebettete Datenbanken. Mit dieser Edition können Entwickler schnell und effizient visuell ansprechende Anwendungen für Windows, macOS, Mobile, IoT und mehr erstellen und aktualisieren.
• Enterprise Edition: Die Enterprise Edition richtet sich an Unternehmen und Entwickler, die komplexe Client/Server-Anwendungen für mobile und Desktop-Plattformen entwickeln. Sie enthält alle Funktionen der Professional Edition und bietet darüber hinaus erweiterte Features wie eine Single-Site-Deployment-Lizenz für RAD Server, DataSnap Multi-Tier-Technologie, FireDAC-Datenzugriffsbibliotheken und Unterstützung für die Erstellung von Linux-Anwendungen in Delphi. Diese Edition ermöglicht die Entwicklung dienstbasierter Anwendungen und bietet Funktionen für eine Remote-Datenbankkonnektivität.

./.

Fazit und Ausblick

Die neue Version von RAD Studio 12.2 bringt einige interessante Verbesserungen, beispielsweise eine konfigurierbare KI-Unterstützung für das Schreiben von Quellcode, Verbesserungen beim Compiler, neue Funktionen für das integrierte Tool Visual Assist und notwendige Qualitätsanpassungen. Erwähnenswert ist insbesondere auch die Integration der Grafikbibliothek Skia (bereits seit Version 11 von RAD Studio), welche eine optimierte grafische Darstellung und Performance auf allen unterstützten Plattformen ermöglicht. Dieses Feature ist insbesondere für Multimedia- und UI-intensive Anwendungen von Vorteil. Weitere Funktionen wie der Multi-Device-Icon-Generator und die WebStencils-Template-Library erleichtern die plattformübergreifende Entwicklung bzw. die Entwicklung von serverbasierten Applikationen.

Dr. Veikko Krypczyk ist begeisterter Entwickler und Fachautor. Er bietet Seminare und Workshops zu unterschiedlichen Themen der Softwareentwicklung. Weitere Informationen zu diesen und anderen Themen der IT und Angebote zu Seminaren und Workshops finden Sie unter https://larinet.com und https://www.tech-punkt.com. Hier finden Sie Seminare zu aktuellen Themen, welche den Inhalt kompakt und auf den Punkt gebracht vermitteln.

Links & Literatur

[1] https://www.embarcadero.com/products/rad-studio

[2] https://www.embarcadero.com/de/products/rad-studio/whats-new-in-12-athens

[3] https://docwiki.embarcadero.com/RADStudio/Athens/en/Skia4Delphi

The post Delphi & C++Builder: Das bietet RAD Studio 12.2 für Entwickler:innen appeared first on Entwickler Konferenz.

1995 war ein gutes Jahr für Programmiersprachen: In dem Jahr wurden erste Versionen sowohl für Java, JavaScript, PHP als auch für Delphi vorgestellt. Wenn wir uns einmal auf Delphi konzentrieren: Was war deiner Meinung nach das Erfolgsrezept der Sprache, das dafür sorgte, dass auch heute noch eine aktive Entwickler-Community existiert?

Matthias Eissing: Es war nicht nur die Sprache, die Delphi zum Erfolg verhalf. Es war ein Gesamtkonzept, welches auf drei wesentlichen Säulen basierte und immer noch basiert: (i) Echter Compiler, der eine ausführbare Datei ohne Abhängigkeiten von DLLs oder einer Laufzeitumgebung erzeugt, (ii) umfangreiche und erweiterbare Klassenbibliothek mit visuellen Komponenten und (iii) visuelle, Formular-basierte Entwicklung mit Datenbankanbindung. Jedes für sich gab es auch jeweils in anderen Compilern, IDEs und Entwicklungsumgebungen: Compiler, wie C++; Komponenten, visuelle Entwicklung und ereignisorientierte Programmierung wie zum Beispiel VisualBasic; und Datenbank-zentrische Ausrichtung, wie Oracle Forms oder Sybase PowerBuilder.

Mit Delphi war das einzigartig – und ist es auch heute noch in vielen Bereichen. Delphi besitzt sicherlich immer noch die beste IDE, um visuell Windows Desktop-Anwendungen zu erstellen. Das hat selbst Microsoft mal in einer CeBIT realisiert, wo die AUTOSTART.EXE auf der tausendfach verteilten CeBIT-Demo-CD-ROM mit einem mir sehr bekannten Ich daherkam: Ja, es war ein Delphi-Programm!

„Mit Delphi war das einzigartig – und ist es auch heute noch in vielen Bereichen.“

Max Kleiner: Basierend auf der Sprache Pascal waren wir neugierig, endlich Turbo Pascal verlassen zu können und in die objektorientierte Komponentenwelt einzusteigen. Borland hatte ein cooles Image, die Architektur der VCL war seiner Zeit meilenweit voraus.

Christoph Schneider: Mitten während meiner Lehre als Elektroniker im Jahre 1984 erwarb ich meinen ersten Personal Computer, ein CASIO FP-1100. Dieser lief noch unter dem Betriebssystem CP/M und hatte damals noch keine Harddisk, dafür zwei 5.25” Floppy Disks. Die erste belegte die Betriebssystem-Diskette, in der zweiten steckte die neu erworbene Turbo-Pascal-Entwicklungsumgebung. Jahre später, mitten in meinem zweiten Informatikstudium, hatte ich mittlerweile auf IBM PC umgestellt, und dort setzte sich Windows als Bedieneroberfläche definitiv durch. Ich lernte mit Turbo Pascal für Windows die Programmierung der damals noch sehr komplexen Anwendungsentwicklung unter Windows kennen. Da war das VCL-Framework mit Delphi wirklich revolutionär einfach, und mein Vorteil war, dass ich die objektorientierte Erweiterung von Pascal bereits gut kannte. An Delphi schätzte ich sehr, dass ich mich nicht mehr mit allen Details von Windows herumschlagen musste, um ein Fenster auf dem Bildschirm zu zeichnen und auf Maus- und Tastatur-Eingaben zu reagieren. Mit diesem Werkzeug entwickelte ich zum ersten Mal wieder schneller Applikationen, als dies noch unter MS-DOS möglich war.

Bernd Ua: Die Kombination aus schneller und grafischer Entwicklungsumgebung mit einer mächtigen aber sicheren Programmiersprache kam genau zu richtigen Zeit. Anders Hejlsberg hatte alles, was er für eine effektive Komponenten-basierte IDE brauchte, in die Sprache Pascal und dessen Objektmodell einfließen lassen und die Sprache entsprechend angepasst. Aber Delphi ermöglichte nicht nur das schnelle Erstellen von UI-Anwendungen für Windows, sondern auch ebenso einfach den Zugriff auf verschiedenste Datenbanken, und hat damit die Lücke, die sich zwischen Datenbanktools wie dBase, Paradox oder Access mit ihren Runtimes und klassischen Compilern wie Visual C++ aufgetan hat, perfekt gefüllt.

Max Kleiner: Im 1995 galt es die Immobiliensoftware CalWin von VB auf 32-bit Delphi zu migrieren. Zudem baute ich eine Zugsteuerung von Turbo Pascal auf Delphi um, die Anforderung war damals, absolut kollisionsfrei zu funktionieren.

Bernd Ua: Ich wollte neben dem Chemie-Studium noch programmieren lernen, und aus dem ersten Kurs „Programmierung für Ingenieure“ konnte ich für mich vor allem eins herausziehen: Fortran war nicht die Sprache meiner Wahl. Dann habe ich mir jenseits der angebotenen Kurse C++ und Pascal angeschaut und fand letzteres eingängiger. Also habe ich mich mit Pascal beschäftigt und relativ bald eine Messdaten-Auswertung und -Erfassung zunächst mit Turbo Pascal für DOS und dann mit Borland Pascal für Windows geschrieben. Da war Delphi für mich quasi unausweichlich, als es herauskam, und praktischerweise konnte ich dann damals auch neben dem Studium direkt für Borland arbeiten.

Und was reizt dich heute noch an der Programmierung mit der Sprache?

Matthias Eissing: Es ist ja nicht nur die Sprache selbst. Es ist die integrierte Umgebung, die ja heute für Windows, Android, iOS/iPadOS und auch Linux kompilieren kann. Reizvoll ist sicherlich die leichte Lesbarkeit der Sprache selbst. Auch Projekte, die ich vor X Jahren mal erstellt habe, kann ich wieder lesen. Ja; das klingt banal. Es ist aber leider die Ausnahme von Programmiersprachen und auch insbesondere Frameworks, die als Hype mal wieder (kurz) durchs Dorf getrieben werden. Diese Lesbarkeit in Verbindung mit der Technologie-Konstanz – das ist es, was mich an Delphi selbst und auch der Sprache reizt.

Max Kleiner: Ich baue ständig mein Tool maXbox aus, und da sind auch noch etliche Anwendungen, wie SecureCenter oder Pas2JS, die weiterleben wollen. Auch die Möglichkeiten, in einer überschaubaren Community daheim zu sein, gefällt. Mit XE2 im Jahr 2011 kam ja die 64-Bit-Win Unterstützung und bald darauf auch MacOS, iOS und Android. Anfangs hätte ich nie gedacht, dass ich meine Fähigkeiten nutzen werde (tja, die Kunden fordern auch) und als Support anderer Plattformen einsetzen kann.

„Ein wichtiger Punkt ist immer die Abwärtskompatibilität zur alten Codebasis.“

Bernd Ua: Normalerweise reizt einen ja immer das Neue oder das Unbekannte, und das ist bei mir meistens genauso. Insofern wäre die Frage besser, was ich an Delphi schätze und nicht, was mich an Delphi reizt. Nach fast drei Jahrzehnten Delphi und noch länger Pascal gibt es da auch nichts für mich, was noch zu entdecken wäre. Der Hersteller und die Community sind da bei Delphi recht konservativ. Egal, was in der Sprache ergänzt wird, ist ein wichtiger Punkt immer die Abwärtskompatibilität zur alten Codebasis. Dementsprechend sind Must Haves wie generische Typen oder anonyme Methoden mit der Zeit dazu gekommen und haben die Sprache erweitert und aktualisiert, aber jeweils ohne die Brücken zu altem Code zu brechen. Wenn man in anderen Systemen Frameworks kommen und gehen sieht und sich vor Augen führt, wieviel Produktiv-Code dabei dann mit in die Tonne wandert und neu geschrieben werden muss, versöhnt das mit dem Umstand, dass einem das Feature X in der Entwicklungsumgebung oder das Feature Y in der Sprache fehlt.

Christoph Schneider: Nachdem mit Delphi 7 im August 2002 die letzte gute Version erschien, kam aus meiner Sicht erst wieder im Jahr 2009 eine spannende neue Version von Delphi heraus, die uns neue Sprachfeatures wie Generics und anonyme Funktionen sowie die überfällige Unicode-Unterstützung brachte. Als dann 2011 das Zeitalter für plattformunabhängige und native Entwicklung basierend auf dem neuen Framework Firemonkey gestartet wurde, war für mich klar, dass ich auch künftig auf diese Sprache setzen werde. Ab 2017 erhielt ich die Möglichkeit, ein größeres Projekt für einen Kunden zu erstellen, welches unter den beiden Betriebssysteme Windows und MacOS laufen sollte. Auch für die mobilen Plattformen iOS und Android erstellte ich mehrere Apps mit Firemonkey, welche mit der Desktop-Anwendung über eine Cloud-Datenbank kommunizierte.

Welche Entwicklung neueren Datums in der Delphi-Szene findest du besonders spannend?

Matthias Eissing: Ganz ehrlich: Dass sich grundlegend nichts geändert hat. Klar: Moderne Programmierkonzepte wie Generics, anonyme Methoden, Handling von Threads durchs Tasks, Cross-Plattform-Entwicklung etc sind sehr willkommene und auch wünschenswerte Erweiterungen. Aber das grundlegende Prinzip ist weiterhin gleich. Technologie-Konstanz ist auch etwas, was Kunden wirklich schätzen: Dass man ein Projekt von „vor X Jahren“ portieren kann, mit kleinem/geringen Aufwand. Das ist für Projekte, die über den Lebenszyklus des nächsten Framework-Hypes hinausgehen, sehr wichtig geworden.

Max Kleiner: Delphi 11 wie auch das kommende 12 hat meiner Meinung nach die bisher beste Schnittstelle eingeführt, da sie (fast) vollständig anpassbar ist und ein API zum Bauen eigener Plug-ins bietet, um zusätzliche Funktionalität bereitzustellen. Das Thema API fasziniert mich am meisten, andere Funktionen anzuzapfen, um dann meistens in der (werbefreien) Konsole zu coden.

Bernd Ua: Ich finde es spannend zu sehen, wie sich zur Zeit gerade in den Schwellenländern wie Brasilien ein neuer Delphi-Hype entwickelt. Während es in Westeuropa und in Amerika ruhiger um Delphi geworden ist und wenig neue Entwickler zur Community dazustoßen, ist das in Brasilien zum Beispiel komplett anders. Bei Delphi-Konferenzen in Brasilien kommen problemlos mehr als tausend Leute zusammen, und auch neue Open-Source-Projekt werden dort gestartet.

Matthias, eine deiner Sessions auf der EKON heißt „Das Neueste vom RAD Studio – Neuigkeiten in Delphi.“ Was ist die Kernbotschaft, die jeder Teilnehmer mit nach Hause nehmen sollte?

Matthias Eissing: Es geht, wie der Titel schon sagt, um die Neuerungen der Version 12; soweit man innerhalb der Vorschau schon darauf eingehen kann, und welche Funktionen, Erweiterungen und Neuerungen denn auch schon (absehbar) da sind. Kann sich natürlich ändern Die Kernbotschaft ist sicherlich: Delphi lebt, entwickelt sich weiter und wird auch hier den Entwickler besser unterstützen.

Max, du wirst auf der EKON das MachineLearningPackage vorstellen. Worum handelt es sich dabei?

Max Kleiner: Es geht im Kern darum, vortrainierte Modelle aus verschiedenen Frameworks oder Tools zu integrieren, also das bereits bewährte und geprüfte Wissen im Supervised Learning einzusetzen. Man muss auch die Scheu verlieren und die eigene Komfortzone verlassen, um die gespeicherten neuronale Netze aus anderen Plattformen, deren Parameter bereits durch selbstüberwachtes Lernen trainiert wurden, ansatzweise zu verstehen.

Bernd, du hältst auf der EKON den Workshop „Docker für Delphi-Entwickler:innen“. Was wirst du den Leuten mitgeben?

Bernd Ua: Die meisten Delphi-Entwickler:innen arbeiten nach wie vor mit der VCL-Bibliothek und adressieren auch nur Windows als Zielplattform. Nur ein deutlich geringerer Teil der Delphi-Entwickler:innen baut tatsächlich Web-APIs mit Delphi oder schreibt mit der Firemonkey-Bibliothek Linux-Anwendungen. In dem WebApi/Linux-Szenario ist Docker ja quasi unverzichtbar, ich möchte aber auch reinen VCL- und Windows-Entwickler:innen zeigen, wo sie Docker einsetzen können und wie sie mit Docker ihren Werkzeugkasten sinnvoll erweitern.

Christoph, dein Talk auf der EKON heißt „Hybride Verschlüsselung ohne Libraries mit WinRT.“ Worum wird es gehen?

Christoph Schneider: Informationssicherheit ist für die allermeisten Entwickler zunehmend ein wichtiges Thema. In dieser Session wird das Schützen von Dokumenten und Nachrichten vor unerlaubtem Zugriff mittels kryptographischer Methoden behandelt. Für Windows-Anwendungen kann eine Verschlüsselung inzwischen gänzlich mit Delphi-Boardmitteln hergestellt werden. Es braucht keine Kryptobibliothek mehr, sondern nur Kenntnisse über den Aufbau der Hybridenverschlüsselung, um die symmetrischen und asymmetrischen Verschlüsselungsalgorithmen richtig zu kombinieren.

Nach einer kurzen theoretischen Einführung in die hybride Verschlüsselung zeige ich die Implementierung unter Verwendung der WinApi.Security. Detaillierte mathematische Erklärungen der eingesetzten kryptographischen Algorithmen kann ich dabei in der kurzen Zeit nicht geben. Doch werde ich auf sicherheitsrelevante Punkte bei der Wahl der Algorithmen und Konfiguration hinweisen. Das Thema des sicheren Schlüsselaustausch mittels Zertifikate kann in dieser Session nicht behandelt werden.

Vielen Dank für Eure Antworten!

The post Delphi – der Erfolgsgeschichte auf der Spur appeared first on Entwickler Konferenz.