VB NET Tutorial 2 – Ausgaben & mehr Datentypen

Willkommen im VB NET Tutorial 2, wo wir weiter in die Welt der Programmierung wagen.

Nachdem wir uns im letzten Tutorial mit dem Einstieg in die Variablen beschäftigt haben, geht es hier weiter.

Eigentlich wollte ich hier auch schon mit den Variablen weiter machen, aber ich glaube, das wäre dann zu viel gewesen. Daher fokussieren wir uns lieber erstmal auf die Konsole und die Verkettung von Strings. Dafür müssen wir natürlich auch noch ein neues Projekt aufsetzen, etc.

Bisher haben wir auch leider noch nicht wirklich was von unseren Daten gesehen.

Wir definierten, deklarierten und initialisierten, aber haben davon nicht viel mitbekommen.

Der Code im Visual Studio, bzw. in Programmen verläuft generell linear.

Zeilenweise wurden unsere kleinen Anweisungen wie z. B. die Folgende ausgeführt:

Dim alter As Integer = 30

Dies funktionierte natürlich auch im Hintergrund alles so wie gewollt.

Der Speicher wurde in der Größe eines „Integers“ reserviert und die Variable wurde für uns ansprechbar.

Dazu konnten wir den Namen (alter in diesem Fall) verwenden und die Variable bei Bedarf ändern.

Das ging kinderleicht mit einer zusätzlichen Zeile, also mit einer Anweisung wie Diese hier:

alter = 33

Dabei müssen wir natürlich auf den korrekten Datentyp achten, da es sonst Probleme gibt.

Wir können also keinem String plötzlich eine Zahl zuweisen:

Dim name = "RobbelRoot"
' geht nicht!!
name = 33

Wie Du siehst, siehst Du nichts – erste Ausgaben

Bisher war es leider nicht möglich, die Variablen wirklich zu verfolgen.

Wie in der Programmierung normal, laufen die Codezeilen von oben nach unten ab.

Nach dem die Ausführung des Programms beendet ist, war es das dann einfach.

Visuell bekommen wir dadurch „leider“ kein Feedback und stehen im Dunkeln.

Später werden wir uns natürlich noch mit dem „Anschauen“ der Werte innerhalb von Visual Studio beschäftigen.

Dabei handelt es sich um das sogenannte „Debugging„, wo man die Werte dann auch Schritt für Schritt verfolgen kann.

Die altbekannte Konsole/Konsolenanwendung

Im heutigen Tutorial werden wir diese visuelle Darstellung aber durch die altbekannte Konsole realisieren.

Auch wenn die Konsole im ersten Schritt ein wenig altbacken erscheint, findet Sie heutzutage durchaus Verwendung.

Besonders viele bekannte Frameworks verwenden die sogenannten CLI– (Command Line Interface) Anwendungen.

Dort stellen Sie eine Hilfe zur Generierung von Projektvorlagen, oder ähnlichen Dingen dar.

Auch viele Konfigurationen im IT-Bereich werden statt mit einer „richtigen“ GUI, mit einer Konsolenanwendung durchgeführt.

Sie sind also – auch heute noch – alles Andere als wegzudenken.

Grafische Oberflächen – noch nicht!

Ich habe mich daher auch hier dazu entschieden, eine typische grafische Oberfläche, nach hinten zu schieben.

Auch wenn ich die sogenannte GUI (graphical user interface) durchaus auch für Anfänger als spannend empfinde.

Besonders das Zusammenklicken und das „Erfahren am Tun“ ist dort hiflreich.

Man klickt einen Button und es passiert irgendwas, man hat Textboxen und kann etwas eintragen, etc.

Dennoch kann es eben auch zu Verwirrung führen, da wir dort dann von Dingen wie Steuerelementen, Ereignissen, etc. sprechen.

Ich muss zugeben, dass mich die Vorgänge an der Konsole in meiner Zeit als Lernender genervt hat.

Man konnte eben nicht viel sehen und der geschriebene Code erschien irgendwie so unnahbar.

