Ein Grundkurs in Programmierung mit Visual Basic .NET

Die Seite wird erstellt Vicky Holz
 
WEITER LESEN
ISBN 3-8272-6425-1     Visual Basic .NET

Kapitel 3

Ein Grundkurs
in Programmierung
mit Visual Basic .NET

 Programmieren zu lernen bedeutet, viel Neues in kurzer Zeit zu
 lernen, im Großen wie im Kleinen. In diesem Kapitel lernen Sie
 das kleine Einmaleins der Programmierung mit Visual Basic
 .NET kennen. Dazu gehören allgemeine Regeln, wichtige Be-
 fehle, Variablen, Operatoren, Kommentare, kurz, die Grundzu-
 taten, die in jedem Visual Basic .NET-Programm benötigt
 werden. Außerdem erfahren Sie, wie ein Computerprogramm
 Entscheidungen trifft. Haben Sie dieses Prinzip verstanden, wis-
 sen Sie, wie ein Computer »denkt«, und wissen gleichzeitig,
 dass kein Computer wirklich intelligent ist.
Ihr Erfolgsbarometer

Das können Sie schon:
.NET installieren                                                 21
Der Umgang mit Visual Studio .NET                                 52

              Das lernen Sie neu:
              Der allgemeine Aufbau eines Visual Basic
              .NET-Programms                                      60
              Konsolenprogramme umsetzen                          65
              Variablen als Kurzzeitgedächtnis des Computers 70
              Ausgaben in der Konsole                             73
              Eingaben über die Konsole                           74
              Wie ein Programm mit Operatoren rechnet             77
              Ein kleiner Mehrwertsteuerrechner                   80
              Stunde der Entscheidung oder wie ein
              Computerprogramm Entscheidungen trifft              81
              Sprechen Sie Visual Basic .NET?
              Ein kurzer Überblick über den Befehlssatz           91

                                                                         59
Hinweis
          Anders als im letzten Kapitel geht es im Folgenden nicht um Windows-
          Programme, die mit Formularen und Steuerelementen ausgestattet sind.
          In diesem Kapitel lernen Sie die Grundregeln der Programmierung am
          Beispiel von Konsolenprogrammen. Auch wenn die Ein- und Ausgabe
          hier nur über die Kommandozeile erfolgt, ist dies kein Nachteil. Im
          Gegenteil, da Konsolenprogramme nicht unbedingt Visual Studio .NET
          benötigen, sondern schnell mit Notepad eingetippt, in eine Datei
          gespeichert und mit dem Visual Basic .NET-Compiler kompiliert wer-
          den, geht alles ein wenig schneller. Dieses Kapitel können Sie also auch
          dann durcharbeiten, wenn Sie nur über das .NET Framework SDK verfü-
          gen.

     Der allgemeine Aufbau eines
     Visual Basic .NET-Programms
     Bevor es mit den ersten Beispielen losgeht, müssen wir uns kurz mit dem all-
     gemeinen Aufbau eines Visual Basic .NET-Programms beschäftigen. Sie wer-
     den am Ende feststellen, dass Sie damit die Funktionsweise eines Visual
     Basic .NET-Programms besser verstehen und die einzelnen Elemente bereits
     von Anfang an einen gewissen Sinn ergeben.
     Auch wenn jedes Programm eine ganz bestimmte Aufgabe erfüllt und mit ei-
     nem individuellen »Mix« an Befehlen und anderen »Zutaten« arbeitet, gibt
     es doch einen gemeinsamen Rahmen, den die meisten Programme aufwei-
     sen. Dies ist so ähnlich wie bei Fernsehserien, die zwar pro Folge (meistens)
     eine neue Handlung besitzen, aber stets den gleichen Aufbau aufweisen (da-
     mit sich die Zuschauer schneller zurechtfinden). Sollten Sie als Autor für
     eine solche Fernsehserie eine neue Episode schreiben, müssten Sie sich an
     diesen allgemeinen Rahmen halten, damit der Reihencharakter und Wieder-
     erkennungseffekt nicht verloren geht. Einen solchen Rahmen gibt es auch für
     Visual Basic .NET-Programme, zumindest, wenn es sich um jene Konsolen-
     programme handelt, die Sie in diesem Kapitel kennen lernen.
     Damit es nicht zu spannend wird, zeigt das folgende Listing einen solchen
     Rahmen, der gleich zwei Aufgaben erfüllen soll. Zum einen soll der Ihnen
     jene Programmelemente zeigen, die in jedem Konsolenprogramm vorkom-
     men. Zum anderen können Sie diesen Rahmen für eigene Programme, etwa
     für die kleinen Übungen, um die es am Ende des Kapitels geht, benutzen.

60
Aufbau eines Visual Basic .NET-Programms

' -----------------------------------------------
' Ein allgemeiner Rahmen für Konsolenprogramme
' Visual Basic .NET Easy, Markt+Technik
' -----------------------------------------------
Imports System.Console

Class App

  Shared Sub Main()
   ' Hier Befehle einfügen
   WriteLine("Auftrag ausgeführt!")
  End Sub

End Class
Ein allgemeiner Programmrahmen für Konsolenprogramme in Visual Basic .NET

     Tipp
     Sie finden den Rahmen auf der Begleit-CD im Verzeichnis \Quel-
     len\Kapitel03 in der Datei Rahmen.vb. Verwenden Sie diesen Rahmen
     ruhig, wenn Sie ein neues Konsolenprogramm anfangen möchten. Sie
     müssen dadurch diesen Rahmen nicht mehr neu eingeben, sondern
     tippen die neuen Befehle lediglich in die Prozedur Main ein. Das spart
     nicht nur etwas Zeit, sondern vermeidet auch unnötige Tippfehler.

Kommentare – überflüssig, aber wichtig
Sind die ersten vier Zeilen des obigen Programmlistings auch Befehlszeilen?
(Und gibt es wirklich einen Befehl, der »Visual Basic .NET Easy« heißt?)
Nein, ganz so flexibel ist Visual Basic .NET, was das Formulieren von Befeh-
len angeht, nun noch nicht. Bei diesen Zeilen handelt es sich lediglich um
Kommentarzeilen, die ein Listing enthalten kann, aber nicht enthalten muss.
Kommentarzeilen erlauben dem Programmierer, allgemeine Hinweise in ein
Listing einzubauen, wie zum Beispiel eine kurze Beschreibung oder einen
Copyright-Hinweis. Eine Kommentarzeile wird durch einen Apostroph ein-
geleitet, auf den beliebige Zeichen folgen können. Da es sich nur um Hin-
weise und nicht um Befehle handelt, werden Kommentarzeilen vom
Compiler einfach ignoriert. Lassen Sie also Ihren dichterischen Fähigkeiten
freien Lauf (am Anfang können Sie aber ruhig auf Kommentare verzichten).

                                                                                   61
