{"id":55000388,"date":"2023-10-01T00:00:00","date_gmt":"2023-10-19T13:18:09","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=388"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"twinBASIC_Grundlagen_zur_AppEntwicklung","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/twinBASIC_Grundlagen_zur_AppEntwicklung\/","title":{"rendered":"twinBASIC: Grundlagen zur App-Entwicklung"},"content":{"rendered":"

\"\"<\/p>\n

VB6-Anwendungen – braucht das noch jemand? Oh ja! Gerade wer mal eben schnell eine Windows-Anwendung mit einer Benutzeroberfläche (oder auch ohne) programmieren will, kann immer noch gut auf seine guten, alten Visual Basic 6-Kenntnisse zurückgreifen – und zwar mit dem Nachfolger twinBASIC. In diesem Magazin haben wir schon die eine oder andere Lösung damit programmiert, die wir als COM-Add-In oder als COM-DLL für die Integration in eine der Office-Anwendungen oder auch zur Erweiterung von VBA genutzt haben. Und in diesem Artikel gehen wir noch einen Schritt weiter: Wir zeigen die grundlegenden Werkzeuge von twinBASIC zur Entwicklung von ausführbare twinBASIC-Anwendung mit eigener Benutzeroberfläche. Mit twinBASIC können wir unsere .exe-Anwendung in Zukunft vielleicht sogar auf Nicht-Windows-Rechnern laufen lassen. Zumindest aber ist die Kompatibilität mit 64-Bit-Systemen gesichert.<\/b><\/p>\n

VB6 im modernen Zeitalter: Ein Relikt mit Wert<\/h2>\n

Visual Basic 6 (VB6) mag auf den ersten Blick wie ein Überbleibsel aus der Technologie-Vergangenheit erscheinen, doch die Realität ist, dass diese robuste Programmiersprache immer noch ihren festen Platz in der Software-Entwicklung hat. Erstens ist die Migration von alten VB6-Anwendungen auf neuere Technologien oft ein zeitaufwändiger und kostspieliger Prozess, den viele Unternehmen scheuen. Daher bleiben VB6-Programme in Betrieb und erfordern weiterhin Wartung und Support.<\/p>\n

Zweitens bietet VB6 eine vertraute Umgebung für Entwickler, die über Jahrzehnte hinweg mit der Sprache gearbeitet haben, und ermöglicht eine schnelle und effiziente Anwendungsentwicklung. Auch wenn VB6 nicht die neuesten Funktionen oder Sprachkonstrukte bietet, bleibt seine Einfachheit und Effizienz in vielen Kontexten unübertroffen. Es ist ein klares Beispiel dafür, dass es nicht immer das Neueste und Beste sein muss, um relevant und wertvoll in der IT-Landschaft zu bleiben.<\/p>\n

twinBASIC als Entwicklungsumgebung<\/h2>\n

Neu sind der Compiler und die Entwicklungsumgebung, die wir in diesem Fall nutzen. Leser unseres Magazins kennen twinBASIC bereits aus verschiedenen Veröffentlichungen, daher empfiehlt sich für den Einstieg ein Blick in das Onlinearchiv von https:\/\/www.vbentwickler.de <\/b>mit einer Suche nach dem Begriff twinBASIC<\/b>. twinBASIC ist zumindest für die Entwicklung mit der 32-Bit-Variante kostenlos, bei Entwicklung von 64-Bit-Apps werden bei Verwendung der kostenlosen Variante Splash-Screens eingeblendet. Die 64-Bit-Version ohne Splash-Screens erfordert den Kauf der Professional-Lizenz (siehe https:\/\/shop.minhorst.com\/access-tools\/364\/twinbasic-professional-edition-jahreslizenz?c=78<\/b>).<\/p>\n

Neues Projekt erstellen<\/h2>\n

Nach dem Start von twinBASIC wählen wir aus den Vorlagen den Eintrag Standard Exe <\/b>aus (siehe Bild 1). Das Ergebnis ist ein neues Projekt, das lediglich ein leeres Fenster enthält. Dieses besteht wiederum aus zwei Elementen: der eigentlichen Benutzeroberfläche (Forms1.tbform<\/b>) und dem Code behind-Klassenmodul (Form1.twin<\/b>).<\/p>\n

\"Erstellen<\/p>\n

Bild 1: Erstellen einer Standard-Exe<\/span><\/b><\/p>\n

Beides sehen wir im Project Explorer <\/b>von twinBASIC, in der Mitte wird direkt der Entwurf des neuen Fensters dargestellt (siehe Bild 2).<\/p>\n

\"Ein<\/p>\n

Bild 2: Ein neues Projekt des Typs Standard Exe<\/span><\/b><\/p>\n

Erster Start des Projekts<\/h2>\n

Mit einem Klick auf die Ausführen-Schaltfläche in der Symbolleiste von twinBASIC können wir das Projekt direkt ausprobieren. Damit zeigen wir das leere Fenster des Projekts an (siehe Bild 3).<\/p>\n

\"Das<\/p>\n

Bild 3: Das noch leere Hauptfenster der Anwendung<\/span><\/b><\/p>\n

Umbenennen der Objekte<\/h2>\n

Bevor wir das Projekt erstmals speichern, wollen wir die bisher vorhanden Objekte umbenennen. So soll das einzige bisher vorhandene Form<\/b>-Objekt in frmMain <\/b>umbenannt werden. Dazu schließen wir dieses Objekt und auch die dazugehörige Code behind-Klasse, sofern diese aktuell geöffnet sind. Zum Umbenennen verwenden wir den Kontextmenü-Eintrag Rename <\/b>und legen die Bezeichnungen frmMain.tbform <\/b>und frmMain.twin <\/b>fest. Dies waren jedoch nur die Dateinamen. Außerdem ändern wir noch die entsprechenden Klassennamen. Die für das Fenster ändern wir im Eigenschaftsbereich. Hier stellen wir die Eigenschaft Name <\/b>auf frmMain <\/b>ein (siehe Bild 4).<\/p>\n

\"Umbenennen<\/p>\n

Bild 4: Umbenennen der Form-Klasse<\/span><\/b><\/p>\n

Für die Code behind-Klasse nehmen wir die Änderungen direkt im Code vor (siehe Bild 5).<\/p>\n

\"Umbenennen<\/p>\n

Bild 5: Umbenennen der Code behind-Klasse<\/span><\/b><\/p>\n

Woher weiß die Code behind-Klasse, dass sie zu dem entsprechenden Form<\/b>-Element gehört? Dies wird durch eine GUID festgelegt, die wir in beiden Fällen in der Eigenschaft FormDesignerId <\/b>finden.<\/p>\n

Umbenennen, schnelle Version<\/h2>\n

Dieser Umbenennungsprozess ist nur bei der standardmäßig vorhandenen Form nötig. Wenn wir über den Kontextmenüeintrag Add|Add Form Windows Form <\/b>des Eintrags Sources <\/b>im Projektexplorer ein neues Form<\/b>-Objekt hinzufügen, haben wir direkt nach dem Anlegen die Möglichkeit, dieses umzubenennen (siehe Bild 6).<\/p>\n

\"Umbenennen<\/p>\n

Bild 6: Umbenennen des Form-Elements<\/span><\/b><\/p>\n

Geben wir hier einen Namen wie im Beispiel frmSample <\/b>an, wird auch gleich die Code behind-Klasse umbenannt. Außerdem wird beim Form<\/b>-Objekt der Objektname auf frmSample <\/b>eingestellt und auch der Klassenname in der Datei frmSample.twin<\/b>.<\/p>\n

Wenn Du also beim Start das vorhandene Form<\/b>-Element Form1 <\/b>umbenennen möchtest, löscht Du es am besten direkt und erstellst ein neues Form<\/b>-Element mit dem gewünschten Namen.<\/p>\n

Startup-Form festlegen<\/h2>\n

Damit haben wir nun Änderungen durchgeführt, die sich auf den Start des Projekts auswirken. Beim ersten Test wurde nämlich das Form<\/b>-Objekt Form1 <\/b>geöffnet. Dieses ist nun nicht mehr vorhanden, also müssen wir angegeben, dass das nun in frmMain <\/b>umbenannte Fenster geöffnet werden soll. Das erledigen wir in den Settings<\/b>, die wir über den gleichnamigen Eintrag im Projektexplorer öffnen.<\/p>\n

Hier finden wir etwas weiter unten den Bereich Project: Startup Object<\/b>. Hier wählen wir wie in Bild 7 den Eintrag frmMain <\/b>aus.<\/p>\n

\"Einstellen<\/p>\n

Bild 7: Einstellen des bei Start anzuzeigenden Form-Objekts<\/span><\/b><\/p>\n

Alternativ können wir auch Sub Main <\/b>auswählen. In diesem Fall müssten wir eine Prozedur namens Main <\/b>bereitstellen, die beim Start aufgerufen wird. Dies eröffnet die Möglichkeit, vor dem Anzeigen des ersten Fensters bereits einige Anweisungen auszuführen. Wie das gelingt, zeigen wir im Artikel twinBASIC: Forms öffnen, schließen und mehr <\/b>(www.vbentwickler.de\/389<\/b>).<\/p>\n

Weitere Projekteinstellungen<\/h2>\n

Im gleichen Dialog finden wir weiter oben noch weitere wichtige Einstellungen, zum Beispiel den Projektnamen, eine Beschreibung und den Anwendungstitel (siehe Bild 8). Der Wert unter Project:Name <\/b>wird nicht angezeigt, sondern dient zum Beispiel folgenden Zwecken:<\/p>\n

\"Einstellen<\/p>\n

Bild 8: Einstellen weiterer Projekteigenschaften<\/span><\/b><\/p>\n