Lasse Dich davon aber nicht abschrecken, es wird Dir nachher helfen, alles besser zu verstehen.

Visual Studio öffnen – ein neues Projekt

Nun ist es an der Zeit einmal ein neues Projekt im Visual Studio anzulegen.

Im vorherigen Tutorial waren wir ja eher mehr theoretisch veranlagt, dass wollen wir nun ändern.

Öffne also nun Visual Studio und wähle rechts den Punkt „Neues Projekt erstellen„:

Projekt-Typ wählen

Nachdem Du diesen Menüpunkt ausgewählt hast, kommst Du in den nächsten Bildschirm.

Dort kannst Du dann den Projekt-Typ auswählen:

Wähle dort den Projekt-Typ „Konsolenanwendung (Visual Basic)“.

Falls Du diesen Projekt-Typ links nicht finden kannst, verwende dafür die Suche oben rechts.

Namen für Projekt festlegen

Sobald Du den Projekttyp ausgewählt hast und weiter gegangen bist, kannst Du einen Namen festlegen.

Später gehen wir noch auf Punkte wie „Name der Projektmappe“ ein, allerdings reicht der Projektname aktuell aus.

Beachte für den Anfang sonst nur den Pfad namens „Ort„, damit Du Deine Projekte auch wiederfindest!

Wähle dann einen für Dich und für Dein Projekt sinnvollen Namen und fahre fort.

Zielframework wählen

Im nächsten Schritt wählen wir mit unserem aktuellen Stand auch einfach nur das standardmäßig ausgewählte Zielframework.

Mach es Dir also nicht schwer und nutze das schon ausgewählte Framework (in meinem Fall .NET Core 3.1).

Ein leeres „Read to go“-Projekt

Danach befinden wir uns im Bildschirm des neu angelegten, leeren Projekts.

Ich habe Dir im Bild markiert, worauf Du in den nächsten Zeilen Deine Aufmerksamkeit lenken solltest.

Alles Andere würde Dich vermutlich nur ablenken und erstmal nur unnötig verwirren, oder überfordern.

Visual Studio Projekt anlegen – In einem neuen Konsolenanwendungs-Projekt

Falls Du allerdings doch schon ein paar Zusatzinformationen haben möchtest, okeydokey!

Projektmappen-Explorer

Rechts oben siehst Du den Projektmappen-Explorer, dort können wir in einer „Mappe“, unsere Projekte organisieren.

Wie das schon suggeriert, kann ein „Projekt“, bzw. eine Projektmappe also verschiedene Projekte beinhalten.

Dabei muss es sich also nicht immer nur um 1 Projekt wie die Konsolenanwendung handeln.

Git-Änderungen

Wenn wir in der Nähe des Explorers auf das nächste Tab gehen, können wir zum Beispiel die Git-Änderungen schauen.

Das ist (für den jetzigen Stand) einfach eine Möglichkeit, die Änderungen unseres Quellcodes sinnvoll zu verwalten.

Klassenansicht

Als nächstes Tab, kommt die Klassenansicht, wo wir einfach praktisch eine andere Ansicht über die Klassen-Struktur bekommen.

Auch das wird später sehr wahrscheinlich mehr einleuchten als jetzt!

Eigenschaftsfenster

Darunter befindet sich das Eigenschafts-Fenster, Welches uns je nach vorher ausgewähltem Element gewisse Eigenschaften anzeigt.

Wähle ich zum Beispiel das Projekt im Explorer aus (in unserem Fall VBTutorial 2b), kann ich hier weitere Eigenschaften dazu sehen.

Über die anderen Bereiche, sprechen wir dann wirklich später!

Das Programm ausführen – VB NET Tutorial 2

Bevor wir nun mit dem Coden fortfahren, kannst Du Dir ja schonmal anschauen, wie man das Programm ausführt.

Damit nun ein wenig Action ins Spiel kommt, klicke mit Deiner Maus einfach mal oben in der Mitte auf den „Play„-Knopf.

Alternativ kannst Du auch den Hotkey „F5“ drücken, Welchen Du vermutlich noch sehr oft benötigen wirst.