Hinweis
          Eine Kommentarzeile wird immer mit einem Apostroph (') eingeleitet.
          Alle Zeichen bis zum Zeilenende gehören zum Kommentar.

     Eine Erfolgsmeldung zum Schluss – überflüssig, aber
     motivierend
     Vielleicht ist Ihnen die kleine Ausgabe des Satzes »Auftrag ausgeführt!« in
     der Prozedur Main aufgefallen? Eine solche »Erfolgsmeldung« ist natürlich
     keine Pflicht und soll am Anfang in erster Linie dazu dienen anzuzeigen,
     dass das Programm erfolgreich zu Ende gebracht wurde. Sollte Sie diese
     Meldung stören oder sollten Sie sie schlicht für überflüssig halten, entfernen
     Sie sie wieder aus dem Rahmen oder lassen sie beim Eintippen eines neuen
     Listings einfach weg. Wie Ausgaben in einem Konsolenprogramm über die
     WriteLine-Funktion erfolgen, erfahren Sie weiter unten in diesem Kapitel
     im Abschnitt »Ausgaben in der Konsole«.

     Ein Imports-Befehl vereinfacht die Programmierung
     (ist aber nicht notwendig)
     Viele Visual Basic .NET-Programme beginnen in der Regel mit einem oder
     mehreren Imports-Befehlen, die offenbar irgendetwas importieren. Dieses
     Etwas ist ein so genannter Namespace, der in Kapitel 6 ausführlich erklärt
     wird. Halten Sie sich am Anfang an diesen einfachen Formalismus, der
     ebenfalls nicht zwingend notwendig ist – lassen Sie den Imports-Befehl
     weg, müssen Sie vor einen Klassennamen den kompletten Namespace-
     Namen schreiben. Der Aufruf der WriteLine-Funktion sähe dann wie folgt
     aus:
     System.Console.WriteLine("Auftrag ausgeführt!")
     Mit einem vorausgehenden Imports-Befehl schreiben Sie einfach:
     WriteLine("Auftrag ausgeführt!")
     Sie sehen, dass ohne den Imports-Befehl die Programmierung etwas mehr
     Tipparbeit erfordert, was sich bei großen Programmen durchaus bemerkbar
     macht (denken Sie immer daran, Programmierer sind faul, aber dafür erfin-
     derisch).

62
Aufbau eines Visual Basic .NET-Programms

Die Main-Prozedur legt den Programmstart fest
Ein Befehl kann in einem Visual Basic .NET nicht einfach »irgendwo« ste-
hen. Meistens befindet er sich in einer Prozedur. Eine Prozedur ist ein Name,
der für eine Gruppe von Befehlen steht. Eine Prozedur wird über den Sub-
Befehl von Visual Basic .NET eingeleitet, auf den der Name der Prozedur
folgt, und über den End Sub-Befehl wieder beendet. Wie groß eine Prozedur
wird, spielt keine Rolle, sie kann aus einem oder aus mehreren Dutzend Be-
fehlen bestehen.
Werfen Sie dazu noch einmal einen Blick in das Listing des oben gezeigten
Programmrahmens. Auch dort finden Sie eine Prozedur, die wie folgt defi-
niert wird:
Shared Sub Main()

End Sub
Prozeduren werden in Kapitel 5 ausführlicher erklärt. Im Moment müssen
Sie sich nur merken, dass ein Konsolenprogramm immer eine Prozedur mit
dem Namen Main besitzen muss. Das Befehlswort Shared gibt an, dass die
Prozedur aufgerufen werden kann, ohne dass die Klasse instanziert werden
muss. Mehr dazu ebenfalls in Kapitel 5.

Klassen bilden den Rahmen für ein Programm
Wenn Sie bei Klassen zunächst an Schule, Hausaufgaben, Nachsitzen, Text-
aufgaben und andere mehr oder weniger erfreuliche Themen denken müssen,
sind Sie noch ganz neu bei der Programmierung. Für einen Programmierer ist
eine Klasse lediglich ein Programmelement, mit dem sich ein so genannter
Typ definieren lässt. Ein Typ wiederum steht für einen Satz an Eigenschaften
und Methoden sowie weitere Details. Dies sind aber alles Themen, die erst in
Kapitel 5 an der Reihe sind. Im Moment soll es lediglich darum gehen, dass
jedes Visual Basic .NET-Programm aus mindestens einer Klasse besteht, die
durch den Class-Befehl eingeleitet und den End Class-Befehl wieder been-
det wird.
Werfen Sie auch dazu noch einmal einen Blick in das Programmrahmenlis-
ting. Auch dort finden Sie eine Klasse, die wie folgt definiert wird:
Class App
End Class
Der Class-Befehl definiert eine Klasse mit dem Namen App. Den Namen
können Sie sich frei ausdenken – in diesem Buch heißt die »Hauptklasse« in

                                                                                 63
einem Konsolenprogramm immer App (für Applikation), wenngleich dies na-
     türlich nicht zwingend ist.

     Das »kleinste« Visual Basic .NET-Programm der Welt
     In den letzten Abschnitten war ein paar Mal davon zu lesen, dass ein Pro-
     grammelement im Grunde gar nicht wirklich benötigt wird. Wenn es nicht
     benötigt wird, warum ist es dann dabei? Nun, auf diese mehr philosophische
     Frage gibt es natürlich eine Antwort. Die Kurzform lautet, dass beim Pro-
     grammieren nicht nur Befehle, sondern auch Konventionen eine Rolle spie-
     len. Eine dieser Konventionen besagt, Programme mit einem Kommentar
     beginnen zu lassen, eine andere, den Imports-Befehl zu verwenden. Den-
     noch, es geht auch etwas einfacher.
     Als kleines »Kontrastprogramm« zeigt das folgende Listing das kleinste mög-
     liche Visual Basic .NET-Programm, das lediglich das zum Kompilieren not-
     wendige Gerüst enthält. Damit auch bei diesem Programm etwas passiert,
     wird eine Ausgabe in der Konsole durchgeführt. Diese ist natürlich – sie wer-
     den es sich doch gedacht haben – im Grunde überflüssig.
     Class App

       Shared Sub Main()
            System.Console.WriteLine("Auftrag ausgeführt!")

       End Sub

     End Class
     Das sicher kleinste Visual Basic .NET-Programm der Welt (Minimal.vb)

     Ist dieses Beispiel wirklich das kleinste Visual Basic .NET-Programm der
     Welt? Nun, nicht ganz. Wenn Sie wirklich möchten, geht es noch ein wenig
     einfacher.
     Das nächste Listing zeigt einen Rahmen, der mit dem Module-Befehl arbei-
     tet, der ein »Modul« definiert (dieser Begriff ist in erster Linie für Program-
     mierer gedacht, die bereits ältere Versionen von Visual Basic gut kennen).
     Da dieser Befehl aber lediglich eine Klasse definiert, in der alle Mitglieder
     mit Shared deklariert werden und somit direkt zugänglich ist, wird der Mo-
     dule-Befehl in diesem Buch nicht weiter verwendet (auch wenn es danach
     aussehen mag, dass durch ihn die Programmierung etwas vereinfacht wird).

64
Konsolenprogramme umsetzen

Module App

    Sub Main()
      System.Console.WriteLine("Ich bin am kleinsten!")

    End Sub

End Module
Kleiner geht es nun wirklich nicht mehr.

Konsolenprogramme umsetzen
Bevor es mit den ersten Beispielen losgeht, müssen Sie noch einmal ausführ-
lich erfahren, wie Sie aus einem Listing, etwa jenen, die in diesem Kapitel
vorgestellt werden, ein Visual Basic .NET-Programm machen, das Sie jeder-
zeit ausführen können. Die Vorgehensweise ist dabei stets gleich:

1   Tippen Sie das Listing aus dem Buch mit Notepad oder SharpDevelop (ein Pro-
grammeditor, der am Ende dieses Abschnitts kurz vorgestellt wird) ab oder geben
Sie ein neues Listing ein (zum Beispiel, wenn Sie eine eigene Programmidee aus-
probieren oder eine der Übungsaufgaben am Ende des Kapitels lösen möchten).

2 Speichern Sie das Programmlisting in einer Datei mit der Erweiterung .vb ab.
3 Rufen Sie die Eingabeaufforderung auf und wechseln Sie in das Verzeichnis, in
dem Sie die Listingdatei gespeichert haben.

4 Rufen Sie nun den Visual Basic .NET-Compiler wie folgt auf:
vbc 
Bei  handelt es sich (natürlich) um den Na-
men der Listingdatei, den Sie beim Abspeichern festgelegt haben.
Erwarten Sie vom Visual Basic .NET-Compiler kein großes »Brimborium«.
Wenn Sie alles richtig gemacht haben, sehen Sie lediglich eine kurze Copy-
right-Meldung des Programms. Das Ergebnis ist eine exe-Datei, die Sie durch
Eingabe ihres Namens zur Ausführung bringen.
Ansonsten werden alle Fehler aufgelistet, was am Anfang etwas frustrierend
sein kann. Doch keine Sorge, Programmierfehler sind dazu da, dass sie ge-
macht werden, damit man aus ihnen etwas lernen kann (und der Compiler
ist nicht nachtragend).

                                                                                  65
So voll kann es auf dem Bildschirm werden, wenn der Visual Basic .NET-Compiler Fehler
     gefunden hat.

     Die Arbeitsweise des Compilers beeinflussen
     Normalerweise gibt es keinen Grund, die Arbeitsweise des Compilers zu be-
     einflussen. Wie immer gibt es aber auch hier Ausnahmen. Eine solche liegt
     zum Beispiel dann vor, wenn Sie am Ende auch die Anzahl der Fehler ange-
     zeigt bekommen möchten. In diesem Fall müssen Sie den Compiler vbc.exe
     zusätzlich mit der Option /verbose aufrufen:
     vbc HalloWelt.vb /verbose
     Es gibt noch mehr Compileroptionen, die Sie nach und nach kennen lernen
     werden. Am Anfang benötigen Sie diese noch nicht. Eine Liste sämtlicher
     Optionen erhalten Sie immer dann, wenn Sie vbc ohne weitere Angaben
     oder mit der Option /? aufrufen. Die wichtigsten dieser Optionen sind in der
     folgenden Tabelle zusammengefasst.
      Compileroption                Bedeutung

      /bugreport:        Es wird ein Fehlerreport in der angegebenen Datei
                                    gespeichert, der ein Problem beschreibt, das beim
                                    Kompilieren aufgetreten ist.

      /main:                Legt den Namen der Klasse fest, die die Prozedur
                                    Main enthält, die den Programmstart einer Konsolen-
                                    anwendung definiert.

66
Konsolenprogramme umsetzen

 Compileroption            Bedeutung

 /nologo                   Es wird keine Compilermeldung angezeigt. Das ist
                           nützlich, wenn der Compiler über ein Skript oder eine
                           Stapeldatei aufgerufen wird.

 /out:               Gibt den Namen der Ausgabedatei an, die das »Kom-
                           pilat« enthält. Spielt nur dann eine Rolle, wenn die
                           Ausgabedatei nicht den Namen der Quelltextdatei
                           besitzen soll.

 /r:                 Beim Kompilieren wird die über  angegebene
                           Bibliothek eingebunden. Das ist oft bei Assembly-
                           Bibliotheken notwendig, wie zum Beispiel System.dll.

 /t:library                Erzeugt anstelle einer exe-Datei eine dll-Datei, das
                           heißt eine Programmbibliothek.

 /t:winexe                 Erzeugt eine Windows-Anwendung – hier gibt es
                           keine Konsole, in der Ein- und Ausgaben durchgeführt
                           werden.

 /verbose                  Es werden ausführlichere Meldungen angezeigt.

 @Datei                    Alle Compileranweisungen werden aus der angege-
                           benen Datei eingelesen. Das ist praktisch, wenn der
                           Compiler jedes Mal mit umfangreichen Angaben,
                           etwa langen Bibliotheksnamen, aufgerufen wird, die
                           man nicht immer wieder neu eintippen möchte.

Weitere Bibliotheken (Assemblies) angeben
Wie eben beschrieben, setzen Sie grundsätzlich alle Visual Basic .NET-
Programme um. Dies gilt auch für Windows-Anwendungen, wenngleich Sie
diese sehr viel komfortabler mit Visual Studio .NET entwickeln. In einigen
Fällen (aber nicht in diesem Kapitel) müssen Sie die Namen weiterer Biblio-
theken angeben, die Funktionen enthalten, die von dem zu übersetzenden
Visual Basic .NET-Programm benötigt werden. Eine häufig benötigte Biblio-
thek ist System.dll. Diese Bibliothek wird beim Aufruf von Vbc.exe über die
Option /r: angegeben. Der Aufruf sieht damit wie folgt aus:
vbc beispiel.vb /r:system.dll
Doch woher weiß ich denn, welche Bibliothek(en) benötigt wird/werden?
Das erfahren Sie zum Beispiel aus der Dokumentation. In diesem Buch er-
halten Sie natürlich einen entsprechenden Hinweis, sodass es in diesem

                                                                                   67
Punkt keine Missverständnisse geben kann. Sollte beim Umsetzen eines Lis-
     tings eine Fehlermeldung auftreten, die nicht auftreten sollte, kann es an ei-
     nem fehlenden Bibliotheksverweis liegen. Beim Arbeiten mit Visual Studio
     .NET spielen diese Verweise im Allgemeinen keine Rolle, da sie beim Anle-
     gen eines Projekts automatisch eingefügt werden (über die Projektmappen-
     Explorer erfahren Sie, welche Verweise ein Projekt enthält und können an
     dieser Stelle auch Verweise hinzufügen oder entfernen).

     SharpDevelop als Alternative zu Notepad
     Sie müssen Konsolenprogramme nicht unbedingt mit Notepad eintippen. Sie
     können dazu genauso gut Visual Studio .NET verwenden (das wird in Kapitel
     5 gezeigt). Sollten Sie nicht über Visual Studio .NET verfügen oder es aus ir-
     gendeinem Grund nicht benutzen wollen, gibt es andere Alternativen. Eine
     davon ist der Freeware-Editor SharpDevelop. Er stammt nicht von Microsoft,
     sondern von einem Programmierer mit dem Namen Mike Krueger. Sharp-
     Develop ist ein attraktiver und leistungsfähiger Editor für .NET-Programmie-
     rer. Sie finden ihn auch auf der Begleit-CD im Verzeichnis \SharpDevelop.
     Aktuelle Versionen sowie viele weitere Informationen finden Sie im Internet
     unter http://www.icsharpcode.net/OpenSource/SD/default.asp
     Die Installation besteht aus dem Aufruf der Setup-Datei (zum Beispiel
     088bSetup.exe für die Version 0.88) und ist in Sekundenschnelle erledigt.
     Auch die Bedienung ist sehr einfach. Folgende Möglichkeiten bietet
     SharpDevelop:
     •   Sie können Projekte anlegen, auch ein VB Forms-Projekt, wobei hier die
         IDE aber nur den erforderlichen Code einfügt. Im Unterschied zu Visual
         Studio .NET gibt es (natürlich) keinen Formular-Designer und keine Tool-
         box. Das wäre für einen kleinen Editor deutlich eine Nummer zu groß.
     •   Der Editor bietet eine einfache Syntaxhervorhebung für alle unterstütz-
         ten Sprachen. Das bedeutet, dass wenn Sie einen Visual Basic .NET-
         Befehl eintippen, dieser vom Editor in einer charakteristischen Farbe
         angezeigt wird.
     •   Eine Visual Basic .NET-Datei kann aus der IDE heraus kompiliert und
         gestartet werden.
     •   Es gibt zwar keine Aufgabenliste, in die Compilerfehler eingetragen wer-
         den, aber sie werden im Quelltext unterlegt angezeigt.
     •   Sie können Lesezeichen setzen.

68
Konsolenprogramme umsetzen

•   Es gibt eine Zwischenablage (Clipboard Ring), in der man Textfragmente
    ablegen kann, um sie später wiederzuverwenden.
•   Die Suchfunktion unterstützt reguläre Ausdrücke.
•   Einzelne Tools, wie IL Dasm oder WinCV (der Klassenviewer), lassen
    sich über das EXTRAS-Menü aufrufen.
•   Es gibt einen Messagebox-Wizard, mit dem sich Dialogfelder zusam-
    menstellen lassen.
•   Über die Optionen lässt sich eine Landessprache aus einem Dutzend
    unterschiedlicher Landessprachen einstellen.
•   Es gibt eine Online-Hilfe.

SharpDevelop ist für Visual Basic .NET-Programmierer eine sehr attraktive Alternative zu
Notepad.

      Hinweis
      Ein kleiner Nachteil bei SharpDevelop ist, dass bei Dateien, die
      Umlaute enthalten, diese offenbar nicht in allen Fällen korrekt gela-
      den werden.

                                                                                           69
Variablen als Kurzzeitgedächtnis des
     Computers
     In diesem Abschnitt geht es mit dem Grundkurs richtig los. Mit den Variab-
     len lernen Sie das erste wichtige Element praktisch jeder Programmierspra-
     che kennen. Variablen sind das »Kurzzeitgedächtnis« eines Programms. Sie
     sind dazu da, dass ein Programm sich Zahlen, Zeichenketten, Datumsanga-
     ben, kurz alles das merken kann, was während der Programmausführung an-
     fällt und nicht sofort wieder in Vergessenheit geraten soll. Wann immer sich
     ein Computerprogramm etwas merken soll, verwendet der Programmierer
     dafür eine Variable.

          Was ist das?
          Eine Variable ist ein Name, der für einen beliebigen Wert, das heißt
          eine Zahl, einen Text oder ein Datum, steht.

     Der Umgang mit Variablen ist sehr einfach. Sie müssen lediglich wissen,
     dass Variablen (meistens am Anfang) des Programms »bekannt gemacht«
     werden müssen. Sie können sich sicher schon denken, dass dies nicht der
     offizielle Begriff ist. Programmierer sprechen vielmehr von der Deklaration
     einer Variablen.
     Für diese Variablendeklaration gibt es bei Visual Basic .NET gleich mehrere
     Befehle. In diesem Kapitel lernen Sie den Dim-Befehl kennen. Dieser Befehl
     hat bei Visual Basic eine lange Tradition, sodass sich aus seinem Namen
     nicht direkt auf seine Rolle schließen lässt. Merken Sie sich daher fürs Erste
     nur, dass Variablen zu Beginn des Programms mit Dim deklariert werden
     müssen.

          Hinweis
          Eine Variable muss vor ihrer Benutzung einmalig deklariert werden.
          Diese Aufgabe übernimmt meistens der Dim-Befehl. Andere Befehle
          für die Variablendeklaration sind Private, Public und Friend.

     Der folgende Befehl deklariert eine Variable mit dem Namen Zahl und gibt
     ihr den Anfangswert 123.
     Dim Zahl As Short = 123

70
Variablen als Kurzzeitgedächtnis des Computers

Doch was hat dieses »As Short« zu bedeuten? Dies ist ein sehr wichtiger As-
pekt bei der Deklaration von Variablen, der aber am Anfang vielleicht nicht
ganz einfach zu verstehen ist. Neben einem Namen benötigt eine Variable
immer einen so genannten Datentyp. Dieser legt fest, welcher Typ von Wert
in der Variablen gespeichert werden kann. Short ist ein Name, der für ganz-
zahlige Zahlen im Bereich –32.768 bis +32.767 steht. Größere und kleinere
Zahlen können daher in der Variablen Zahl genauso wenig gespeichert wer-
den wie die Zahl 3,14327689, da dies keine ganze Zahl ist. Auch wenn sich
das nach einer unnötigen Einschränkung anhören mag, ist dies natürlich
nicht der Fall. Dem Programmierer steht es selbstverständlich frei, einen an-
deren, besser passenden Datentyp zu verwenden. Über den Datentyp erfährt
der Visual Basic .NET-Compiler, welche Sorte von Daten in der Variablen
gespeichert werden sollen und kann sich entsprechend darauf einstellen.
Mehr zu den Datentypen in Kapitel 7.

Namensregeln für Variablennamen
Auch wenn Sie für eine Variable im Prinzip einen beliebigen Namen wählen
können, gibt es ein paar Einschränkungen, die Sie kennen müssen:
•   Variablen dürfen keine Leerzeichen enthalten. Auch einige Sonderzei-
    chen, wie %, &, $, @ und #, sind in Variablennamen nicht erlaubt.
•   Variablen dürften (oder besser sollten) nicht die Namen von Befehls-
    und Schlüsselwörtern oder anderen reservierten Namen erhalten. Sollte
    es sich nicht vermeiden lassen, muss der Name in eckige Klammern
    gesetzt werden (das ist aber eine seltene Ausnahme).
•   Für Variablennamen gibt es keine (echte) Längenbegrenzung – Sie sollten
    daher einen Namen so wählen, dass er »sprechend« ist und sich aus dem
    Namen die Bedeutung seines Inhalts erkennen lässt. Nennen Sie eine
    Variable daher ruhig Mwst oder Mehrwertsteuer und nicht nur Mw. Bei
    sehr langen Namen ist es üblich, die einzelnen Namensteile durch einen
    Unterstrich zu trennen (zum Beispiel Koerperschaftsteuer_2002). Auf
    diese Weise wird der Name besser lesbar.
•   Auch wenn Umlaute in einem Variablennamen erlaubt sind, sollten Sie
    sie wenn möglich vermeiden (dies ist aber keine echte Regel, sondern
    eher eine persönliche Empfehlung).

Variablen in Aktion
Sobald der formelle Teil erledigt ist, kann die Variable benutzt werden. Der
folgende Befehl gibt der Variablen Zahl einen Wert:

                                                                                   71
Zahl = 1234
     Das Zuweisen eines Wertes an eine Variable wird Zuweisung genannt (ei-
     gentlich logisch). Wichtig ist dabei, dass der Name der Variablen links vom
     Gleichheitszeichen steht – das Gleichheitszeichen bedeutet nicht, dass die
     linke Seite gleich der rechten Seite ist, sondern muss als »wird zu« gelesen
     werden. Überall, wo der Name Zahl im Programm auftaucht (und die Vari-
     able gültig ist, was nicht uneingeschränkt der Fall sein muss), steht sie für
     den aktuellen Wert. Dieser kann jederzeit wieder geändert werden:
     Zahl = 5678
     Es ist auch möglich, mehrere Variablen auf einmal zu deklarieren:
     Dim Alter, Gewicht, IQ As Short
     Alle drei Variablen erhalten den Datentyp Short (das ist ein wichtiger Un-
     terschied zu früheren Versionen von Visual Basic, in denen die Variablen
     Alter und Gewicht den Datentyp Variant erhalten hätten, den es bei
     Visual Basic .NET nicht mehr gibt).
     Das folgende Beispiel (Variablen.vb) zeigt den generellen Umgang mit Vari-
     ablen. Es wird eine Variable mit dem Namen Zahl definiert, die einen An-
     fangswert erhält, der im weiteren Verlauf des Programms zwei Mal geändert
     wird. Einmal durch eine Zuweisung, ein weiteres Mal, in dem der Wert um
     1 erhöht wird.
     ' -----------------------------------------------
     ' Beispiele für den Umgang mit Variablen
     ' Visual Basic .NET Easy, Markt+Technik
     ' -----------------------------------------------
     Imports System.Console

     Class App

       Shared Sub Main()
           Dim Zahl As Short = 123
           WriteLine("Der Wert von Zahl ist: " & Zahl)
          Zahl = 456
          WriteLine("Der neue Wert von Zahl ist: " & Zahl)
          Zahl +=1
          WriteLine("Der neue Wert von Zahl ist: " & Zahl)
       End Sub

     End Class

     Konstanten als Alternative
     Neben Variablen kennt Visual Basic .NET auch Konstanten. Sie sind das Ge-
     genstück zu Variablen. Wie es der Name bereits andeutet, ist ihr Wert kon-

72
Ausgaben in der Konsole

stant, er kann sich während der Programmausführung nicht ändern.
Konstanten werden über den Const-Befehl definiert.
Der folgende Const-Befehl definiert eine Konstante mit dem Namen Mwst
und dem Datentyp Byte (Wertebereich 0 bis 255 ohne Vorzeichen):
Const Mwst As Byte = 16

Ausgaben in der Konsole
Bevor es mit dem Grundkurs der Visual Basic .NET-Programmierung weiter-
geht, müssen Sie etwas mehr über die Ausgabe von Texten und anderen Din-
gen in der Konsole erfahren. Ein Konsolenprogramm arbeitet (meistens)
nicht mit Fenstern, sämtliche Ausgaben werden in der Konsole (dem Fenster
der Eingabeaufforderung) durchgeführt. Das sieht am Anfang zwar nicht sehr
aufregend aus, ist für die meisten Situationen aber vollkommen ausreichend.
Anders als man es zunächst vielleicht vermuten könnte, gibt es bei Visual
Basic .NET keinen Ausgabebefehl. Doch wie soll man Ausgaben denn an-
sonsten durchführen? Ganz einfach, über eine Klassenfunktion. Klassen-
funktionen sind bei .NET »Befehle«, die immer zu einer Klasse gehören.
Klassen sind bei .NET wiederum »Behälter«, die Funktionen enthalten. Sie
werden über Klassen und Klassenfunktionen noch sehr viel in diesem Buch
lesen, da sie für die Programmierung eine wichtige Rolle spielen. Kapitel 6
geht ausführlicher auf die Rolle dieser .NET-Basisklassen ein. Im Moment ge-
nügt es, wenn Sie sich merken, dass es für die Ausgabe in der Konsole die
WriteLine-Funktion gibt, die zur Klasse Console gehört.
Nun müssen Sie außerdem noch wissen, dass Klassenname und Funktions-
name immer durch einen Punkt getrennt werden. Zudem wird das, was aus-
gegeben werden soll, in Klammern gesetzt (das ist bei Funktionen so üblich).
Möchten Sie daher den Satz »Visual Basic .NET hat Klasse« in der Konsole
ausgeben, lautet der komplette Befehl wie folgt:
Console.WriteLine("Visual Basic .NET hat Klasse")

     Hinweis
     Klassenname und Funktionsname werden bei Visual Basic .NET immer
     durch einen Punkt getrennt.

                                                                                73
Ausgaben mit Platzhalter
     Die WriteLine-Funktion besitzt eine Besonderheit, die Sie kennen müssen,
     da sie bereits für die ersten kleinen Beispiele in diesem Kapitel eine Rolle
     spielt. In den Ausgabetext können Platzhalter eingebaut werden, die bei der
     Ausgabe durch Zahlen oder andere Daten ersetzt werden. Ein Platzhalter ist
     dabei eine Zahl zwischen 0 und 9, die in geschweifte Klammern gesetzt wird
     (zum Beispiel {0}). Doch was soll das bringen? Ganz einfach, auf diese Wei-
     se muss die Zeichenkette nicht geändert werden, wenn sich der auszugeben-
     de Wert einer Zahl ändern sollte.
     Stellen Sie sich vor, Sie möchten einen Kontostand in der Konsole ausgeben
     – der Kontostand ist in einer Variablen mit dem Namen Konto enthalten. Mit
     Platzhalter sieht die Ausgabe wie folgt aus:
     Console.WriteLine("Der aktuelle Kontostand: {0}", Konto)
     Haben Sie den Platzhalter erkannt? Es ist {0}. Bei der Ausgabe ersetzt Visual
     Basic .NET diesen Platzhalter durch den Wert der Variablen Konto. Beträgt
     dieser zum Beispiel 350,28, sieht die Ausgabe wie folgt aus:
     Der aktuelle Kontostand: 350,28
     Eine besondere Erweiterung bei Platzhaltern ist die Möglichkeit, die Ausga-
     be in einer speziellen Art und Weise ausgeben zu können. Dies wird Forma-
     tierung genannt. Bei Währungsbeträgen bietet es sich natürlich an, diese in
     dem speziellen Währungsformat auszugeben, das über die Ländereinstel-
     lungen des Computers festgelegt wird. Dazu muss auf den Platzhalter ein :C
     folgen:
     Console.WriteLine("Der aktuelle Kontostand: {0:C}", _
         Konto)
     Leider sehen Sie aber bei der Konsolenausgabe kein Eurozeichen, da der
     Zeichensatz es nicht darstellen kann.

     Eingaben über die Konsole
     Natürlich muss es auch eine Möglichkeit geben, während der Programmaus-
     führung Eingaben über die Tastatur durchführen zu können. Auf diese Weise
     wird es zum Beispiel möglich, dass ein Programm Werte verarbeitet, die der
     Anwender erst während der Programmausführung eingegeben hat. Für Ein-
     gaben über die Tastatur stellt .NET die Klassenfunktion ReadLine zur Verfü-
     gung. Wie WriteLine gehört auch ReadLine zur .NET-Basisklasse
     Console, was für die Praxis aber keine Bedeutung hat (mehr zur Rolle der
     Basisklassen bei der Visual Basic .NET-Programmierung in Kapitel 6).

74
Eingaben über die Konsole

Trifft das Programm bei der Ausführung auf eine ReadLine-Funktion, hält es
an und wartet auf eine Eingabe durch den Anwender. Die Programmausfüh-
rung wird erst dann fortgesetzt, wenn der Anwender die (¢)-Taste drückt.
Alle eingegebenen Zeichen, die von der ReadLine-Funktion »zurückgege-
ben« werden, werden üblicherweise einer Variablen zugewiesen, die vom
Typ String sein muss (oder besser sollte, ansonsten kann eine Ausnahme
die Folge sein, die zu einem Programmabbruch führt, wenn sie nicht abge-
fangen wird), denn ReadLine gibt immer Zeichenfolgen zurück. Dies gilt
auch dann, wenn eine Zahl oder ein Datum eingegeben wurde.
Wenn Sie ReadLine benutzen möchten, sieht die Befehlszeile wie folgt aus:
Lieblingsfilm = ReadLine()
Da man dem Anwender in der Regel mitteilen möchte, was er an dieser Stel-
le eingeben soll (ansonsten erscheint nur der kleine blinkende Balken, was
nicht sehr aussagekräftig ist), gibt man vorher eine so genannte Eingabeauf-
forderung (auch als Prompt bezeichnet) aus. Dies geschieht wieder mit der
WriteLine-Funktion, die Sie bereits kennen gelernt haben.

ReadLine als »Programmstopper« bei
Visual Studio .NET
Wenn Sie mit Visual Studio .NET arbeiten, dürfte Ihnen schon aufgefallen
sein, dass das Fenster des Konsolenprogramms am Ende einfach wieder ver-
schwindet und Programmausgaben nicht mehr zu sehen sind. Eine Möglich-
keit, dies zu verhindern, besteht darin, am Ende des Programms die
ReadLine-Funktion aufzurufen. Sie bewirkt, dass die Programmausführung
angehalten und erst mit dem Drücken der (¢)-Taste fortgesetzt wird.
Wer es ganz korrekt machen möchte, stellt der ReadLine-Funktion eine
Write-Funktion voran, sodass der Anwender erfährt, warum das Programm
scheinbar hängt:
Write("Weiter mit der Eingabe-Taste")
ReadLine()

Die Read-Funktion für die Eingabe eines einzelnen
Zeichens
Mehr der Vollständigkeit halber soll auch die Read-Funktion vorgestellt wer-
den. Sie nimmt lediglich ein einzelnes Zeichen entgegen, dessen Zeichen-
code zurückgegeben und im Programm abgefragt werden kann. Doch da die
Eingabe immer mit der (¢)-Taste abgeschlossen werden muss, ist sie etwas
unpraktisch und wird daher relativ selten benötigt.

                                                                                75
Das folgende Beispiel (ReadWriteLine.vb) zeigt, wie Eingaben über die
     ReadLine-Funktion und Ausgaben über die Write-Funktion durchgeführt
     werden (im Unterschied zu WriteLine geschieht am Ende kein Zeilen-
     sprung, sodass die Eingabe in der gleichen Zeile wie die Ausgabe erfolgt).
     Wenn Sie das Programm starten, werden Sie aufgefordert, einen Namen ein-
     zugeben. Anschließend gibt das Programm die Anzahl der Zeichen in die-
     sem Namen aus (dazu wird die Length-Eigenschaft der String-Klasse
     benutzt, die Sie in Kapitel 7 kennen lernen werden).
     ' -----------------------------------------------
     ' Ein- und Ausgaben in der Konsole
     ' Visual Basic .NET Easy, Markt+Technik
     ' -----------------------------------------------
     Imports System.Console

     Class App

       Shared Sub Main()
          Dim Name As String
          Write("Bitte Ihren Namen eingeben")
          Name = ReadLine()
          WriteLine("Hallo, {0} - der Name umfasst {1} Zeichen",
     Name, Name.Length)
       End Sub

     End Class

          Wenn Visual Basic .NET WriteLine & Co. nicht kennen will
          Viele Beispiele in diesem Buch verwenden zwar munter WriteLine und
          ReadLine, doch wenn Sie sie so abtippen, wie es im Buch steht, und
          dann kompilieren, gibt es auf einmal eine Fehlermeldung. Der Visual
          Basic .NET-Compiler will die Funktionen offenbar nicht kennen – was ist
          hier los? Der Grund dafür ist, dass der Funktionsname alleine nicht
          genügt und Sie den Imports-Befehl vergessen haben. Zu jeder Funktion
          muss offiziell nicht nur der Klassenname, sondern auch der so genannte
          Namespace angegeben werden. Den Namen der Klasse kennen Sie
          bereits, sie heißt Console, und der Namespace heißt System, sodass der
          komplette Funktionsname System.Console.WriteLine lautet. Da die-
          ses Voranstellen des Namespace- und des Klassennamens bei zwei oder
          drei Funktionen kein Problem ist, bei mehreren Dutzend Funktionen aber
          in Tipparbeit ausartet, gibt es den Imports-Befehl. Er wurde bereits kurz
          zu Beginn dieses Kapitels erwähnt und wird in Kapitel 6 ausführlicher
          erklärt. Bis dahin nehmen Sie den Imports-Befehl einfach als praktische
          Abkürzung hin, die Sie zu Beginn des Programms nicht vergessen sollten.

76
Mit Operatoren lernt ein Programm rechnen

Mit Operatoren lernt ein Programm rechnen
Natürlich muss ein Computer auch rechnen können. Das kann man schließ-
lich erwarten, zumal sich der Name Computer genau aus diesem Umstand
ableitet (engl. to compute = rechnen). Die Rechenbefehle von Visual Basic
.NET lassen sich in zwei Kategorien einteilen: Operatoren und Klassenfunk-
tionen. Die Klassenfunktionen, wie zum Beispiel Sin für die Sinus-Winkel-
funktion oder Sqrt für die Berechnung der Quadratwurzel, lernen Sie in
Kapitel 6 kennen, im Folgenden geht es nur um die Operatoren.
Ein Operator verknüpft zwei Ausdrücke zu einem neuen Wert (der Begriff
Ausdruck wird im nächsten Abschnitt erklärt). Operatoren müssen deswe-
gen nicht ausführlich erklärt werden, weil wir im täglichen Leben praktisch
permanent mit ihnen in Berührung kommen. Zwei Zahlen werden über den
+-Operator addiert und über den --Operator subtrahiert. Nicht alle Opera-
toren entsprechen den Symbolen aus dem Alltag, die Sie auch auf jedem Ta-
schenrechner finden. So lautet der Divisionsoperator wahlweise \ oder /, je
nachdem, ob ein Rest mit Nachkommaanteil oder nur eine ganze Zahl ohne
Nachkommaanteil herauskommen soll, und der Potenzoperator, der Zahl1
hoch Zahl2 ausrechnet, ist das ^-Zeichen.
Alle Operatoren, die Visual Basic .NET kennt, sind in der folgenden Tabelle
in der Reihenfolge ihrer Priorität zusammengestellt. Mit dabei sind auch die
logischen Operatoren, wie And und Or, die weiter unten im Abschnitt »Stun-
de der Entscheidung« erklärt werden, wenn es um das Thema Bedingungen,
und wie sie sich verknüpfen lassen, gehen wird.
 Operator            Bedeutung

 ^                   Potenzierung (zum Beispiel 2 ^3 = 8)

 +, –                Vorzeichen

 *, /, *=, /=        Multiplikation, Division bzw. kombinierte Operation mit
                     einer Zuweisung

 \                   Integer-Division

 Mod                 Rest einer Division

 +, -, +=, -=        Addition, Subtraktion bzw. kombinierte Operation mit einer
                     Zuweisung

 &, &=               Zusammenfügen von Zeichenketten bzw. kombinierte Opera-
                     tion mit einer Zuweisung

                                                                                    77
Operator            Bedeutung

      =, , , =, Like, Is,
      TypeOf…Is

      Not                 Logische Umkehrung

      And, AndAlso        Logische UND-Verknüpfung

      Or, OrElse          Logische ODER-Verknüpfung

      Xor                 Logische XOR-Verknüpfung (Entweder-Oder-Verknüpfung)

     Ausdrücke bestehen aus Operanden und
     Operatoren
     Ein Ausdruck in einem Visual Basic .NET-Programm hat nichts mit seiner
     umgangssprachlichen Bedeutung zu tun. Seine Definition ist vielmehr klar
     und vor allem eng umrissen: Ein Ausdruck ist eine (beliebige) Kombination
     aus Zahlen, Variablen, Funktionen und Operatoren, die nach gültigen Syn-
     taxregeln kombiniert werden und die immer einen einzigen Wert ergeben.
     Selbst eine einfache Zahl stellt einen Ausdruck dar. Ausdrücke sind in einem
     Visual Basic .NET-Programm wie Variablen allgegenwärtig, denn sie kom-
     men praktisch in jedem Befehl vor.
     Der folgende Ausdruck besteht aus zwei Operanden 4 und 5, einer Variab-
     len A und zwei Operatoren:
     4 + 5 * A
     Ausdrücke können auch etwas umfangreicher sein:
     11 + (22 + 33)^2 –(44 –55)^3 –1
     Oder lediglich aus einer einzigen Zahl bestehen:
     -4
     Das Minuszeichen ist auch ein Operator und zwar ein anderer als das Mi-
     nuszeichen im folgenden Ausdruck:
     5-4
     Im ersten Fall stellt das Minuszeichen den »unären« Vorzeichenoperator
     dar, im zweiten Fall den bekannten Subtraktionsoperator. Der folgende Aus-
     druck ist daher nicht korrekt, weil er nicht vollständig ist:
     4 +

78
Mit Operatoren lernt ein Programm rechnen

Auf den Additionsoperator muss ein zweiter Operand folgen.

      Hinweis
      Bei Zahlen, die in ein Programmlisting eingegeben werden, ist das
      Dezimaltrennzeichen ein Punkt (und nicht ein Komma). Wird eine
      Zahl dagegen während der Programmausführung eingegeben, hängt
      das Dezimaltrennzeichen von den Ländereinstellungen ab – in
      Deutschland ist es das Komma.

Es kommt auf die Reihenfolge an
Beim Umgang mit Operatoren müssen Sie zwei grundsätzliche Fakten be-
rücksichtigen:
•   Ein Operator steht immer zwischen den Operanden – eine Ausnahme
    sind jene (wenigen) Operatoren, die nur mit einem Operand arbeiten.
•   Bei den Operatoren gibt es eine so genannte Rangfolge, die Visual Basic
    .NET immer dann berücksichtigt, wenn mehrere Operatoren in einem
    Ausdruck verknüpft werden.
Aus der Schule wissen Sie sicherlich, dass Punkt- immer vor Strichrechnung
geht. Diese Regel gilt auch für Visual Basic .NET. Der Ausdruck 4+3*2 ergibt
daher stets 10. Soll die Reihenfolge verändert werden, muss der Teilaus-
druck mit einem Operator niedriger Priorität in Klammern gesetzt werden.
(4+3)*2 ergibt nun 14.

Kleine Abkürzungen gehören zum
Programmieralltag
Bei einfachen arithmetischen Operationen bietet Visual Basic .NET eine
kleine Abkürzung. Der Befehl
a = a + 3
erhöht den in der Variablen a gespeicherten Wert um 3.
Der folgende Befehl macht das Gleiche, nur etwas kürzer:
a += 3
Das sind die kleinen »Tricks«, die Sie im Laufe der Zeit verinnerlichen
werden.

                                                                                79
Ein kleiner Mehrwertsteuerrechner
     In diesem Abschnitt wird ein kleines Beispielprogramm vorgestellt, mit des-
     sen Hilfe Sie nach Eingabe eines Bruttobetrags den Nettobetrag und die in
     diesem Betrag enthaltene Mehrwertsteuer erhalten. Das Beispiel kombiniert
     die Eingabe über ReadLine mit der Ausgabe über Write und WriteLine.
     Auch das Deklarieren von Variablen und das Durchführen einfacher arith-
     metischer Operationen kommen noch einmal vor.
     ' ===============================================
     ' Kleiner Mwst-Rechner
     ' Visual Basic .NET Easy
     ' ===============================================
     Imports System.Console

     Class App
       Shared Sub Main ()
         Dim Netto, Brutto, Mwst As Single
         Write("Brutto?")
         Brutto = ReadLine()
         Netto = (Brutto / 116) * 10
         Mwst = Brutto – Netto
         WriteLine("Brutto: {0} Netto: {1}             Mwst. {2}", _
            Brutto, Netto, Mwst)
       End Sub
     End Class
     Speichern Sie das Listing in einer Datei beispielsweise mit dem Namen
     Mwst.vb und kompilieren Sie die Datei wie folgt:
     vbc mwst.vb
     Ging alles gut, kommt eine Programmdatei mit dem Namen Mwst.exe her-
     aus. Nach dem Start des Programms werden Sie aufgefordert, einen Brutto-
     betrag einzugeben (denken Sie daran, dass für das Dezimaltrennzeichen ein
     Komma eingegeben werden muss). Anschließend werden Nettobetrag und
     Mehrwertsteuer über die WriteLine-Funktion ausgegeben.

     Vorsicht bei der Eingabe von Zahlen über ReadLine
     Natürlich weiß ein Visual Basic .NET-Programm nichts über die Mehrwert-
     steuer und andere Dinge, auch wenn man dies zunächst vermuten könnte.
     Die ReadLine-Funktion nimmt stur alle Zeichen entgegen, die bis zum Drü-
     cken der (¢)-Taste eingegeben werden. Dagegen ist auch nichts einzuwen-
     den. Problematisch kann es immer dann werden, wenn die Eingabe direkt
     einer Variablen zugewiesen wird, die als Datentyp nicht String besitzt. In
     diesem Fall muss die Eingabe sich in eine Zahl umwandeln lassen, ansons-
     ten meldet die CLR einen Fehler, der bei .NET Ausnahme genannt wird.

80
Wie ein Computerprogramm Entscheidungen trifft

Bezogen auf den Mehrwertsteuerrechner könnten Sie auf die Idee kommen,
bei der Eingabeaufforderung statt 100 »100 Euro« einzugeben. Auch wenn
dies einen Sinn ergeben mag, das Programm kann mit dem Zusatz »Euro«
nichts anfangen. Da sich dieser Ausdruck nicht in eine Zahl umwandeln
lässt, kommt es beim Befehl
Brutto = ReadLine()
zu der erwähnten Ausnahme. Wie sich solche Ausnahmen »abfangen« las-
sen, wird in Kapitel 8 gezeigt. Im Moment (und für die meisten Beispielpro-
gramme, die in diesem Buch vorgestellt werden) sollten Sie versuchen, alles
richtig einzugeben. Sonst erscheint sehr schnell ein Dialogfeld, wie es in der
nächsten Abbildung gezeigt wird. Sie werden damit von der CLR gefragt, ob
Sie das Programm »debuggen« möchten. Antworten Sie auf diese Frage im-
mer durch Anklicken der NEIN-Schaltfläche (es sei denn, Sie möchten das
Programm wirklich debuggen, was in diesem Buch aber nicht erklärt wird).

Upps, da ging etwas schief – ein Programm hat eine Ausnahme verursacht. In diesem
Fall gilt es, die Ausführung abzubrechen und die Ursache für die Ausnahme zu finden.

Stunde der Entscheidung oder wie ein
Computerprogramm Entscheidungen trifft
Dieser Abschnitt hätte auch mit »Der Computer tut so, als ob er denken wür-
de, obwohl er dazu nicht in der Lage ist« überschrieben werden können –

                                                                                       81
diese Überschrift wäre etwas ehrlicher, aber leider auch etwas länger. Com-
     puter können natürlich nicht denken, sie können nicht fühlen und auch
     nicht beleidigt sein (dass Computer, die häufiger von ihren menschlichen
     Besitzern angebrüllt werden, auf einmal sehr langsam werden und sehr selt-
     same Fehler produzieren, ist ein bis heute unbewiesenes Gerücht).
     Allerdings können Computer Entscheidungen treffen und Berechnungen mit
     einer unglaublichen Geschwindigkeit durchführen. Möglich wird dies mit
     den elementaren Befehlen für Entscheidungen und Programmschleifen, die
     Visual Basic .NET, wie praktisch jede andere Programmiersprache auch, zur
     Verfügung stellt. Im Folgenden lernen Sie das Prinzip kennen, nach dem in
     einem Visual Basic .NET-Programm Entscheidungen durchgeführt werden –
     die Programmschleifen sind in Kapitel 4 an der Reihe. Bevor Sie aber die da-
     für zuständigen Befehle If, Else & Co. kennen lernen, müssen Sie erst ein-
     mal verstanden haben, auf welcher Grundlage in einem Computer eine
     Entscheidung getroffen wird.

     Alles ist wahr oder falsch oder so – »denken«
     Computer
     Computer können nicht denken. Das wurde bereits im letzten Abschnitt er-
     wähnt und dürfte vielleicht jene Leser etwas beruhigt haben, die bislang
     noch nicht direkt mit der Programmierung eines Computers konfrontiert
     wurden und daher diesem vielleicht etwas mehr zutrauten als dieser zu leis-
     ten imstande ist. Doch können Computer Entscheidungen treffen?
     Die Antwortet lautet Ja und Nein. Nein, weil es keine selbstständige, eigenver-
     antwortliche und von der jeweiligen Stimmungslage (die es, wie Sie inzwi-
     schen wissen, bei einem Computer gar nicht gibt) abhängige Entscheidung ist.
     Ja, weil Computer in der Lage sind, Zahlen zu vergleichen und eine Befehls-
     folge in Abhängigkeit dieses Vergleichs auszuführen.
     Computer können also Entscheidungen treffen, allerdings auf der Grundlage
     sehr einfacher Ja/Nein-Entscheidungen, deren Ergebnis nur »Ja« (Vergleich
     stimmt) und »Nein« (Vergleich stimmt nicht) sein kann. Ein Programm ver-
     gleicht zwei Zahlen Zahl1 und Zahl2 und prüft eine Bedingung, die etwa
     »Ist Zahl1 größer als Zahl2?« lauten kann. Sie werden im Folgenden lernen,
     dass ein solcher Vergleich immer nur zwei Ergebnisse haben kann: 1. Er ist
     wahr. 2. Er ist nicht wahr.
     Was scheinbar nach einer begrenzten Auswahl aussieht (stellen Sie sich eine
     Eisdiele mit nur zwei Sorten Eis vor), ist in Wirklichkeit ein sehr flexibles
     Konzept. Praktisch alle Computer der Welt arbeiten nach diesem Prinzip

82
Wie ein Computerprogramm Entscheidungen trifft

und steuern damit Raumsonden durch den Weltraum (die hin und wieder
verloren gehen – daran sind mit Sicherheit irgendwelche Außerirdischen
schuld), berechnen Aktienkurse und sagen das Ergebnis einer Bundestags-
wahl auf drei Überhangmandate genau voraus.

Wahr oder falsch? Das ist immer die Frage
Bevor die ersten Beispiele vorgestellt werden, müssen Sie sich in aller Kürze
mit der Logik eines Computerprogramms vertraut machen. Das ist ein wenig
so wie in der Fahrschule, wo den ersten Praxisstunden stets eine kurze Ein-
führung in die »Logik« eines Kraftfahrzeugs vorausgeht (erst den Gang ein-
legen, dann gefühlvoll das Gaspedal treten). Alles ist sehr einfach, höchstens
ein wenig ungewöhnlich.
Die Computerlogik ist wirklich sehr einfach, denn es gibt nur zwei Zustände:
Wahr oder Falsch. Beide Begriffe haben nichts mit der umgangssprachlichen
Bedeutung dieser Wörter zu tun, sie stehen lediglich für die Zustände Ein
und Aus, die jeder Schalter annehmen kann (intern besteht ein Computer aus
vielen Hundert Millionen solcher Schalter, die alle nur diese beiden Zustän-
de annehmen können). Zwischenzustände gibt es nicht. Ein Zustand ist ent-
weder ein oder aus, 1 oder 0, wahr oder falsch. Auf dieser einfachen Logik
basiert die gesamte Programmierung. Da es eine Logik mit nur zwei Zustän-
den ist, wird sie auch als binäre Logik bezeichnet (bi = zwei).
Bei Programmiersprachen werden die Zustände Wahr und Falsch unter-
schiedlich festgelegt. Bei Visual Basic .NET steht der Zustand Falsch für den
Wert 0, er wird durch die Konstante False repräsentiert. Der Zustand Wahr,
hierfür gibt es die Konstante True, steht offiziell für -1, doch inoffiziell ist je-
der Ausdruck, der nicht 0 ist, Wahr.

      Hinweis
      Speziell für die Werte True und False gibt es bei Visual Basic .NET
      den Datentyp Boolean. Eine Variable vom Typ Boolean kann nur die
      Werte True und False annehmen.

Wenn dann und ansonsten nicht – Der If-Befehl
Der wichtigste Befehl für Entscheidungen ist der If-Befehl, der sehr einfach
funktioniert. Auf den If-Befehl folgt ein beliebiger Ausdruck. Ist dieser Aus-
druck gleich 0, wird er vom If-Befehl als False betrachtet und die auf If

                                                                                       83
folgenden Befehle werden nicht ausgeführt. Stattdessen wird der erste Befehl
     ausgeführt, der auf den dazugehörigen End If- oder Else-Befehl folgt.
     Der folgende »Volljährigkeitscheck« (Volljaehrigkeitscheck1.vb) soll fest-
     stellen, ob eine Person volljährig ist oder nicht, indem die Variable Alter
     über einen If-Befehl geprüft wird.
     ' ===============================================
     ' Beispiel für den If-Befehl
     ' Visual Basic .NET Easy, Markt+Technik
     ' ===============================================
     Imports System.Console

     Class App
       Shared Sub Main()
         Dim Alter As Byte
         Write("Bitte Alter eingeben:")
         Alter = ReadLine()
         If (Alter < 18)
          WriteLine("Du bist noch nicht volljährig, sorry!")
         End If
       End Sub
     End Class
     Die WriteLine-Funktion wird nur ausgeführt, wenn die Bedingung Alter
     < 18 erfüllt ist, das heißt, die Variable einen Wert enthält, der kleiner als 18
     ist. Dann ist der gesamte Ausdruck wahr. Ist dies nicht der Fall, das heißt,
     Alter besitzt einen Wert, der gleich oder größer 18 ist, wird der Befehl nicht
     ausgeführt. Visual Basic tut dann so, als gäbe es den Befehl gar nicht.

          Hinweis
          Es ist üblich, aber nicht notwendig, die Bedingung, die auf den If-
          Befehl folgt, in Klammern zu setzen. Ein Then-Befehl, wie bei früheren
          Visual Basic-Versionen, ist bei Visual Basic .NET optional.

     Jede logische Bedingung lässt sich auch umgekehrt formulieren. Das folgen-
     de Beispiel prüft, ob die Variable Alter größer oder gleich 18 ist:
     If (Alter >= 18)
       WriteLine("Sie sind volljährig, Glückwunsch!")
     End If
     In welche »Richtung« eine logische Bedingung formuliert wird, spielt in den
     meisten Fällen keine Rolle, da es zu jeder logischen Bedingung immer ein
     exaktes Pendant gibt. Achten Sie aber auf Kleinigkeiten: Das Gegenstück zu
     kleiner ist nicht größer, sondern größer oder gleich, wofür es in Visual Basic
     .NET mit >= auch einen eigenen Operator gibt.

84
Wie ein Computerprogramm Entscheidungen trifft

     Hinweis
     In Wirklichkeit müsste man bei einem Volljährigkeitscheck natürlich
     auch den Geburtstag und den Geburtsmonat mit einbeziehen. Sie fin-
     den auf der Begleit-CD im Verzeichnis \Quellen\Kapitel03 die Datei
     Volljaehrigkeitscheck3.vb, in der dies umgesetzt wird.

Trickreiche Syntax beim If-Befehl
Die Syntax von Visual Basic .NET umfasst einige Abkürzungen und Spezial-
fälle, die es in anderen Programmiersprachen nicht gibt. Sie bieten dem Pro-
grammierer mehr Freiheit, führen aber auch dazu, dass Visual Basic .NET in
den Bereichen Klarheit und Übersichtlichkeit nicht immer die Bestnoten er-
hält. Ein kleines Beispiel hierfür ist der If-Befehl. Folgt auf den If-Befehl nur
ein einziger Befehl, wird kein End If-Befehl benötigt. Dafür aber ein Then-
Befehl, wobei der auszuführende Befehl in der gleichen Befehlszeile folgen
muss.
Der folgende Befehl führt einen weiteren Volljährigkeitscheck aus, dieses
Mal aber mit einem Then-Befehl und ohne einen abschließenden End If-
Befehl.
If (Alter < 18) Then _
  WriteLine("Du bist noch nicht volljährig, sorry!")
Ist Ihnen der unscheinbare Unterstrich am Ende der ersten Zeile aufgefallen?
Dieser ermöglicht es, dass die Befehlszeile in der nächsten Zeile fortgesetzt
werden kann.

Wenn Tante Else zu Besuch kommt –
Die Alternative zum If-Befehl
Tante Else ist natürlich keine richtige Tante, sondern eine harmlose Wort-
spielerei, die sich auf den Else-Befehl in Visual Basic .NET bezieht. Dieser
Befehl leitet jenen Befehlsteil ein, der immer dann ausgeführt wird, wenn die
Bedingung, die ein If-Befehl prüft, unwahr ist.
Das folgende Beispiel führt einen Befehl aus, wenn die vom If-Befehl ge-
prüfte Bedingung zutrifft. Ist dies nicht der Fall, wird stattdessen der Befehl
ausgeführt, der auf den Else-Befehl folgt.
Dim StartErlaubnis = Boolean
If (Treibstoff > 1000)
  StartErlaubnis = True

                                                                                    85
Else
       StartErlaubnis = False
     End If

          Tipp
          Das letzte Beispiel ist noch in einer anderen Hinsicht bemerkenswert.
          Profiprogrammierer würden so nie programmieren, da es viel zu
          »umständlich« wäre. Überlegen Sie bitte kurz, wie sich die obige
          Befehlsfolge deutlich abkürzen ließe. Die Überlegung basiert auf dem
          Umstand, dass StartErlaubnis vom Typ Boolean ist und einen Wert
          erhält, der nur True oder False sein kann. Doch genau dieser Wert
          wird von der Bedingung Treibstoff > 1000 immer zurückgegeben.
          Die ganze Überprüfung kann damit auf einen einzigen Befehl redu-
          ziert werden:
          StartErlaubnis = Treibstoff > 1000
          Programmieren zu lernen heißt zum einen, die Befehle, Operatoren
          und Syntaxregeln zu lernen, die eine Programmiersprache zur Verfü-
          gung stellt. Es bedeutet aber auch, sich mit der Programmierlogik ver-
          traut zu machen und dabei auch Abkürzungen zu benutzen.

     Das folgende Beispiel (Volljaehrigkeitscheck2.vb) erweitert den Volljährig-
     keitscheck aus diesem Kapitel um einen Alternativzweig, der über den Else-
     Befehl eingeleitet und immer dann ausgeführt wird, wenn die über den If-
     Befehl geprüfte Bedingung nicht zutrifft.
     ' ===============================================
     ' Beispiel für den Else-Befehl
     ' ===============================================
     Imports System.Console

     Class App
       Shared Sub Main()
         Dim Alter As Byte
         Write("Bitte Alter eingeben:")
         Alter = ReadLine()
         If (Alter < 18)
          WriteLine("Du bist noch nicht volljährig, sorry!")
         Else
          WriteLine("Sie sind volljährig, Glückwunsch!")
         End If
       End Sub
     End Class

86
Wie ein Computerprogramm Entscheidungen trifft

     Die Windows-Version der Volljährigkeitsprüfung
     Auch wenn in diesem Kapitel nur Konsolenprogramme vorgestellt
     werden, hat eine Windows-Anwendung natürlich etwas mehr »Pepp«.
     In der Projektdatei Volljaehrigkeit.sln im Verzeichnis \Quellen\
     Kapitel04\Volljaehrigkeit auf der Begleit-CD finden Sie die Windows-
     Version der Volljährigkeitsprüfung. Führen Sie sie aus, indem Sie ent-
     weder die Datei Volljaehrig.exe in diesem Verzeichnis starten oder die
     Projektdatei in Visual Studio .NET über den Menübefehl DATEI/ÖFF-
     NEN/PROJEKT laden. Die Eingabe der Jahreszahl erfolgt über ein Text-
     feld, die Ausgabe über ein Label. An der Logik ändert sich nichts. In
     Kapitel 4 erfahren Sie, wie eine solche Windows-Anwendung pro-
     grammiert wird.

     Die Windows-Version der Volljährigkeitsprüfung

Mehrfachentscheidungen – Der ElseIf-Befehl
Sobald mehrere If- und Else-Befehle unmittelbar aufeinander folgen, gibt
es mit dem ElseIf-Befehl eine praktische und harmlose Abkürzung.
Das folgende Beispiel (ElseIf.vb) erweitert die Volljährigkeitsprüfung um
weitere (allerdings nicht ganz ernst gemeinte) Altersabfragen.
' ===============================================
' Beispiel für den ElseIf-Befehl
' ===============================================
Imports System.Console

Class App
  Shared Sub Main()
    Dim Alter As Byte
    Write("Bitte Alter eingeben:")
    Alter = ReadLine()
    If (Alter < 16)

                                                                                  87
Sie können auch lesen