Verarbeitung von ersten Eingaben in die Konsole – VB NET Tutorial 3

Heyho und herzlich willkommen zurück zum VB NET Tutorial 3!

Nachdem wir uns beim letzten Tutorial mit den Ausgaben beschäftigt haben, wechseln wir nun zu Eingaben.

Bevor wir zu einer ausgereiften grafischen Oberfläche wechseln, arbeiten wir weiter mit der Konsolenanwendung.

Auch dort kennt man es z. B. von gewissen Konfigurationsprogrammen, dass man Eingaben zur Steuerung verwendet.

Dabei reicht es von einfachen „J/N“, also Ja/Nein Antworten bis hin zu sogenannten Flags wie „-force“, oder Ähnliches.

Diese meist als Parameter bezeichneten Daten werden ganz normal als Text in die Konsole eingegeben.

Wie gewohnt müssen wir seitens der Konsole dann auf die Bestätigung durch z. B. „Enter“ warten.

Eingaben entgegennehmen – VB NET Tutorial 3

Um Programme verschiedenster Art die gewollten Sachen ausführen zu lassen müssen wir mit dem Nutzer interagieren.

Dafür müssen wir ihm natürlich in irgendeiner Weise die Möglichkeit zur Kommunikation geben.

Ich spreche von der Kommunikation zwischen Programm und dem Nutzer selbst.

Moderne Anwendungen

Für gewöhnlich, bzw. in modernen Anwendungen passiert das meist anhand einer grafischen Oberfläche.

Später werden wir uns natürlich auch noch mit richtigen, sogenannten GUIs beschäftigen.

Diese grafischen Nutzeroberflächen (graphical user interfaces) beinhalten meist Knöpfe, Tabellen, Dialoge und mehr.

Ich hatte schonmal in einem früheren Beitrag erwähnt, dass dies zum jetzigen Zeitpunkt aber noch zu kompliziert wäre.

Daher bleiben wir also erstmal bei den guten alten Konsolenanwendungen.

Konsolenanwendungen = Altbacken?

Obwohl man vielleicht denken könnte, dass die Konsolenanwendungen altbacken sind, ist dem nicht so.

Viele moderne Tools verwenden immer noch Konsolenanwendungen.

Darunter gibt es Fälle, in denen man damit gewisse Templates generieren kann.

Auch Konfigurationen werden auf diese Art und Weise via Kommandozeile durchgeführt.

Besonders im Laufe Deiner Entwickler-Karriere wird wirst Du ganz viele dieser Kommandozeilen-Tools kennenlernen.

Bekannte Funktionen

Um Daten vom Nutzer in einer Konsolenanwendung entgegenzunehmen, benötigen wir Standardfunktionen.

Diese haben wir auch schon im letzten Tutorial verwendet, zwar anders, aber naja trotzdem!

Letztes Mal haben wir sie dafür benutzt, um das Programm anzuhalten und sich nicht (sofort) schließen zu lassen.

Allerdings können die Funktionen noch mehr, ansonsten wäre auch die Namensgebung quatsch.

Die beiden Funktionen, Welche ich meine sind:

• „Console.ReadLine„
• „Console.ReadKey„

Das Alphabet oder so – Einen Buchstaben verarbeiten im VB NET Tutorial 3

Für unser erstes kleines Beispiel schauen wir uns die „ReadKey“-Funktion genauer an.

Wundere Dich bitte übrigens nicht, wenn die beiden Wörter Methode & Funktion manchmal gemischt verwendet werden.

Sie stehen indirekt für das Gleiche, da Sie mehr oder weniger verwandt sind.

Das Wort „Methode“ ist praktisch der Überbegriff für Funktionen und sogenannten „Subs„, Welche später noch drankommen.

Im nächsten Schritt kannst Du ein neues Visual Studio Projekt (Konsolenanwendung) für dieses Tutorial erstellen.