Präge Dir den Hotkey deswegen am besten auch so schnell es geht ein!

Damit wird das Programm im „Debug„-Modus gestartet und – ups, verschwindet gleich wieder..

Wenn Deine Augen schnell sind, siehst Du vermutlich kurz ein schwarzes Fenster aufblinken.

Das ist, bzw. war dann die Konsole, Welche den Befehl tatsächlich ausgeführt hatte, eine Zeile auf Ihr auszugeben.

Lass mich Dir kurz ein wenig den Ablauf erklären..

Wenn ein Programm gestartet wird, wird nach einem Einstiegspunkt gesucht, also wo das Ganze Programm „los geht“.

In unserem Fall hier ist das die „Main“-Methode, Welche sich im „Program„-Modul befindet und nur eine Zeile enthält.

Dabei handelt es sich um eine „WriteLine“-Anweisung, Welche den gewählten Text „Hello World“ auf der Konsole ausgibt.

Nachdem die Konsole mit der Ausgabe fertig ist, gibt es keine weiteren Anweisungen mehr im Programm.

Somit wurden alle Arbeiten erledigt und das Programm, bzw. die Konsole wird wieder geschlossen.

Gleich schauen wir uns an, wie man dieses Verhalten verhindern kann.

Die erste Ausgabe auf der Konsole – VB NET Tutorial 2

Sorgen wir nun im nächsten Schritt einmal darum, dass das Programm sich nicht immer sofort beendet.

Damit haben wir dann endlich die Chance, die Ausgabe aktiv zu verfolgen, ohne „The Flash“ sein zu müssen.

Im Endeffekt ist das auch gar nicht schwer, wir müssen der Konsole nur irgendwie „Hey, warte mal“ sagen.

Dafür haben wir für den Anfang 2 einfache und sinnvolle Möglichkeiten:

• Die „Console.ReadKey“-Methode
• oder die seitens UI bekanntere „Console.ReadLine“-Methode

Die „ReadKey„-Methode liest – wie der Name vermuten lässt – einen bestimmten „Key„.

Dabei handelt es sich um einen Tastendruck = Tippen von z. B. „b„.

Die Konsole pausiert nach Start des Befehls solange, bis es einen gewissen Input von uns bekommt.

Bei Variante 1 ist es wie gesagt ein einziger „Key“ und bei der nächsten Variante bis Sie ein „Enter“ bekommt.

Code anpassen – Ausgabe

Wenn Du nun also bereits wie oben beschrieben ein Projekt angelegt hast, geht’s nun weiter.

Wir werden nun eine der genannten Methoden verwenden, um das Beenden der Konsole zu verhindern.

Passe den Code also nun so an, dass der „Console.ReadLine“-Befehl seinen Platz findet:

Module Program

    Sub Main(args As String())
        Console.WriteLine("Dies ist unsere Ausgabe!")
        Console.ReadLine()
    End Sub

End Module

Dadurch dürftest Du nun die Ausgabe des Textes „Dies ist unsere Ausgabe!“ sehen:

Programm schließen

Diese Ausgabe bleibt nun solange stehen, bis Du das Programm:

• entweder durch das „X“ oben rechts
• durch drücken einer Eingabe von z. B. „abc“ und „Enter“ beendest
• alternativ kannst Du auch den Stop-Knopf im Visual Studio benutzen

Nun bist Du natürlich herzlich eingeladen, einmal die Definitionen von Variablen aus Tutorial 1 zu wiederholen.

Diese, oder neue Definitionen, bzw. deren dahinterstehende Werte werden wir gleich einmal ausgeben.

Am einfachsten ist es am Anfang mit Strings, warum wirst Du gleich noch erfahren.

Strings definieren – Einladung & Wiederholung

Definiere daher einfach mal 2-3 Strings und dann sehen wir weiter.

Ich habe hier bewusst nochmal die 3 Möglichkeiten zur Definition verwendet.

Zur Erinnerung, die Möglichkeiten zur Definition waren:

• Deklaration (mit anschließender Zuweisung bei Bedarf)
• Initialisierung
• Initialisierung mit Typinferenz

