VB NET Tutorial 3 – Eingaben entgegennehmen & verarbeiten
Inhaltsverzeichnis
- 1 Verarbeitung von ersten Eingaben in die Konsole – VB NET Tutorial 3
- 2 Eingaben entgegennehmen – VB NET Tutorial 3
- 3 Das Alphabet oder so – Einen Buchstaben verarbeiten im VB NET Tutorial 3
- 4 Auf den Datentyp kommt es an – VB NET Tutorial 3
- 5 Ein kleiner Taschenrechner – Werte konvertieren
- 6 Die richtige Einstellung – von vorne herein!
- 7 Fazit
- 8 Kompletter Code
- 9 Downloads
- 10 Weiterführende Links
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:
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.
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