Falls Du nicht mehr weißt wie das geht, schaue am besten nochmal einen Schritt zurück.

Die ReadLine-Funktion im Einsatz

Nun werden wir die „ReadLine„-Funktion mal so einsetzen, wie Sie auch eingesetzt werden sollte.

Wir nehmen Zeichen entgegen und geben Diese anschließend aus.

Verwende dafür im ersten Schritt den folgenden Code:

Console.WriteLine("Gib etwas ein :)")
Dim eingabe = Console.ReadLine()
Console.WriteLine("Du hast " & eingabe & " eingegeben")
Console.ReadLine()

Ich benutze hier absichtlich nicht die „ReadKey“-Funktion, da Diese noch wesentlich komplizierter sein würde.

Dort bekommen wir anderweitige Daten, womit wir uns später noch befassen werden.

Führe am besten den Code aus und gebe in der Konsole einen Buchstaben wie „b“ ein, bestätige anschließend mit „Enter„.

Dann wirst Du die Ausgabe a la „Du hast <deinBuchstabe> eingegeben“ sehen können.

Ich möchte Dir auch hier mal eine andere Variante für die Verkettung von Strings zeigen.

Verwendung der String-Interpolation

Es ist dann so gesehen keine Verkettung mehr, kommt aber auf das gleiche Ergebnis hinaus.

Man nennt diese Variante „String-Interpolation“ und Sie vereinfacht viele Dinge.

Wir sparen uns dadurch im Endeffekt dieses Ganze „&, &, &“, was es durchaus angenehmer gestaltet.

Nehmen wir also obigen Code noch einmal, nur dieses Mal mit der String-Interpolation:

Console.WriteLine("Gib etwas ein :)")
Dim eingabe = Console.ReadLine()
Console.WriteLine($"Du hast {eingabe} eingegeben")
Console.ReadLine()

Wie Du sehen kannst, kann man dafür ganz einfach ein Dollar-Zeichen vor den String setzen.

Anschließend kannst Du die Variable in geschweiften Klammern setzen, dadurch wird die Variable in einen String umgewandelt.

Wir haben in diesem Fall schon einen String vorliegen, weshalb die Umwandlung hier eigentlich nicht wirklich nötig ist.

Später kommen aber noch wesentlich komplexere Objekte, wo wir die Umwandlung in einen String dann selbst gestalten können.

Darstellung von Anführungszeichen

Man könnte die Ausgabe auch noch etwas schöner gestalten.

Ich dachte da an Anführungszeichen, Welche nochmal genauer hervorheben, was wir eingegeben haben.

Natürlich können wir das erstmal mit den einfachen Anführungszeichen gestalten:

' ...
Console.WriteLine($"Du hast '{eingabe}' eingegeben")
' ...

Um doppelte Anführungszeichen verwenden zu können, müssen wir Diese „escapen„.

Wenn Du versuchst, die Anführungszeichen wie die Einfachen zu platzieren, wirst Du einen Fehler bekommen.

Damit das funktioniert, musst Du die Anführungszeichen einfach „doppeln„:

' ...
Console.WriteLine($"Du hast ""{eingabe}"" eingegeben")
' ...

Das liegt daran, dass der Compiler sonst denken würde, dass der String am ersten Zeichen endet.

Auf den Datentyp kommt es an – VB NET Tutorial 3

Bisher haben wir bewusst nur mit Strings gearbeitet, aber nun wird es Zeit für mehr!

Falls Du zwischendurch einmal versucht hast Zahlen einzugeben, wird es auf den ersten Blick funktioniert haben.

Das liegt daran, dass wir einen String einlesen und letztendlich auch einen String wieder ausgeben.

Also keine große Magie, könnte man auf den ersten Blick meinen.

Leider ist es nicht ganz so einfach, da eine Zahl im Hintergrund natürlich anders verarbeitet werden möchte.

Äpfel sind keine Birnen..

