VB NET Tutorial 3 – Eingaben entgegennehmen & verarbeiten

VB NET Tutorial 3 - Eingaben in die Konsole verarbeiten
VB NET Tutorial 3 – Eingaben in die Konsole verarbeiten

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

VB NET Tutorial 3 - Interaktion zwischen Nutzer und Programm
VB NET Tutorial 3 – Interaktion zwischen Nutzer und Programm

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:

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

VB NET Tutorial 3 - Buchstaben entgegennehmen
VB NET Tutorial 3 – Buchstaben entgegennehmen

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 „bein, 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

VB NET Tutorial 3 - Zeichen entgegennehmen und ausgeben
VB NET Tutorial 3 – Zeichen entgegennehmen und ausgeben

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

VB NET Tutorial 3 - Eins ungleich eins
VB NET Tutorial 3 – Eins ungleich eins

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.

Zahlen in Konsole einlesen
Zahlen in Konsole einlesen

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.0Dbenutzen.

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 Klasseeingehen, 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 „ToDecimalin 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!

VB NET - Die richtige Einstellung
VB NET Die richtige Einstellung

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 Projektmappenund danach auf „VB-Standard„.

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

VB NET Option Strict On Einstellung
VB NET Option Strict On Einstellung

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

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.