' Variante 1
Dim vorname As String
vorname = "Robert"

' Variante 2
Dim youtubeKanal As String = "RobbelRoot"

' Variante 3
Dim befehl = "Download"

Die definierten Variablen ausgeben

Nun können wir auch einmal die definierten Variablen, statt der geschriebenen Texte ausgeben lassen.

Dafür können wir der „Console.WriteLine“-Methode einfach unsere Variablen übergeben:

Dim befehl = "Download"
Console.WriteLine(befehl)
Console.ReadLine()

Nun dürfest Du auch die „befehl“-Variable ausgegeben bekommen.

Schön wäre es auch, wenn man nun so etwas wie „Hey, in der Variable steht: <InhaltDerVariable>“ ausgeben könnte.

Das geht zum Glück auch ganz einfach mit dem verketten von Strings.

Dabei spielt es keine Rolle, ob wir diesen String selbst schreiben, also im Sinne von „Das ist ein String“ (mit Anführungszeichen).

Oder ob wir den String wie oben vorher in einer Variable gespeichert haben.

Strings miteinander verketten

Durch die Verkettung von Strings können wir beliebig viele Strings aneinander reihen.

Das funktioniert in Kombination mit dem Verkettungsoperator – in Visual Basic ist das das „&„-Zeichen.

In anderen Sprachen ist es häufig das „+„-Zeichen, nur mal so als Anmerkung.

Hier hast Du ein Beispiel für die Ausgabe und die Verkettung von 2 Strings:

Dim befehl = "Download"
Console.WriteLine("Hey, in der Variable steht: " & befehl)

Dadurch wird nun diese Ausgabe auf der Konsole zustande kommen:

Beachte hierbei wie gesagt, dass es sich hier einfach nur um 2 Strings handelt, Welche wir verkettet haben.

Links ist ein String, rechts ist ein String – ganz easy, Punkt!

Du könntest stattdessen auch 5 Strings verketten, kein Thema, wobei ich hier sogar die Variable mehrfach genutzt habe:

Dim befehl = "Download"
Console.WriteLine("Das ist ein " & befehl & ", plus ein " & befehl & " mit Strings!")

Diese Verkettung funktioniert auch nicht nur bei der Ausgabe selbst, wir können die Variable auch so neu zuweisen:

Dim befehl = "Download"
befehl = "Dies ist ein " & befehl

Falls wir die String-Variable nur „erweitern“ möchten, also einen String anfügen wollen, geht das auch kürzer:

Dim befehl = "Download"
befehl &= " erweitert um das hier!"

Das „und-gleich“ (&=) könnte man hier als „erweitere um“ übersetzen, cool oder!?

Letztendlich sind also diese beiden Anweisungen hier praktisch das Gleiche:

befehl = befehl & " erweitert um das hier!"
befehl &= " erweitert um das hier!"

So, ich denke das war es an dieser Stelle für das heutige Tutorial, sonst dürfte es zu viel werden.

Fazit

Im heutigen Tutorial haben wir uns mit der ersten Ausgabe von Daten beschäftigt.

Diese Daten waren in erster Linie Strings, Welche wir als Literale, oder als Variablen geschrieben haben.

Zur Erinnerung: Literale sind einfach gewisse Schreibweisen, von Denen man ableiten kann, was der dahinter stehende Wert ist.

Ein Beispiel wären die Anführungszeichen im Quellcode, woran man erkennt, dass es sich um einen String handelt.

Anschließend habe wir verschiedene Verkettungsoperationen durchgeführt, um die Ausgabe ein wenig dynamischer zu gestalten.

Damit das Ganze überhaupt möglich war, haben wir natürlich auch noch ein neues Visual Studio Projekt aufgesetzt.

Downloads

Weiterführende Links

• weiter zu Tutorial 3 – Eingaben verarbeiten
• VB NET Timer Beispiel
• zurück zu Tutorial 1 – Variablen

Der Beitrag VB NET Tutorial 2 – Erste Ausgaben auf der Konsole erschien zuerst auf Robert Skibbe.