Wenn wir z. B. eine simple Addition durchführen wollen, brauchen wir immerhin 2 tatsächliche Zahlen.

Bisher lesen wir alles aber nur im Zeichenfolgen-Format (String) ein.

Diese kann man letztendlich nur verketten, aber leider nicht korrekt addieren.

Ich würde Dir hier dringend empfehlen eine gewisse Einstellung in Visual Studio festzulegen. Sie verhindert die unsaubere Arbeit mit Datentypen von Deinen Anfängen an. Somit gewöhnst Du Dir von vorne rein einen sauberen Stil mit Datentypen an. Schaue dafür weiter unten in den Beitrag.

So wäre z. B. das Ergebnis aus „1 + 1“ praktisch „11“ und nicht 2..

Das wird besonders in anderen Programmiersprachen wie C#, Java, oder ähnlichen Sprachen klar.

Dort ist der Verkettungsoperator meistens der Gleiche wie Der für die mathematische Addition.

Ein kleiner Taschenrechner – Werte konvertieren

Nun, wo wir wissen, dass die Arbeit mit den richtigen Datentypen aus verschiedenen Gründen wichtig ist, geht es weiter.

Bedenke wie gesagt, dass Äpfel eben keine Birnen, also z. B. Strings eben keine Integer sind.

Auch wenn Beide hier erstmal visuell gleich erscheinen, sind sie etwas Anderes!

Eine kleine Addition programmieren

Machen wir uns nun im nächsten Schritt mal ran, so richtig was mit den Eingaben des Nutzers anzufangen.

Ich dachte hier an einen kleinen Taschenrechner, Welcher allerdings erstmal nur Additionen unterstützt.

Gerne kannst Du natürlich versuchen, den Taschenrechner in Eigenarbeit zu erweitern.

Das wäre sicherlich eine tolle Übung und bringt Dich ggf. das ein oder andere Mal ins Schwitzen.

Aber nun gut, fangen wir mit den ersten Schritten für den Taschenrechner an.

Wir brauchen folgendes:

• Eine Aufforderung für die Eingabe zweier Zahlen
• Die Möglichkeit diese Zahlen entgegenzunehmen
• Dabei müssen wir auf den tatsächlichen Datentyp achten
• Wir addieren beide Zahlen
• Und geben das Ergebnis anschließend aus

Auf los geht’s los – Die Aufforderung an den Nutzer

Als erstes brauchen wir also eine Art Aufforderung, damit der Nutzer der Konsole auch weiß, was er tun soll.

Wir geben also im ersten Schritt eine Nachricht via „Console.WriteLine“ aus.

Vergiss anschließend nicht, den „Console.ReadLine„-Befehl zu verwenden, damit das Programm nicht beendet wird.

Console.WriteLine("Willkommen im kleinen Taschenrechner")
Console.WriteLine("Bitte gib zwei Ganz- oder Dezimalzahlen ein und bestätige Sie jeweils mit Enter")

Ein neuer Datentyp – ohoh!

Im gleichen Schritt dachte ich mir, könnte man auch einen neuen Datentyp bekannt machen.

Ich denke wir möchten ungern nur mit Ganzzahlen a la „8“, „9“, etc. arbeiten, daher brauchen wir den Datentyp „Decimal„.

Um eine Addition durchzuführen benötigen wir ja zwei Summanden, Welche dann die Summe ergeben.

Wir definieren diese Summanden mit Absicht auf zwei verschiedene Weisen, damit man Beide nicht vergisst:

Dim summandA As Decimal
Dim summandB = 0D

Der erste Summand wird per Deklaration definiert, wobei auch hier der Standardwert „0“ gezogen wird.

Anschließend wird der zweite Summand mit einem Literal und der daraus resultierenden Inferenz initialisiert.

Achte darauf, dass Du nicht unbeabsichtigt „0.0“ schreibst, denn dann wird daraus ein anderer Datentyp.

