{"id":55000310,"date":"2022-04-01T00:00:00","date_gmt":"2024-01-26T10:43:15","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=310"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"twinBASIC_Visual_Basic_fuer_die_Zukunft","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/twinBASIC_Visual_Basic_fuer_die_Zukunft\/","title":{"rendered":"twinBASIC: Visual Basic für die Zukunft"},"content":{"rendered":"

\"\"<\/p>\n

twinBASIC ist eine moderne Version des klassischen Visual Basic, die auf 100% Kompatibilität zu bestehenden Visual Basic 6-Projekten ausgelegt sein wird. Es ist ein Projekt des englischen Programmierers Wayne Phillips, der bereits im Access-Umfeld mit spektakulären Lösungen auf sich aufmerksam gemacht hat. twinBASIC scheint jedoch sein Meisterwerk zu werden. Es kommt mit einer eigenen Entwicklungsumgebung, die sich nicht vor anderen modernen IDEs verstecken muss. In diesem Artikel schauen wir uns an, wie Du die twinBASIC-Entwicklungsumgebung installierst und die ersten Projekte damit erstellst. In weiteren Artikeln werfen wir einen Blick auf die verschiedenen Projekttypen und wie Du Lösungen damit erstellen kannst.<\/b><\/p>\n

Möglichkeiten von twinBASIC<\/h2>\n

twinBASIC schickt sich an, ein vollständiger Ersatz für Visual Basic 6 zu werden – und dieses auf eine moderne Ebene zu heben. Einer der wichtigsten Faktoren, warum Visual Basic 6 nicht mehr genutzt wurde, ist die Einschränkung auf 32-Bit. twinBASIC bietet auch die Möglichkeit, beispielsweise DLLs, COM-Add-Ins und mehr in einer 64-Bit-Version zu erstellen.<\/p>\n

Mittlerweile kann twinBASIC nicht nur reine Konsolenprojekte beziehungsweise DLLs und COM-Add-Ins, sondern auch solche mit Benutzeroberfläche erstellen.<\/p>\n

Geplant ist auch eine vollständige Kompatibilität mit Visual Basic 6, das heißt, dass Du Deine alten Visual Basic 6-Projekte hervorholen und modernisieren kannst.<\/p>\n

Welche Editionen bietet twinBASIC?<\/h2>\n

Zum Zeitpunkt der Erstellung dieses Artikels gibt es eine Community Edition, eine Professional Edition und eine Ultimate Edition. Die Community Edition bietet alle wichtigen Funktionen und erlaubt die kommerzielle Nutzung der damit erstellten Projekte.<\/p>\n

Einschränkungen sind eine nicht optimierte Kompilierung sowie die Anzeige von Splash-Screens bei Projekten auf Basis von 64-Bit. Diese Edition ist komplett kostenlos – es lohnt sich also, diese auszuprobieren.<\/p>\n

Die Professional Edition erlaubt das Kompilieren für 64-Bit ohne Anzeige von Splash-Screens in den damit erstellten Projekten. Außerdem erhält man Zugriff auf Betaversionen. Die Jahreslizenz kostet regulär 420 EUR, ist aber aktuell zum Vorbesteller-Rabatt für 248,80 EUR erhältlich (alle Preise zuzüglich MwSt.).<\/p>\n

Die Ultimate Edition liefert zusätzlich – und das ist wirklich revolutionär – Cross-Plattform-Kompatibilität, man kann also Projekte für die Nutzung unter Linux, Mac OS oder Android erstellen. Dieses Feature ist allerdings noch nicht verfügbar. Den reduzierten Jahrespreis kann man sich dennoch jetzt schon sichern. Die Jahreslizenz kostet regulär 756 EUR und kann aktuell zum Vorbesteller-Tarif für 486 EUR bestellt werden (alle Preis zuzüglich MwSt.).<\/p>\n

Die Möglichkeit zur Bestellung findest Du in unserem Shop unter https:\/\/shop.minhorst.com<\/b>. Dort wechselst Du einfach zur Kategorie Access-Tools und findest die Möglichkeit zur Bestellung einer Jahreslizenz. Und noch ein Hinweis: Aktuell gibt es keine Angabe seitens des Herstellers, wie lange die Vorbestellung noch möglich und damit der reduzierte Preis noch gültig ist. Der Hersteller sichert den Vorbestellerpreis jedoch auch für die Verlängerung der Lizenz über das erste Jahr hinaus zu!<\/p>\n

twinBASIC herunterladen<\/h2>\n

Den Download der Entwicklungsumgebung von twinBASIC findest Du aktuell in github.com. Da die Entwicklungsumgebung noch im Betastatus ist, werden regelmäßig neue Versionen veröffentlicht.<\/p>\n

Diese gibt Wayne Phillips unter folgendem Link bekannt:<\/p>\n

https:\/\/github.com\/WaynePhillipsEA\/twinbasic\/releases<\/pre>\n
Hier wählen wir einfach den obersten Eintrag aus – zum Zeitpunkt der Erstellung dieses Artikels beispielsweise Version Beta 79 (siehe Bild 1).<\/p>\n
\"Download<\/p>\n
Bild 1: Download von twinBASIC in der jeweils aktuellen Version<\/span><\/b><\/p>\n
twinBASIC starten<\/h2>\n
Nach dem Download der knapp 10 MB großen .zip<\/b>-Datei extrahiert man den kompletten Inhalt in das gewünschte Verzeichnis und startet twinBASIC <\/b>einfach durch einen Doppelklick auf die enthaltene Datei twinBASIC.exe<\/b>. Das heißt, Du brauchst noch nicht einmal eine Installation durchzuführen!<\/p>\n
Optionen einstellen<\/h2>\n
Beim ersten Start erscheint der Dialog twinBASIC: IDE options<\/b>, mit dem Du die gewünschten Einstellungen vornehmen kannst. Wichtig ist hier zum Beispiel, ob Du Anwendungen im 32-Bit- oder 64-Bit-Modus erstellen möchtest. Die übrigen Optionen sind weitgehend selbsterklärend (siehe Bild 2).<\/p>\n
\"Einstellen<\/p>\n
Bild 2: Einstellen der Optionen beim Starten<\/span><\/b><\/p>\n
Projekte neu anlegen oder öffnen<\/h2>\n
Nach dem Einstellen und dem Speichern der Optionen folgt der eigentliche Startbildschirm (siehe Bild 3).<\/p>\n
\"Vorlagen<\/p>\n
Bild 3: Vorlagen für Projekte<\/span><\/b><\/p>\n
Hier kannst Du zwischen den folgenden Projekttypen wählen, um ein neues Projekt anzulegen:<\/p>\n
    \n
  • Standard EXE<\/li>\n
  • ActiveX Control<\/li>\n
  • ActiveX DLL<\/li>\n
  • Standard DLL (non-ActiveX)<\/li>\n<\/ul>\n
    Außerdem kann man bestehende Projekte importieren:<\/p>\n
      \n
    • Import from VBP<\/li>\n
    • Import from Folder<\/li>\n<\/ul>\n
      Fertige Beispielprojekte<\/h2>\n
      Für den ersten Eindruck noch interessanter sind jedoch die Beispielprojekte, die wir unter dem Registerreiter Samples <\/b>finden (siehe Bild 4). Diese schauen wir uns im Anschluss im Detail an, um einen Eindruck von der Leistungsfähigkeit von twinBASIC <\/b>zu vermitteln.<\/p>\n
      \"Beispielprojekte\"<\/p>\n
      Bild 4: Beispielprojekte<\/span><\/b><\/p>\n
      Beispielprojekt öffnen<\/h2>\n
      Zum Öffnen eines der Beispielprojekte klickst Du einfach doppelt auf das jeweilige Projekt. In diesem Fall schauen wir uns das Projekt Sample 0. WebView2 Examples <\/b>an. Dies öffnet das Projekt in der Entwicklungsumgebung von twinBASIC<\/b> (siehe Bild 5).<\/p>\n
      \"Die<\/p>\n
      Bild 5: Die twinBASIC-Entwicklungsumgebung mit einem geöffneten Beispielprojekt<\/span><\/b><\/p>\n
      Beispielprojekt starten<\/h2>\n
      Für einen kleinen Ausblick, was wir mit twinBASIC <\/b>alles erledigen können, klicken wir einfach einmal auf die Starten-Schaltfläche in der oberen Menüleiste der twinBASIC<\/b>-Entwicklungsumgebung. Daraufhin erscheint direkt das Startmenü der Anwendung (siehe Bild 6). <\/p>\n
      \"Startmenü<\/p>\n
      Bild 6: Startmenü einer twinBASIC-Beispielapp<\/span><\/b><\/p>\n
      Klicken wir hier auf den ersten Eintrag, öffnet die Anwendung ein weiteres Fenster, in dem wir das neue WebView2<\/b>-Steuerelement ausprobieren können (siehe Bild 7). Außerdem zeigt Wayne Phillips mit diesem Beispiel, wie wir jede Menge interne Informationen zum Ablauf beim Browsen im Internet abgreifen und anzeigen können.<\/p>\n
      \"Webbrowser-Steuerelement<\/p>\n
      Bild 7: Webbrowser-Steuerelement in einer twinBASIC-Anwendung<\/span><\/b><\/p>\n
      Anwendung erstellen<\/h2>\n
      Nun wollen wir diese Anwendung noch erstellen. Dazu beenden wir den Debugging-Vorgang und klicken in der oberen Leiste auf die Schaltfläche Build <\/b>(siehe Bild 8). Damit erstellen wir nach dem Speichern des Projekts eine .exe<\/b>-Datei, die wir so direkt weitergeben können.<\/p>\n
      \"Erstellen<\/p>\n
      Bild 8: Erstellen einer twinBASIC-Anwendung<\/span><\/b><\/p>\n
      Was können wir mit twinBASIC machen?<\/h2>\n
      Nun stellt sich die Frage, was wir im Rahmen dieses Magazins mit twinBASIC <\/b>alles machen können. Die erste Antwort ist: Alles, was wir uns wünschen! twinBASIC bietet alle Möglichkeiten, um die folgenden interessanten Aufgaben zu erledigen:<\/p>\n
        \n
      • Erstellen selbstständiger .exe<\/b>-Anwendungen ohne Benutzeroberfläche, zum Beispiel als  Startup-Anwendung vor dem Öffnen einer Access-Anwendung, die prüft, ob die Access-Datenbank bereits geöffnet ist, ob es eine neue Version gibt oder ob die Verknüpfungen aktuell sind.<\/li>\n
      • Erstellen selbstständiger .exe<\/b>-Anwendungen mit Benutzeroberfläche. Wenn wir irgendwelche Aufgaben automatisieren wollen oder uns einfach eine Benutzeroberfläche für eine Aufgabe schaffen wollen, können wir die Möglichkeiten zum Erstellen von Anwendungen wie die zuvor vorgestellte nutzen.<\/li>\n
      • Erstellen von DLL-Bibliotheken, die oft verwendete Funktionen enthalten und die beispielsweise in die VBA-Projekte von Access-Datenbanken eingebunden werden oder die wir auch von anderen VBA-Projekten wie unter Outlook, Word, Excel und Co. nutzen können.<\/li>\n
      • Erstellen von COM-Add-Ins, die wir in die Office-Anwendungen Access, Excel, Outlook, Word et cetera einbinden können, beispielsweise um diese um selbst programmierte Funktionen zu erweitern. Diese können dann beispielsweise über benutzerdefinierte Steuerelemente im Ribbon oder in Kontextmenüs aufgerufen werden.<\/li>\n
      • Und wir können damit auch COM-Add-Ins für den VBA-Editor entwickeln, mit denen wir die dortigen Funktionen erweitern. Auch diese können wir über das dort verwendete Menüsystem bereitstellen.<\/li>\n<\/ul>\n
        Du siehst: Schon wenn wir uns die Ansatzpunkte für mögliche Anwendungen ansehen, finden wir eine Menge Optionen. In weiteren Artikeln in diesem Magazin werden wir uns die verschiedenen Optionen ansehen und Beispielanwendungen für die unterschiedlichen Einsatzgebiete und Zielanwendungen entwickeln.<\/p>\n
        Zusammenfassung und Ausblick<\/h2>\n
        Dieser Artikel hat einen ersten Einblick in die Möglichkeiten von twinBASIC geliefert. Damit kannst Du die Community Edition schon einmal herunterladen und ausprobieren – Beispielprojekte zum Ausprobieren gibt es genug (siehe Bild 9), und mit der Community Edition kannst Du alle Möglichkeiten von twinBASIC ausprobieren.<\/p>\n
        \"Anlegen<\/p>\n
        Bild 9: Anlegen des HelloWorld-Beispiels<\/span><\/b><\/p>\n
        In weiteren Artikeln werden wir uns die Programmiersprache twinBASIC<\/b> und die mitgelieferte Entwicklungsumgebung im Detail ansehen.<\/p>\n
        Dort werden wir uns dann um die verschiedenen Projekttypen kümmern, Beispielanwendungen für COM-Add-Ins und DLLs liefern und die Gemeinsamkeiten und Unterschiede von twinBASIC zu Visual Basic 6 ermitteln.<\/p>\n","protected":false},"excerpt":{"rendered":"
        twinBASIC ist eine moderne Version des klassischen Visual Basic, die auf 100% Kompatibilität zu bestehenden Visual Basic 6-Projekten ausgelegt sein soll. Es ist ein Projekt des englischen Programmierers Wayne Phillips, der bereits im Access-Umfeld mit spektakulären Lösungen auf sich aufmerksam gemacht hat. twinBASIC scheint jedoch sein Meisterwerk zu werden. Es kommt mit einer eigenen Entwicklungsumgebung, die sich nicht vor anderen modernen IDEs verstecken muss. In diesem Artikel schauen wir uns an, wie Du die twinBASIC-Entwicklungsumgebung installierst und die ersten Projekte damit erstellst. In weiteren Artikeln werfen wir einen Blick auf die verschiedenen Projekttypen und wie Du Lösungen damit erstellen kannst.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[66022022,662022,44000036,44000031],"tags":[],"yst_prominent_words":[],"class_list":["post-55000310","post","type-post","status-publish","format-standard","hentry","category-66022022","category-662022","category-Ribbon_programmieren","category-twinBASICProgrammierung"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000310","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/comments?post=55000310"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000310\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000310"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000310"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000310"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000310"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}