Wenn Du die „0.0“ Schreibweise bevorzugst, kannst Du in unserem Fall hier „0.0D“ benutzen.

Du wirst durch Visual Studio ggf. auch eine Meldung a la „unnötige Wertzuweisung summandB“ bekommen.

Das ist deshalb so, weil die Wertzuweisung eben unnötig ist, denn Sie wird ein paar Zeilen weiter sowieso überschrieben.

Ich habe es aber wie bereits erwähnt deshalb so gemacht, damit Du Dich nochmal an die beiden Varianten der Variablendefinition erinnerst.

Die Eingaben der (Dezimal-) Zahlen programmieren

Nun gehen wir hin und fragen tatsächlich nach den Zahlen, das machen wir wie gewohnt mit „Console.ReadLine“.

Du wirst Dich jetzt (hoffentlich) ggf. fragen: „Ähm, aber dann bekommen wir doch einen String!?“.

Das fragst Du Dich zurecht, aber diesen String werden wir gleich in eine Dezimalzahl umwandeln!

Gängige Umwandlungen können wir mit der „Convert“-Klasse durchführen.

Später werden wir natürlich noch genau auf das ganze Ding namens „Klasse“ eingehen, aber aktuell passt das erstmal so.

Achte darauf, dass Du im Visual Studio oben eventuell die Zeile hier stehen hast (über „Module Program“).

Imports System

Es könnte allerdings auch sein (bzw. wird es in diesem Fall), dass es auch ohne funktioniert.

Dieses Ding namens „Convert“ befindet sich nämlich wie ein Buch praktisch in diesem Regal namens „System„.

Mehr Gedanken solltest Du Dir zu diesem Zeitpunkt noch nicht darüber machen – vertrau‘ mir!

Schreibe also nun folgende Zeilen hinzu:

Dim eingabeA = Console.ReadLine()
summandA = Convert.ToDecimal(eingabeA)

Mit der Ersten dieser Zeilen holen wir uns die Eingabe des Nutzers.

Beachte hier, dass wir aktuell wirklich nur Zahlen erwarten, da wir eine Behandlung von Fehlern noch nicht haben!

Die zweite Zeile wandelt dann die „eingabeA“ durch die Klasse „Convert“ und deren Funktion namens „ToDecimal“ in die Dezimalzahl.

Das wiederholen wir dann dementsprechend für die zweite Zahl:

Dim eingabeB = Console.ReadLine()
summandB = Convert.ToDecimal(eingabeB)

Ggf. möchtest Du auch noch irgendwelche Nachrichten zwischendurch ausgeben, a la „Hey, jetzt gib Zahl 1/2 ein“.

Ergebnis ausgeben

Zum Schluss erfassen wir das Ergebnis mit:

Dim ergebnis = summandA + summandB

Das Ergebnis einer Addition aus 2 Dezimalzahlen ist natürlich eine Dezimalzahl.

Die Typinferenz für die Variable „ergebnis“ ist daher natürlich auch dementsprechend eine Zahl vom Typ „Decimal“.

Im letzten Schritt kannst Du dann das Ergebnis an den Nutzer ausgeben.

Beachte, dass ich dafür auch wieder die String-Interpolation (mit dem Dollar vorn und den geschweiften Klammern) nutze.

Console.WriteLine($"Das Ergebnis von {summandA} + {summandB} = {ergebnis}")

Alternativ könnte es auch so funktionieren:

Console.WriteLine("Das Ergebnis von " & summandA & " + " & summandB & " = " & ergebnis)

Natürlich solltest Du die grundsätzliche Verkettung von Strings beherrschen, allerdings ist obige Variante einfacher.

Man sieht ganz klar, wie man ohne die ganzen Unterbrechungen und „&“-Zeichen auskommen kann.

Die richtige Einstellung – von vorne herein!

Wie oben schonmal erwähnt, würde ich Dir gerne eine gewisse Visual Studio Einstellung ans Herz legen.

Diese sorgt von vorne rein für einen saubereren Umgang mit Datentypen.

Somit ist das Jonglieren mit Datentypen sofort Geschichte und wir verhindern es, dass Du es Dir falsch angewöhnst.

Viele Anfänger im VB NET-Bereich gewöhnen sich von vorn herein einen schlechten Stil mit Datentypen an.

Das ist unter anderem auch ein Grund, weshalb Visual Basic NET von einigen anderen Programmierern verpönt wird.

Lass Dich davon allerdings nicht abschrecken, da VB NET eine großartige Programmiersprache ist.

Wie bei vielen Werkzeugen kommt es einfach darauf an, wie man es verwendet!

Die „Option Strict“-Einstellung global setzen

Eins vorweg: Wir könnten die Einstellung auch projektbezogen setzen.

Allerdings ist das meiner Meinung nach nicht wirklich sinnvoll, da man Sie immer verwenden sollte.

Gehe nun auf den Punkt „Extras„, oben im Visual Studio und klappe Diesen auf.

Wähle danach den Punkt „Optionen“ und öffne Diese.

Klicke links außen auf die Einstellungen namens „Projekte und Projektmappen“ und danach auf „VB-Standard„.

Anschließend kannst Du die „Option Strict„- Einstellung auf „On“ stellen.

Nun bist Du typensicher, herzlichen Glückwunsch!

Beachte jedoch, dass die Einstellung sich nur auf künftig erstellte Projekte auswirkt.

Alte Projekte, oder Projekte von Dritten können diese Einstellung immer noch überschreiben!

Fazit

Im heutigen Beitrag haben wir einen kleinen Taschenrechner programmiert, Welcher Additionen durchführen kann.

Dabei mussten wir uns an einen neuen Datentyp namens „Decimal“ heranwagen, damit wir auch mit Dezimalzahlen arbeiten konnten.

Nach der Berechnung haben wir das Ergebnis durch String-Interpolation ausgegeben.

Zusätzlich haben wir eine wichtige Einstellung im Visual Studio konfiguriert: „Option Strict“.

Diese sorgt dafür, dass wir uns weiterhin einen sauberen Umgang mit Datentypen angewöhnen.

Kompletter Code

Module Program

    Sub Main(args As String())

        'Console.WriteLine("Gib etwas ein :)")
        'Dim eingabe = Console.ReadLine()
        'Console.WriteLine($"Du hast ""{eingabe}"" eingegeben")
        'Console.ReadLine()

        Console.WriteLine("Willkommen in meinem kleinen Taschenrechner")
        Console.WriteLine("Aktuell kann Er nur Additionen :P")
        Console.WriteLine()

        Dim summandA As Decimal
        Dim summandB = 0D

        Console.WriteLine("Bitte gib die erste Zahl ein:")
        Dim eingabeA = Console.ReadLine()
        summandA = Convert.ToDecimal(eingabeA)
        Console.WriteLine("Danke, nun gib bitte auch nochmal die zweite Zahl ein:")

        Dim eingabeB = Console.ReadLine()
        summandB = Convert.ToDecimal(eingabeB)

        Dim ergebnis = summandA + summandB
        Console.WriteLine($"Das Ergebnis von {summandA} + {summandB} = {ergebnis}")
        ' Console.WriteLine("Das Ergebnis von " & summandA & " + " & summandB & " = " & ergebnis)

    End Sub

End Module

Downloads

Weiterführende Links

• weiter zu Tutorial 4 – folgt noch
• VB NET BackgroundWorker Beispiel
• zurück zu Tutorial 2

Der Beitrag VB NET Tutorial 3 – Eingaben entgegennehmen & verarbeiten erschien zuerst auf Robert Skibbe.

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.

Auf YouTube ansehen Code Download

Der Beitrag Mit der Konsole (CMD) arbeiten erschien zuerst auf Robert Skibbe.