4 Visual Basic-Grundlagen In diesem Kapitel möchte ich Ihnen erste Grundlagen zu Visual Basic vermitteln. Wer bisher noch nicht mit Visual Basic programmiert hat, erfährt etwas über den grundlegenden Aufbau von Visual Basic .NETProgrammen und kann nachlesen, wie sich Konstanten bzw. Variablen definieren lassen. Umsteiger von VBScript, VBA oder früheren Visual Basic-Versionen sollten sich das Kapitel ebenfalls ansehen, um sich über die Änderungen zu den Vorgängerversionen zu informieren. An dieser Stelle noch ein Tipp an alle Einsteiger: Einige Abschnitte dieses Kapitels sind für Umsteiger bzw. erfahrenere Programmierer vorgesehen. Falls Sie Verständnisprobleme haben sollten, übergehen Sie die betreffenden Abschnitte. Wichtig ist zu Beginn, dass Sie die Grundstruktur eines Programms kennen und wissen, wie eine Konstante oder Variable in einer so genannten Prozedur definiert wird. Alle anderen Feinheiten lernen Sie später, wenn Sie bereits mehr Erfahrung besitzen. Dann können Sie ggf. in diesem Kapitel nachschlagen, um Details nachzulesen.

4.1 Die Grundstruktur eines VB.NETProgramms Bevor Sie mit der Erstellung von Visual Basic-Programmen beginnen, müssen Sie sich über die grundsätzliche Struktur des Quellcodes im Klaren sein. Sie sollten auch wissen, wie Anweisungen zu schreiben sind und wie Kommentare oder Fortsetzungszeilen hinterlegt werden. Diese Fragen werde ich nachfolgend in einer kleinen Übersicht behandeln.

4.1.1

Kommentaranweisungen im Quellcode

Bevor es zu den ersten Visual Basic-Anweisungen geht, möchte ich auf das Kommentieren des Quellcodes zu sprechen kommen. Die Anweisungen in einem Visual Basic-Programm müssen für den Übersetzer (den Visual Basic-Compiler) verständlich und korrekt sein. Eigentlich reicht dies, um die Programmfunktion zu realisieren. Andererseits ist es so, dass ein Entwickler häufig über längere Zeit mit der Pflege des Quellcodes, also der Dateien, die die Visual Basic-Anweisungen enthalten, befasst ist. Je nach Programm kommt es vor, dass mehrere Entwickler über Jahre immer wieder Änderungen einfügen müssen. Dann ist es oft schwierig für die Entwickler, an Hand des Codes herauszufinden, was das Programm tut und was der Programmautor mit dieser oder jener Anweisung wohl bezweckt hat. Für diese Fälle wäre es hilfreich, wenn das Visual Basic-Quellprogramm zusätzliche Hinweise für den menschlichen Leser bereithält, die Erläuterungen zu Anweisungen, zur Funktion des Programms etc. enthalten. Dies ist in folgendem Listing zu erkennen.

105

Die Grundstruktur eines VB.NET-Programms

magnu num m

0

'************************************************ ' File: Modul.vb ' Autor: G. Born www.borncity.de ' Erzeugt ein einfaches Meldungsfeld unter Windows. '************************************************ Module Test Sub Main() ' das ist das Hauptmodul ' Jetzt eine Benutzermeldung ausgeben Microsoft.VisualBasic.MsgBox ("Es hat geklappt!") End Sub End Module Listing 4.1: Modul.vb als Kommentarbeispiel

Aus praktischen Erfahrungen habe ich es mir zur Gewohnheit gemacht, jedes Programm im Quellcode mit einer Art Kommentarkopf zu versehen, aus dem der Dateiname, der Autor sowie eine grobe Funktionsbeschreibung hervorgeht. Stößt man später auf einen Ausdruck dieses Quellcodes, lässt sich sofort nachlesen, wer das Programm erstellt hat und welchen Zweck es erfüllen soll. Sie werden diese Kommentare in allen meinen Beispielen finden. Für eigene Zwecke können Sie dann zusätzliche Informationen wie das Erstellungsdatum, den Revisionsstand, Änderungen oder Fehlerkorrekturen etc. einfügen. Um einen solchen Kommentar, der vom Compiler übersprungen wird, im Quellcode einzufügen, müssen Sie den betreffenden Text durch ein Hochkomma ' einleiten. Der Visual Basic-Compiler erkennt das Hochkomma und überliest den Rest der Zeile. In obigem Listing sind die ersten fünf Zeilen komplett als Kommentare ausgebildet und stellen den von mir verwendeten Kommentarkopf dar. Aber Sie können auch Anweisungszeilen mit Kommentaren versehen. Hierzu fügen Sie den durch ein Hochkomma eingeleiteten Kommentar einfach am Zeilenende ein. Die folgende Anweisung aus obigem Listing nutzt dies: Sub Main()

' das ist das Hauptmodul

Die Anweisung Sub Main() wird durch den Visual Basic-Compiler erkannt und entsprechend umgesetzt. Sobald der Compiler aber das Hochkomma erkennt, ignoriert er den kompletten Rest der betreffenden Zeile und beginnt mit der Bearbeitung der Folgezeile. In obigem Fall teilt der Kommentar dem Leser mit, dass das Hauptmodul beginnt. Die beiden folgenden Zeilen verdeutlichen diesen Ansatz noch einmal. ' Eine komplette Kommentarzeile Brutto = Netto * (100.00 + Mwst)/100.00 ' Brutto ermitteln

In der zweiten Zeile beginnt der Kommentar erst hinter der Anweisung, d.h. die am Zeilenanfang befindliche Anweisung wird noch ausgeführt.

106

Kapitel 4 · Visual Basic-Grundlagen

Aus älteren Visual Basic-Dialekten ist Ihnen vielleicht noch die REMAnweisung bekannt, mit der sich Kommentare einleiten lassen. Das Schlüsselwort REM wird in Visual Basic .NET ebenfalls erkannt. Aus Vereinfachungsgründen verwenden die meisten Entwickler aber das Hochkomma ', um die Kommentare einzuleiten. Laden Sie ein Visual Basic-Quellprogramm in Visual Studio oder in der auf der Begleit-CD enthaltenen Entwicklungsumgebung SharpDevelop, werden die Kommentarteile des Textes standardmäßig in grüner Farbe hervorgehoben. Sie finden die Datei Modul.vb im Ordner \Beisp\Kap04 auf der BegleitCD.

4.1.2

Anweisungen ...

Anweisungen sind in Visual Basic alle Programmstellen, die durch den Compiler erkannt und in ausführbaren Code übersetzt werden. Zudem gehören zu den Anweisungen auch Steuerbefehle, die bestimmte Einstellungen bei der Übersetzung vornehmen. Die folgenden Zeilen enthalten gültige Visual Basic-Anweisungen. Module Test Sub Main() x = 13 + 5

Welche Anweisungen zulässig sind, wird durch die Syntax der Sprache Visual Basic definiert. Die Anweisungen bestimmen quasi, was das Programm tun soll. So kann eine Anweisung zum Beispiel die Vorschrift zur Addition zweier Zahlen enthalten. Anweisungen können auch spezielle Schlüsselwörter aus Visual Basic enthalten. In obigem Code sind beispielsweise Module und Sub Main solche Schlüsselwörter. Je nach Schlüsselwort verlangt Visual Basic, dass die Anweisung mit einer zweiten Anweisung in einer der folgenden Programmzeilen abgeschlossen wird. Dies ist beispielsweise bei der Anweisung Sub der Fall. Dort muss im Quelltext irgendwann eine abschließende Anweisung End Sub auftreten. Präzise Auskünfte zu den zulässigen Anweisungen samt den reservierten Schlüsselwörtern liefert die Visual Basic-Hilfe, die sowohl im .NET Framework SDK als auch in Visual Studio .NET enthalten ist. In den verschiedenen Kapiteln dieses Buches lernen Sie die wichtigsten Anweisungsstrukturen für die Sprache Visual Basic .NET kennen. Bei der Eingabe von Anweisungen wird in Visual Basic keine Unterscheidung zwischen Groß- und Kleinschreibung getroffen. Erkannte Schlüsselwörter (Sub, End Sub, If, Then, Else, End If etc.) werden im Codefenster der Entwicklungsumgebung (Visual Studio .NET oder SharpDevelop) standardmäßig in blauer Farbe hervorgehoben.

107

Die Grundstruktur eines VB.NET-Programms

magnu num m

0

Wie ich bereits ausführte, sind Anweisungen im Codefenster gemäß den für Visual Basic geltenden Syntaxregeln einzugeben. Die nachfolgenden Zeilen enthalten gültige Anweisungen: Wert = 10 Wert = Wert + 10 If Wert > 100 Then Wert = 100 Mwst = 0.1 : Ust = Wert * Mwst

Sie können auch mehrere Anweisungen in einer Zeile aufnehmen, sofern Sie diese durch Doppelpunkte : trennen. Aus Gründen der Übersichtlichkeit und Programmtransparenz sollten Sie jedoch auf diese Möglichkeit verzichten. An dieser Stelle noch ein Hinweis an Leser, die mit früheren Versionen von Basic gearbeitet haben. Standardmäßig benötigt Visual Basic keine Nummerierung der Anweisungszeilen. Kommen in diesem Buch nummerierte Listings vor, wurden die Nummern am Zeilenbeginn von mir aus didaktischen Gründen eingeführt. In VS.NET lassen sich die betreffenden Zeilennummern über den Menübefehl EXTRAS/OPTIONEN, Kategorie TEXT-EDITOR/BASIC, Kontrollkästchen ZEILENNUMMERN ein- oder ausblenden. Die Entwicklungsumgebung SharpDevelop blendet die Zeilennummern im Editor ebenfalls ein, entfernt diese aber beim Speichern. In der DotNET-IDE lässt sich ein Listing mit Zeilennummern über die Schaltfläche VIEW erzeugen.

4.1.3

... und Fortsetzungszeilen

Standardmäßig ist es in Visual Basic so, dass mit einem Zeilenumbruch eine neue Anweisungszeile beginnt. Nun kommt es aber vor, dass Anweisungen relativ umfangreich werden und sich dadurch sehr lange Programmzeilen im Quellcode ergeben. Dadurch leidet die Übersichtlichkeit des Quellprogramms sehr stark. Die folgende Anweisung verdeutlicht dies in etwa: Microsoft.VisualBasic.MsgBox ("Das Ergebnis der ersten Berechnung ergab folgenden Wert: " & x)

Die Anweisung ist zu lang für eine Zeile und wird hier im Buch in zwei Zeilen umbrochen. Das Fenster des Code-Editors in Visual Studio .NET, in SharpDevelop oder selbst bei der Eingabe in Notepad zeigt die Anweisung zwar in einer Zeile an. Spätestens beim Ausdruck des Quellcodes tritt das hier skizzierte Problem des Zeilenumbruchs aber auf. Außerdem müssen Sie bei sehr langen Anweisungszeilen ständig horizontal im Codefenster blättern; kurzum, eine recht aufwändige, fehlerträchtige und umständliche Sache. Umsteiger von Visual Basic oder VBScript kennen es bereits: Es gibt eine Möglichkeit, lange Anweisungen auf mehrere Zeilen aufzuteilen. Sie müssen am Ende einer Zeile jeweils ein Leerzeichen gefolgt von einem Unterstrich _ einfügen.

108

Kapitel 4 · Visual Basic-Grundlagen

Microsoft.VisualBasic.MsgBox _ ("Das Ergebnis der ersten Berechnung ergab folgenden Wert: " _ & x)

Der Unterstrich am Zeilenende signalisiert dem Visual Basic-Compiler, dass die Anweisung in der folgenden Zeile fortgesetzt wird. Dieses Fortsetzungszeichen darf durchaus in mehreren Zeilen auftreten. Lediglich die letzte Zeile der Anwendung enthält kein solches Zeichen. Fortsetzungszeilen dürfen aber hinter dem Zeichen _ keine Kommentare aufweisen! Falls Sie eine über mehrere Zeilen verlaufende Anweisung kommentieren möchten, stellen Sie den Kommentar als eigene Zeile vor den betreffenden Block. Alternativ können Sie den Kommentartext an das Ende der letzten Anweisungszeile, die kein Fortsetzungszeichen mehr enthält, anhängen. Aufpassen müssen Sie auch bei Zeichenketten. Soll ein längerer Text als Zeichenkette mit einem Fortsetzungszeichen versehen werden, ist mit Teilzeichenketten zu arbeiten, die mit dem &-Zeichen verknüpft werden. Das Fortsetzungszeichen muss weiterhin durch mindestens ein Leerzeichen von dem letzten Zeichen der Anweisung getrennt werden. Die nachfolgenden Anweisungen zeigen dies. Microsoft.VisualBasic.MsgBox ("Das Ergebnis der ersten " & _ "Berechnung ergab folgenden Wert: " & x)

Die Zeichenkette wurde hier an der Trennstelle jeweils mit einem doppelten Anführungszeichen abgeschlossen bzw. eingeleitet, die Teilstücke sind durch das &-Zeichen wieder zusammenzufügen.

4.1.4

Der Rahmen für den Quellcode: Modul oder Klasse?

Der Visual Basic-Programmcode muss in VB.NET ganz bestimmten Regeln entsprechen bzw. ist in bestimmten Strukturen zu hinterlegen. Hierzu werden verschiedene Schlüsselwörter verwendet. Nachfolgend finden Sie nochmals das am Kapitelanfang vorgestellte Listing. Ich habe lediglich den Kommentarkopf weggelassen. Module Test Sub Main() ' das ist das Hauptmodul ' Jetzt eine Benutzermeldung ausgeben Microsoft.VisualBasic.MsgBox ("Es hat geklappt!") End Sub End Module

Wer bereits mit früheren Versionen von Visual Basic programmiert, kennt das: Der eigentliche Programmcode für das Hauptprogramm muss in einen bestimmten Rahmen gepackt werden. Da ist einmal die Anweisungsfolge

109

Die Grundstruktur eines VB.NET-Programms

magnu num m

0

Sub Main() .... End Sub

die die eigentlichen Anweisungen einschließt. Zwischen diesen beiden Anweisungen wird der eigentliche Programmcode für das Hauptprogramm gepackt. Jedes Visual Basic-Programm muss einen solchen Main()-Block aufweisen. Dieser Zweig wird beim Start der übersetzten Anwendung aufgerufen und ausgeführt. Aus dem Hauptprogramm können andere Unterprogramme und Funktionen aufgerufen oder Formulare und Fenster geöffnet werden. Als Einsteiger lernen Sie auf den nachfolgenden Seiten, dass das Visual Basic-Schlüsselwort Sub eine Prozedur einleitet. Hier besitzt die Prozedur den Namen Main(), es handelt sich offenbar um das so genannte Hauptprogramm, welches beim Programmstart zuerst ausgeführt wird. Da eine Visual Basic-Quellcodedatei neben dem Hauptprogramm zusätzliche Unterprogramme, Klassen etc. aufweisen kann, muss das Ganze noch mit einem weiteren Schlüsselwort gekapselt werden. In obigem Beispiel habe ich hierzu die Module-Anweisungen Module Test … End Module

verwendet. Ein Modulblock wird immer mit Module name eingeleitet. name steht für einen beliebigen Namen des Moduls, der aber ein gültiger Visual Basic-Bezeichner sein muss. Über diesen Namen lässt sich das Modul später ansprechen. Ein Modulblock muss mit End Module abgeschlossen werden. Zusätzlich lässt sich über die optionalen Schlüsselwörter Public und Friend festlegen, wie sich das Modul innerhalb einer Assembly verhalten soll. Verwenden Sie das Schlüsselwort Public, ist das Modul innerhalb der Assembly für andere Module sichtbar, d.h. es kann auf den Inhalt des Moduls zugegriffen werden. Bei einem Modul innerhalb der Datei spielt dies aber keine weitere Rolle. Mit dem Schlüsselwort Friend setzen Sie den Friend-Zugriff. Damit ist vom Programm, welches die Deklaration enthält, sowie überall in derselben Assembly ein Zugriff möglich. Zudem erlaubt die Module-Deklaration noch optionale Parameter, die hier aber weggelassen werden. Details zu diesen Themen finden sich in der Visual Basic-Hilfe. Die obige Struktur bildet daher so etwas wie einen Grundstock für Ihre Visual Basic-Programme und eigentlich können Sie den Programmrahmen in Form einer Vorlagedatei auf der Festplatte hinterlegen. Bei einer neuen Anwendung verwenden Sie einfach die Vorlage und haben bereits den Programmrahmen vorliegen.

110

Kapitel 4 · Visual Basic-Grundlagen

An dieser Stelle muss ich aber noch auf eine andere Variante zu sprechen kommen. Microsoft hat die Module-Deklaration eigentlich nur noch aus Kompatibilitätsgründen zu Visual Basic beibehalten. Der universellere Ansatz besteht darin, den Code einer Visual Basic-Quelldatei in einer Klasse zu hinterlegen (d.h. das Modul wird durch eine Klasse dargestellt). Sofern Sie ein neues Visual Basic-Projekt in Visual Studio .NET anlegen, erzeugt die zu Grunde liegende Vorlage Klassencode. Das Beispiel aus Listing 4.1 sieht dann folgendermaßen aus: '************************************************ ' File: Class.vb ' Autor: G. Born www.borncity.de ' Erzeugt ein einfaches Meldungsfeld unter Windows. '************************************************ Class Test Shared Sub Main() ' das ist das Hauptmodul ' Jetzt eine Benutzermeldung ausgeben Microsoft.VisualBasic.MsgBox ("Es hat geklappt!") End Sub End Class Listing 4.2: Datei Class.vb mit Klassencode als Rumpf

Sie finden die Datei Class.vb im Ordner \Beisp\Kap04 auf der BegleitCD. Einziger Unterschied zum Module-Beispiel besteht vordergründig darin, dass das betreffende Schlüsselwort durch Class zu ersetzen. Allerdings ist dann dass Schlüsselwort Shared vor der Deklaration der Sub Main()-Prozedur voranzustellen. Das Schlüsselwort Shared bewirkt, dass sich das betreffende Mitglied der Klasse verwenden lässt, ohne dass eine Instanz angelegt werden muss. Lassen Sie dieses Schlüsselwort weg, wird der Visual Basic-Compiler durch eine Fehlermeldung darauf hinweisen, dass keine Main-Methode gefunden wurde, auf die zugegriffen werden kann. Die Frage, ob Sie mit Module oder mit Class arbeiten, müssen Sie selbst beantworten. Wer neu in Visual Basic .NET einsteigt, sollte Class verwenden. Zum Umstellen älterer Visual Basic-Anwendungen wird sich aber der Aufwand nicht lohnen, alle Module-Anweisungen in Class umzusetzen. Verwenden Sie dann die alte Module-Anweisung.

4.1.5

Nutzen der Imports-Anweisung

Eine Änderung gegenüber früheren Visual Basic-Versionen besteht darin, dass Visual Basic .NET-Funktionen und sogar Datentypen aus der .NETKlassenbibliothek importiert. Dies ist unter anderem die Grundlage dafür, dass Codeteile für .NET-Anwendungen teilweise in Visual Basic und teilweise in anderen Sprachen wie C# erstellt werden können. Für Sie als Entwickler hat dies eigentlich keine Nachteile, Sie müssen sich lediglich der Tatsache bewusst sein, dass es die in früheren Versionen

111

Die Grundstruktur eines VB.NET-Programms

magnu num m

0

direkt in Visual Basic verfügbaren Funktionsaufrufe so nicht mehr gibt. Ein Beispiel, welches bereits benutzt wurde, ist die MsgBox-Anweisung. Früher reichte es, den Befehl MsgBox [Parameter] im Programm anzugeben, um ein Dialogfeld anzuzeigen. Visual Basic .NET besitzt dagegen keine MsgBox-Funktion oder Prozedur mehr. Geben Sie das betreffende Schlüsselwort im Quelltext ein, wird der Compiler eine Fehlermeldung erzeugen. Mit anderen Visual Basic-Funktionen (z.B. zur Bearbeitung von Zeichenketten) ist dies ähnlich. Möchten Sie die betreffenden Funktionen bzw. Prozeduren nutzen, müssen Sie diese aus der .NET-Klassenbibliothek importieren. Dann spricht man aber nicht mehr von Funktionen bzw. Prozeduren, sondern verwendet den Begriff Methode. In Kapitel 1 habe ich bereits ausgeführt, dass die .NET-Klassenbibliothek streng hierarchisch aufgebaut ist. Um eine Methode aus der Klassenbibliothek zu verwenden, muss Visual Basic .NET wissen, wo diese Methode hinterlegt ist. Hier kommen die bereits erwähnten Namensräume ins Spiel. Die einzelnen »Bausteine« der .NETKlassenbibliothek sind eindeutig über Namensräume gekennzeichnet bzw. zu unterscheiden. Die Visual Basic-Hilfe charakterisiert dies so: »Die in einer Assembly definierten Objekte werden in Namespaces organisiert.« Das bedeutet, wenn Sie eine bestimmte Methode eines in einer Klassenbibliothek enthaltenen Objekts im Visual Basic-Programm verwenden möchten, müssen Sie den Namensraum dieses Objekts angeben. Alles, was von Microsoft aus früheren Visual Basic-Versionen entfernt und in die .NET-Klassenbibliothek ausgelagert wurde, findet sich im Namensraum Microsoft.VisualBasic. Man bezeichnet Microsoft.VisualBasic auch als Kompatibilitätsklasse, die die früheren Visual Basic-Konstrukte bereitstellt. Bei den obigen Beispielen wurde die MsgBox-Methode benutzt. Um dem Compiler mitzuteilen, wo er die betreffende Klasse findet, lässt sich der komplette Namensraum bei jedem Befehl angeben. Die Anweisung zur Ausgabe des Dialogfelds mit MsgBox lautete dann folgendermaßen: Microsoft.VisualBasic.MsgBox ("Es hat geklappt")

Dieser Ansatz zeigt dem Betrachter sofort, woher die betreffende Methode bzw. Funktion kommt, besitzt aber den gravierenden Nachteil, dass recht viel Tippaufwand erforderlich ist. Wer mit früheren Visual Basic-Versionen gearbeitet hat, weiß, dass der MsgBox-Funktion Argumente (auch als Parameter bezeichnet) in Klammern zu übergeben waren, während beim Aufruf der MsgBox-Prozedur die Argumente ohne Klammern aufgeführt wurden. Dies hat sich nun geändert, in Visual Basic .NET verwenden wir die MsgBox-Methode. Und bei Methodenaufrufen müssen Argumente immer in Klammern übergeben werden. Gerade wenn eine Visual Basic-Funktion bzw. Methode recht häufig verwendet wird, ist der obige Ansatz nicht mehr tragbar. Sie müssten jedes Mal beim Aufruf der betreffenden Methode den kompletten Namens-

112

Kapitel 4 · Visual Basic-Grundlagen

raum mit angeben. Daher gibt es eine Vereinfachung, bei der Sie dem Compiler einmalig den benutzten Namensraum angeben: Sie müssen lediglich im Kopf des Quellprogramms das Schlüsselwort Imports mit der gewünschten Klassenbibliothek aufführen. Das folgende Beispiel demonstriert diesen Ansatz: '************************************************ ' File: Beisp04_01.vb ' Autor: G. Born www.borncity.de ' Erzeugt ein einfaches Meldungsfeld unter Windows. '************************************************ Imports Microsoft.VisualBasic Class Test Shared Sub Main() ' das ist das Hauptmodul ' Jetzt eine Benutzermeldung ausgeben MsgBox ("Es hat geklappt!") End Sub End Class Listing 4.3: Verwendung des Imports-Schlüsselworts in Beisp04_01.vb

Das Schlüsselwort Imports muss vor der Module- oder Class-Definition auftauchen. Fügen Sie einfach für jede im Programm benutzte Klasse aus der .NET-Klassenbibliothek einen entsprechenden Imports-Befehl hinzu. In Kapitel 3 habe ich bereits ausgeführt, dass Sie die Imports-Angaben auch als Argument in der Kommandozeile des Compilers angeben dürfen. Dies setzt aber eine gewisse Buchhaltungdarüber voraus, welche Teile der Klassenbibliothek benutzt werden. Deshalb empfiehlt sich die Verwendung des Schlüsselworts Imports im Quellcode.

4.2 Konstanten in Visual Basic In Visual Basic-Programmen können Sie Konstanten zum Speichern fester Werte verwenden. Der nachfolgende Abschnitt geht auf Fragen rund um das Arbeiten mit Konstanten ein.

4.2.1

Konstanten

In den Visual Basic-Anweisungen können feste Werte auftauchen, die Konstanten darstellen. Die folgende Anweisung verwendet eine solche Konstante: Gewicht = Netto + 100.0

Der Wert 100.0 ist eine (numerische) Konstante, die in die Berechnung eingeht. Sobald Sie eine Zeichenkette direkt im Programmcode angeben, arbeiten Sie ebenfalls mit einer (Zeichenketten-) Konstanten. Die Anweisung Text = "Es hat geklappt"

113

Konstanten in Visual Basic

magnu num m

0

weist der Variablen Text die Zeichenkettenkonstante "Es hat geklappt" zu. Wir sprechen deshalb von Konstanten, weil sich deren Wert – im Gegensatz zu Variablen – während der Ablaufzeit des Programms nicht ändern kann. Wenn Sie den Wert einer Konstanten anpassen möchten, müssen Sie diesen direkt im Quelltext des Programms ändern und das Programm neu übersetzen. Für Einsteiger noch zwei Anmerkungen: Zahlenkonstanten mit Nachkommastellen werden im wahrsten Sinne des Wortes mit einem Dezimalpunkt im Quelltext angegeben. Die deutsche Schreibweise 100,00 wird bei Visual Basic einen Fehler auslösen. Die richtige Schreibweise ist dagegen 100.00. Zeichenkettenkonstanten werden in Visual Basic derart angegeben, dass der Text durch doppelte Anführungszeichen eingerahmt wird (z.B. "Dies ist ein Text"). Häufig besteht jedoch der Wunsch, eine Konstante zentral und mit einem Namen zu vereinbaren, um diese als Bezeichner im Programm nutzen zu können. Nehmen wir einmal eine Konstante, die häufiger in einem Programm auftritt (z.B. das Nettogewicht eines Behälters, der bei der Berechnung des Bruttogewichts auftritt). Geben Sie den Wert der Konstanten direkt in den Berechnungsformeln an und ändert sich etwas, müssen Sie im Quelltext alle Stellen finden, die diesen Wert aufweisen. Das ist eine aufwändige und fehlerträchtige Methode. Wesentlich eleganter wäre es doch, eine benannte Konstante Tara im Programmkopf zu vereinbaren und dieser einen Wert zuzuweisen. Hierzu muss die Konstante im Deklarationsteil des Moduls oder der Klasse explizit definiert werden. Dies kann zum Beispiel so aussehen: Const Tara = 100.00

Die Konstantendeklaration wird mit dem Schlüsselwort Const eingeleitet. Daran schließt sich der Name der Konstante an. Weiterhin wird in der Anweisungszeile der Wert der Konstante gesetzt. Die Konstante lässt sich anschließend unter ihrem Namen im Visual Basic-Programm benutzen. Bruttogewicht = Nettogewicht + Tara

Die benannte Konstante ist in obiger Anweisung sicherlich aussagekräftiger als der Wert 100.00. Zudem erleichtert sich die Programmpflege, wenn die wichtigsten Konstanten direkt im Programmkopf aufgeführt sind.

4.2.2

Wo darf ich die Const-Anweisung einsetzen?

Kommen wir auf die Frage zurück, wo innerhalb einer Programmstruktur eigentlich Const-Anweisungen eingefügt werden dürfen. Die Antwort darauf geht mit der Frage der Gültigkeit einer Konstanten einher. Das folgende Beispiel demonstriert einen typischen Fall zur Verwendung einer Konstanten.

114

Kapitel 4 · Visual Basic-Grundlagen

'************************************************ ' File: Beisp04_02.vb ' Autor: G. Born www.borncity.de ' Erzeugt ein einfaches Meldungsfeld unter Windows. '************************************************ 'Option Explicit Off Imports Microsoft.VisualBasic Class Test Shared Sub Main() ' das ist das Hauptmodul Const Tara = 100.00 ' Konstante auf Sub-Ebene ' Jetzt eine Benutzermeldung ausgeben MsgBox ("Der Wert für Tara ist: " & Tara) End Sub End Class Listing 4.4: Datei Beisp04_02.vb mit Konstante

Die Konstante Tara wird hier im Kopf der Hauptprozedur Main, also nach der Sub-Anweisung eingefügt. Damit ist diese Konstante innerhalb des Main-Blocks verfügbar. In den folgenden Kapiteln werden Sie Beispiele kennen lernen, wo mehrere Sub-Blocks innerhalb einer Klasse oder eines Moduls vorkommen. Benötigen Sie innerhalb mehrerer Sub-Blocks eine Konstante, müsste diese für das komplette Modul oder die Klasse gültig sein. Sie können dies lösen, indem die Konstantendeklaration auf die Ebene des Moduls oder der Klasse verlegt wird. Dies ist in folgendem Listing der Fall. '************************************************ ' File: Beisp04_02a.vb ' Autor: G. Born www.borncity.de ' Erzeugt ein einfaches Meldungsfeld unter Windows. '************************************************ 'Option Explicit Off Imports Microsoft.VisualBasic Class Test Const Tara = 100.00 ' Konstante auf Class-Ebene Shared Sub Main() ' das ist das Hauptmodul ' Jetzt eine Benutzermeldung ausgeben MsgBox ("Der Wert für Tara ist: " & Tara) End Sub End Class Listing 4.5: Datei Beisp04_02a.vb mit globaler Konstante

In diesem Beispiel steht die Konstantendeklaration nach der ClassAnweisung aber vor der Sub-Anweisung. Folglich ist die Konstante innerhalb der gesamten Klasse definiert. Gleiches gilt, falls Sie die ModuleAnweisung verwenden.

115

Konstanten in Visual Basic

magnu num m

0

Diese Ausführungen gelten übrigens auch für die Deklaration von Variablen, die auf den folgenden Seiten behandelt wird. Um Ihnen ein Gefühl dafür zu geben, wo Visual Basic keine Deklarationen erlaubt, schauen Sie sich einmal das folgende Listing an. '************************************************ ' File: Beisp04_02b.vb ' Autor: G. Born www.borncity.de ' Erzeugt ein einfaches Meldungsfeld unter Windows. '************************************************ 'Option Explicit Off Imports Microsoft.VisualBasic Const Fehler = "Falsche Position" ' Hier ist Const unzulässig Class Test Const Tara = 100.00 ' Konstante auf Class-Ebene Shared Sub Main() ' das ist das Hauptmodul Const Tara = 200.00 ' Konstante auf Class-Ebene ' Jetzt eine Benutzermeldung ausgeben MsgBox ("Der Wert für Tara ist: " & Tara) Const Test = "hallo" ' eine weitere Konstante End Sub End Class Listing 4.6: Datei Beisp04_02b.vb mit globaler Konstante

Der Visual Basic-Compiler wird beim Übersetzen die Konstantendeklaration nach dem Imports-Befehl als Fehler auswerfen. Die betreffende Deklaration ist unzulässig und macht auch keinen Sinn. Im Bereich vor einem Modul oder einer Klasse sind nur Imports-Anweisungen gefolgt von Steueranweisungen wie Option Explicit etc. zulässig. Entfernen Sie die Konstantendeklaration für die Konstante Fehler im Quellcode und übersetzen das Beispiel, ergeben sich noch einige Besonderheiten. Einmal erlaubt Visual Basic, dass Sie die Konstantendeklaration überall innerhalb eines Moduls oder einer Klasse vornehmen. Dies lässt sich an der Konstanten Test erkennen, die in diesem Beispiel nach der Anweisung mit der MsgBox-Funktion vereinbart wird. Obwohl dies zulässig ist, empfehle ich aber, alle Konstantendeklarationen in den Kopf eines Moduls, einer Klasse oder einer Prozedur bzw. Funktion zu ziehen. Dies führt zu ordentlich strukturierten Quellcodes, in dem man auf einen Blick alle Konstantendeklarationen im Kopfteil des jeweiligen Abschnitts findet (also dort, wo man sie auch vermutet). In Listing 4.6 ist noch ein weiterer Spezialfall zu erkennen: Die Konstante Tara wird zweimal deklariert. Einmal findet sich eine Deklaration auf Klassenebene und einmal innerhalb der Main-Prozedur. Dies ist ebenfalls zulässig. Kommt es zu einem solchen Fall, gilt immer die Deklara-

116

Kapitel 4 · Visual Basic-Grundlagen

tion im aktuellen Block. In obigem Beispiel bedeutet dies, dass die Konstante Tara den Wert 200.00 besitzt, der vorherige Wert 100.00 wird einfach überschrieben. Führen Sie eine weitere Prozedur in der Klasse ein und verwenden Sie in dieser Prozedur die Konstante Tara, besitzt diese den Wert 100.00. Auf Fragen zur Gültigkeit von Variablen komme ich weiter unten bei der Variablendeklaration nochmals zurück. Sie finden die VB-Beispiele Beisp04_02a.vb bis Beisp04_02c.vb im Ordner \Beisp\Kap04 auf der Begleit-CD. Die Datei Beisp04_02c.vb enthält die fehlerfrei übersetzbare Fassung von Listing 4.6. Zum Übersetzen geben Sie auf der Kommandoebene den Befehl vbc .vb ein.

4.2.3

Spezielle Hinweise zu Konstanten

Wer nun glaubt, alles über Konstanten zu wissen, sollte sich doch einmal die folgenden Ausführungen zu Gemüte führen. Einmal dürfen Sie gleich mehrere Konstanten in einer Zeile definieren: Const MwSt = 0.15, Tara = 100.0

Die einzelnen Konstantendeklarationen sind durch Kommata zu trennen. Weiterhin ist es so, dass Konstanten auch in Visual Basic einen Typ besitzen. Eine numerische Konstante wie 100.00 ist sicherlich etwas anderes als eine Zeichenkettenkonstante wie »Hallo, ein schöner Tag«. Sobald eine Konstantendeklaration in einer Anweisungszeile erkannt wird, weist Visual Basic dieser Konstanten neben dem Wert automatisch den betreffenden Datentyp zu. Wird kein Datentyp angegeben, verwendet Visual Basic .NET automatisch den Datentyp Object. Sie haben aber die Möglichkeit, den Datentyp innerhalb der Konstantendefinition zu vereinbaren. Const Zuschlag As Long = 100.0 Const MwSt As Long = 0.15 Const Limit As Integer = 100.0

Das Schlüsselwort As mit der folgenden Typangabe wird Ihnen bei der Deklaration von Variablen weiter unten noch begegnen. Dort finden Sie auch Hinweise zu den für Variablen und Konstanten zulässigen Datentypen.

4.2.4

Zugriffsberechtigungen auf Konstante

An dieser Stelle möchte ich auch noch auf die Zugriffsberechtigungen zu sprechen kommen. Zugriffsberechtigungen gelten sowohl für Konstanten als auch für Variablen. Über diese Berechtigungen wird festgelegt, wo eine Konstante oder eine Variable sichtbar ist, d.h. ob aus einer Klasse oder einer Prozedur darauf zugegriffen werden kann. Auf den vorhergehenden Seiten wurde bereits in einem Beispiel gezeigt, dass man eine

117

Konstanten in Visual Basic

magnu num m

0

Konstante gleichen Namens auf Modul- bzw. Klassenebene und dann nochmals auf Prozedurebene definieren kann. Eine Konstante gilt standardmäßig immer nur in dem Block, in dem Sie definiert wurde (bzw. in den zugehörigen Unterblocks). Eine auf Klassenebene definierte Konstante oder Variable kann in allen Blöcken dieser Klasse benutzt werden. Außerhalb der Klasse ist sie nicht sichtbar. Eine in einer Prozedur deklarierte Konstante ist nur in der Prozedur sichtbar. Diese Zugriffsberechtigung lässt sich aber über spezielle Schlüsselwörter wie Public, Private, Shared, Friend etc. ändern. Sehen Sie sich einmal das folgende Beispiel an. '************************************************ ' File: Beisp04_03.vb ' Autor: G. Born www.borncity.de ' Erzeugt einige einfaches Meldungsfelder unter Windows. '************************************************ Imports Microsoft.VisualBasic Class Test Class Konstanten Public Const Sprache = "Englisch" Public Const Tara = 100.00 End Class Shared Sub Main() ' das ist das Hauptmodul Const Tara = 200.00 ' Konstante auf Class-Ebene ' Jetzt eine Benutzermeldung ausgeben MsgBox ("Der Wert für Tara ist: " & Tara) MsgBox ("Sprache: " & Konstanten.Sprache & vbCrLf & _ "Tara in Klasse: " & Konstanten.Tara) End Sub End Class Listing 4.7: Beisp04_03.vb mit Klasse für öffentliche Konstanten

Die Klasse Test dient lediglich als Klammer für das Beispiel und enthält eine weitere Unterklasse Konstanten sowie eine Prozedur Main. Beides sind getrennte Blöcke. Möchte man nun aus der Prozedur Main auf die in der Klasse Konstanten definierten Konstanten Sprache und Tara zugreifen, muss der betreffende Namensraum angegeben werden. Daher enthalten die MsgBox-Aufrufe auch Angaben der Art Konstanten.Sprache bzw. Konstanten.Tara. Beim Übersetzen wird der Visual Basic-Compiler aber den Hinweis liefern, dass die beiden Konstanten privat sind, also nicht von außerhalb darauf zugegriffen werden kann. Damit die Konstanten auch in anderen Prozeduren und Klassen sichtbar sind, muss die betreffende Zugriffsberechtigung erteilt werden. In obigem Beispiel wird dies durch das der Const-Anweisung vorangestellte Schlüsselwort Public erreicht. Insgesamt kennt Visual Basic für Konstanten, Variablen, Funktionen, Prozeduren etc. folgende Schlüsselwörter:

118

Kapitel 4 · Visual Basic-Grundlagen

쮿

Private: Private Konstanten, die nur im Kontext des entsprechenden Blocks (z.B. in einer Prozedur, in einer Klasse etc.) sichtbar und zugreifbar sind. Private ist der Standard-Zugriffsmodus, der vom Compiler zugewiesen wird, falls Angaben wie Public etc. fehlen.

쮿

Public: Mit dem Schlüsselwort wird eine öffentliche Konstante (oder Variable etc.) definiert, die auch in anderen Blöcken (z.B. Klassen oder Prozeduren) sichtbar und zugreifbar ist.

쮿

Protected: Diese Konstanten sind geschützt, d.h. es ist nur ein Zugriff in der eigenen Klasse oder aus einer daraus abgeleiteten Klasse möglich. Sie können das Schlüsselwort daher nur für Mitglieder einer Klasse (Klassenmember) verwenden.

쮿

Friend: Mit diesem Schlüsselwort ausgezeichnete Konstanten können sowohl in dem Programm, welches die Deklaration enthält, als auch aus allen anderen Modulen und Klassen derselben Assembly gelesen werden.

쮿

Protected Friend: Stellt eine Kombination der einzelnen Schlüsselwörter dar. Die Konstante kann im Code der Assembly sowie im Code abgeleiteter Klassen verwendet werden. Eine Verwendung dieses Schlüsselworts ist nur für Klassenmembers zulässig.

Zusätzlich gibt es noch das Schlüsselwort Shadows, mit dem eine Konstante aus einer Basisklasse überladen (überschattet) werden kann. Wer bereits mit früheren Versionen von Visual Basic oder mit VBScript programmiert hat, kennt eine Reihe vordefinierter Konstanten (z.B. vbOkOnly etc.). Diese sind in Visual Basic .NET nicht mehr Bestandteil der Sprache. Sie können diese benannten Konstanten aber angeben, wenn Sie die Microsoft-Kompatibilitätsklasse Microsoft.VisualBasic mit dem Imports-Befehl importieren. Ob Sie dies machen oder auf andere Konstanten der Basisklassen zurückgreifen, bleibt Ihnen überlassen. Für die frühere Visual Basic-Konstante vbCrLf, die einen Zeilenumbruch in Meldungsfeldern durchführt, lässt sich z.B. auch die neue newline-Eigenschaft des Objekts, welches die betreffende Ausgabemethode bereitstellt, verwenden. Die Eigenschaft newline ist dabei intern als Zeichenkettenkonstante »\r\n« hinterlegt.

4.3 Regeln für Bezeichner Bezeichner sind die im Programm verwendeten Namen für Konstanten, Variablen, Funktionen, Prozeduren etc. Bezeichner müssen in Visual Basic gewissen Regeln entsprechen. Bezeichner in Visual Basic .NET erfüllen den Standard für Unicode 3.0 (Report 15 und Annex 7), d.h. Sie dürfen die Zeichen dieses Unicode-Zeichensatzes anwenden. Zusätzlich gibt es die Ausnahme, dass ein Bezeichner mit einem Unterstrich _ beginnen darf. Sie können folgende Regeln zur Konstruktion von Bezeichnern verwenden:

119

magnu num m

Regeln für Bezeichner 0

쮿

Bezeichner dürfen maximal 16.383 Zeichen lang sein. Aus Aufwandsgründen sollten Sie aber nie Bezeichner festlegen, die länger als 15 bis 20 Zeichen sind. In Visual Basic wird keine Unterscheidung zwischen Groß-/Kleinschreibung dieser Bezeichner gemacht.

쮿

Ein Bezeichner darf mit einem Unterstrich beginnen, muss dann aber mindestens ein weiteres gültiges Bezeichnerzeichen (Ziffer oder Buchstabe) aufweisen – andernfalls wäre keine Unterscheidung zu einem Fortsetzungszeichen möglich.

쮿

Ein Bezeichner kann aus Zahlen, Buchstaben und Sonderzeichen des oben angegebenen Unicode-Zeichensatzes bestehen. Nicht zulässig ist ein Bezeichner, der nur aus Ziffern besteht (dann ist keine Unterscheidung möglich, ob es sich um eine Zahl oder einen Bezeichner handelt).

쮿

Fehlt der Unterstrich, muss das erste Zeichen eines Bezeichners ein Buchstabe sein (keine Ziffer).

쮿

In einem Bezeichner dürfen keine Leerzeichen vorkommen. Die Verwendung reservierter Visual Basic-Schlüsselwörter wie Sub, Public etc. ist nicht zulässig. Auch die Verwendung von Zeichen, die als Operanden verwendet werden (z.B. +, –, *, /), ist unzulässig.

Die Tabelle 4.1 enthält eine Auflistung aller Visual Basic-Schlüsselwörter, die nicht als Bezeichner nutzbar sind. Ein Bezeichner mit dem Namen Assembly wäre gemäß dieser Tabelle also unzulässig. AddHandler

AddressOf

Alias

And

AndAlso

Ansi

As

Assembly

Auto

Boolean

ByRef

Byte

ByVal

Call

Case

Catch

CBool

CByte

CChar

CDate

CDec

CDbl

Char

CInt

Class

CLng

CObj

Const

CShort

CSng

CStr

CType

Date

Decimal

Declare

Default

Delegate

Dim

DirectCast

Do

Double

Each

Else

ElseIf

End

Enum

Erase

Error

Event

Exit

#ExternalSource

False

Tabelle 4.1: Reservierte Visual Basic .NET-Schlüsselwörter

120

Kapitel 4 · Visual Basic-Grundlagen

Finally

For

Friend

Function

Get

GetType

GoTo

Handles

If

Implements

Imports

In

Inherits

Integer

Interface

Is

Let

Lib

Like

Long

Loop

Me

Mod

Module

MustInherit

MustOverride

MyBase

MyClass

Namespace

New

Next

Not

Nothing

NotInheritable

NotOverridable

Object

On

Option

Optional

Or

OrElse

Overloads

Overridable

Overrides

ParamArray

Preserve

Private

Property

Protected

Public

RaiseEvent

ReadOnly

ReDim

#Region

REM

RemoveHandler

Resume

Return

Select

Set

Shadows

Shared

Short

Single

Static

Step

Stop

String

Structure

Sub

SyncLock

Then

Throw

To

True

Try

TypeOf

Unicode

Until

Variant

When

While

With

WithEvents

WriteOnly

Xor

#Const

#ExternalSource

#If...Then...#Else

#Region

–

&

&=

*

*=

/

/=

\

\=

^

^=

+

+=

=

–= Tabelle 4.1: Reservierte Visual Basic .NET-Schlüsselwörter (Forts.)

121

Datentypen in Visual Basic

magnu num m

0

Auch die Angabe 123 ist als Bezeichner unzulässig, da es sich um eine Zahl handeln kann. Sie können aber einen Bezeichner der Art _1 definieren – wobei sich aber die Frage nach dem Sinn dieses Namens stellt. Die Angabe 1Messung wird von Visual Basic .NET als Bezeichner ebenfalls abgelehnt, da das erste Zeichen kein Buchstabe ist. Als Sonderzeichen können Sie beispielsweise Umlaute einfügen. Die Angabe Müllmenge wäre als Bezeichner zulässig. Wollen Sie den Bezeichner optisch strukturieren, dürfen Sie keine Leerzeichen verwenden. Greifen Sie einfach auf den Unterstrich zu. Die Angabe Einkommen_2002 ist ein zulässiger Bezeichner. Punkte sind dagegen im Bezeichnernamen unzulässig, da ein Punkt zur Trennung von Namen in Objektangaben (z.B. Hierarchie mehrerer Objekte, Objekt.Eigenschaft, Objekt.Methode oder in Namensräumen genutzt wird). Ihre Bezeichner sollten möglichst nicht mehr mit Sonderzeichen wie &, !, $, %, &, # und @ enden. Diese Zeichen wurden in früheren BasicDialekten zur Kennzeichnung des Datentyps verwendet. Man spricht daher auch von Typbezeichnern. Die Angabe Name$ stand beispielsweise für einen Bezeichner vom Datentyp String. Visual Basic .NET unterstützt diese Typbezeichner aus Kompatibilitätsgründen. Dieser Ansatz ist aber veraltet und sollte nicht mehr verwendet werden (oder wissen Sie sofort, welcher Datentyp mit dem Zeichen & definiert wird?). Wählen Sie die Bezeichner so, dass diese Namen eine gewisse Aussagekraft besitzen und selbst dokumentierend sind. Konstantennamen der Art x1, x2 etc. sind kaum aussagekräftig (was hat der Programmierer bloß damit gemeint). Namen wie MwSt, Tara, Offset etc. dürften dagegen im Kontext des jeweiligen Programms einen Sinn ergeben. Die Hilfe zu Visual Basic .NET unterscheidet noch zwischen regulären Bezeichnern und Bezeichnern, die in Escapesequenzen stehen – letztere sind Bezeichner, die zwischen eckigen Klammern stehen. Bei Bezeichnern in Escapesequenzen gelten die gleichen Regeln wie für normale Bezeichner mit den Ausnahmen, dass Schlüsselwörter zulässig sind und Sie keinen Typbezeichner an den Namen anhängen dürfen. Lassen Sie sich durch diese Unterscheidung nicht verwirren, da sich diese mehr oder weniger auf die von Microsoft gelieferte Dokumentation bezieht. Bei den in der Hilfe in eckige Klammern gestellten Bezeichnern handelt es sich meist um Schlüsselwörter.

4.4 Datentypen in Visual Basic Im vorhergehenden Abschnitt haben Sie bereits erfahren, dass Konstanten einen Datentyp besitzen. Der Datentyp legt fest, wie die betreffende Information intern gespeichert wird und welche Verarbeitungsanweisungen auf den Werten zulässig sind. Eine Textkonstante wird sicherlich etwas anders als eine Zahl zu behandeln sein. Neben der impliziten Zuordnung eines Datentyps kann einer Konstanten auch explizit ein

122

Kapitel 4 · Visual Basic-Grundlagen

Datentyp zugewiesen werden. Das gleiche gilt für die im folgenden Abschnitt behandelten Variablen, die in Visual Basic .NET ebenfalls einen Datentyp besitzen.

4.4.1

Hintergrundinformationen zu den Datentypen

Visual Basic .NET kennt eine ganze Sammlung an Datentypen, die Konstanten oder Variablen zugeordnet werden können. Wer aber bereits mit früheren Versionen von Visual Basic gearbeitet hat, muss an dieser Stelle etwas umlernen. Was früher Bestandteil der Sprache Visual Basic war, findet sich nun im .NET Framework. Wie bereits in Kapitel 1 erwähnt, stellt .NET Framework eine Klassenbibliothek bereit. Für .NET Framework hat Microsoft das Common Type System (CTS) definiert, welches für alle .NET-Programmiersprachen einen gemeinsamen Satz an primitiven Datentypen bereitstellt. Dies stellt sicher, dass ein Visual Basic-Programm eine Variable oder Konstante mit einem bestimmten Datentyp definieren und ggf. einem in C# geschriebenen Modul als Argument übergeben kann. C# benutzt die gleichen primitiven Datentypen. Allerdings ist es so, dass in den Programmiersprachen eigene Datentypen von den primitiven Datentypen abgeleitet werden können. Zudem ist es so, dass die Namen für die Datentypen in der Syntax der Programmiersprachen voneinander abweichen (der in C# benutzte Datentyp Int16 wird in Visual Basic als Short bezeichnet). Sofern Sie nur mit Visual Basic .NET programmieren, muss Sie dies aber nicht sonderlich interessieren. Die primitiven Datentypen und die darauf zulässigen Operationen werden letztendlich über die .NET Framework-Klassenbibliothek bereitgestellt. Sie finden die betreffenden Objekte im Namensraum (Namespace) System. Dies hat zur Folge, dass ein Visual Basic-Programmierer Datentypen sowohl über die internen Typen des System-Namensraums wie System.Object als auch über die Visual Basic-Schlüsselwörter für Datentypen wie Object vereinbaren kann. Verwenden Sie die Bezeichner des System-Namensraums, bleiben Sie in der Benennung über alle .NETSprachen einheitlich. Für Programmierer, die bereits mit älteren Visual Basic-Versionen gearbeitet haben, ergibt sich noch eine zusätzliche Änderung. Wurde in diesen Visual Basic-Versionen der Variablen oder Konstanten kein Datentyp zugeordnet, führte dies zu einem Datentyp Variant. Dieser Datentyp kann unterschiedliche Inhalte (Zahlen, Datumswerte, Texte etc.) aufnehmen. Um es gleich vorweg zu nehmen, den Datentyp Variant gibt es in Visual Basic .NET nicht mehr. Da die Datentypen über eine Klassenbibliothek bereitgestellt werden, sind Konstanten und Variablen letztendlich nur Objekte. Wird einer Konstanten oder einer Variablen kein Datentyp zugewiesen, erhält diese in Visual Basic .NET daher automatisch den Typ Object.

123

magnu num m

Datentypen in Visual Basic 0

4.4.2

Welche primitiven Datentypen gibt es im CTS?

Das Common Type System stellt neben dem Typ Object nur die wichtigsten primitiven Datentypen bereit, mit denen sich Zahlen, Zeichen und logische Werte abbilden lassen. Die nachfolgende Tabelle enthält eine Übersicht über die betreffenden Datentypen des Common Type Systems. In der Spalte Beschreibung habe ich die betreffenden von Visual Basic .NET benutzten Aliasnamen für die Datentypen mit aufgenommen. CTS-Datentyp/ Klassenname

Beschreibung

System.Byte

Eine 8-Bit-Ganzzahl ohne Vorzeichen. Visual Basic .NET verwendet den Aliasnamen Byte für diesen Datentyp.

System.Int16

Eine 16-Bit-Ganzzahl mit Vorzeichen. Dies entspricht dem Visual Basic .NET-Datentyp Short.

System.Int32

Eine 32-Bit-Ganzzahl mit Vorzeichen. Dies entspricht dem Visual Basic .NET-Datentyp Integer.

System.Int64

Eine 64-Bit-Ganzzahl mit Vorzeichen. Dies entspricht dem Visual Basic .NET-Datentyp Long.

System.Single

Eine Gleitkommazahl einfacher Genauigkeit (32 Bit). Dies entspricht dem Visual Basic .NET-Datentyp Single.

System.Double

Eine Gleitkommazahl doppelter Genauigkeit (64 Bit). Dies entspricht dem Visual Basic .NET-Datentyp Double.

System.Boolean

Ein boolescher Wert (true oder false) der 16 Bit belegt. Dies entspricht dem Visual Basic .NET-Datentyp Boolean.

System.Char

Ein Unicode-Zeichen (16 Bit). Dies entspricht dem Visual Basic .NET-Datentyp Char.

System.Decimal

Ein 96-Bit-Dezimalwert, der für finanzmathematische Berechnungen geeignet ist, die eine signifikante Zahl an Vor- und Nachkommastellen benötigen. Der Datentyp entspricht dem Visual Basic .NET-Datentyp Decimal. Intern werden die Daten auf 128 Bit abgebildet, wobei die binäre Darstellung einer Instanz von Decimal ein Bit für das Vorzeichen, 96 Bit für eine Ganzzahl und einen Skalierungsfaktor in den restlichen Bits umfasst. Der Skalierungsfaktor ist implizit 10 mit einem Exponenten zwischen 0 und 28.

Tabelle 4.2: Datentypen des Common Type Systems (CTS) in Visual Basic

124

Kapitel 4 · Visual Basic-Grundlagen

CTS-Datentyp/ Klassenname

Beschreibung

System.Object

Dieser universelle Datentyp stellt den Stamm der Objekthierarchie dar und wird für alle Variablen und Konstanten ohne Typbezeichner benutzt. In Visual Basic .NET wird der Aliasname Object für den Datentyp verwendet.

System.String

Eine unveränderliche Zeichenfolge fester Länge mit Unicode-Zeichen. Dies entspricht dem Visual Basic .NETDatentyp String.

Tabelle 4.2: Datentypen des Common Type Systems (CTS) in Visual Basic (Forts.)

Beachten Sie beim Datentyp Object, dass Visual Basic der Konstanten oder Variablen bei der Zuweisung eines Werts den internen Datentyp am Wert anpasst. Eine Variable vom Typ Object erhält z.B. bei der Zuweisung einer Zeichenkette den Typ String.

4.4.3

Welche Datentypen kennt Visual Basic .NET?

Die über die .NET-Klassenbibliothek im Namensraum System bereitgestellten primitiven Datentypen des Common Type Systems werden von allen .NET-Programmiersprachen unterstützt. Visual Basic .NET kennt aber weitere Datentypen. Die folgende Tabelle listet alle in Visual Basic .NET unterstützten Datentypen auf. In der Spalte CTS-Datentyp finden Sie die entsprechenden Pendants des CTS-Datentyps. Enthält die betreffende Zeile keinen Eintrag, ist der Visual Basic .NET-Datentyp nicht von CTS abgeleitet und daher auch nicht mit CTS kompatibel. CTSDatentyp

VB.NET- KateDaten- gorie typ

Wertebereich

Beschreibung

Byte

Byte

0 bis 255

Eine 8-Bit-Ganzzahl ohne Vorzeichen

SByte

–128 bis 127

Eine 8-Bit-Ganzzahl mit Vorzeichen. Dieser Visual Basic .NETDatentyp ist nicht CTSkompatibel.

Short

–32.768 bis

Eine 16-Bit-Ganzzahl mit Vorzeichen

Int16

Ganze Zahl

32.767 Tabelle 4.3: Visual Basic .NET-Datentypen

125

magnu num m

Datentypen in Visual Basic 0

CTSDatentyp

VB.NET- KateDaten- gorie typ

Wertebereich

Beschreibung

Int32

Integer

–2.147.483.648 bis

Eine 32-Bit-Ganzzahl mit Vorzeichen

2.147.483.647 Int64

Long

Eine 64-Bit-Ganzzahl mit – 9.223.372.036.854. Vorzeichen 775.808 bis 9.223.372.036.854. 775.807

UInt16

0 bis 65.535

UInt32

0 bis 4.294.967.295 Eine 32-Bit-Ganzzahl ohne Vorzeichen. Dieser Visual Basic .NETDatentyp ist nicht CTSkompatibel.

UInt64

0 bis 184.467.440.737.09 5.551.615

Single

Single

Double

Double

Boolean

Boolean

Eine 64-Bit-Ganzzahl ohne Vorzeichen. Dieser Visual Basic .NETDatentyp ist nicht CTSkompatibel.

–3,402823E+38 bis Gleitkomma –1,401298E–45 für negative und 1,401298E–45 bis 3,4028235E+38 für positive Werte

Eine Gleitkommazahl einfacher Genauigkeit (32 Bit) mit bis zu 7 Nachkommastellen

–1,7976931348623 1570E+308 bis – 4,94065645841246 544E–324 für negative und 4,94065645841246 544E–324 bis 1,79769313486231 570E+308 für positive Werte

Eine Gleitkommazahl doppelter Genauigkeit (64 Bit) mit bis zu 16 Nachkommastellen

Logisch –1 (True) oder 0 (False)

Tabelle 4.3: Visual Basic .NET-Datentypen (Forts.)

126

Eine 16-Bit-Ganzzahl ohne Vorzeichen. Dieser Visual Basic .NETDatentyp ist nicht CTSkompatibel.

Ein boolescher Wert (True oder False)

Kapitel 4 · Visual Basic-Grundlagen

CTSDatentyp

VB.NET- KateDaten- gorie typ

Wertebereich

Beschreibung

Char

Char

1 Unicode-Zeichen

Ein Unicode-Zeichen (16 Bit)

Decimal

Decimal

+/–1E–28 bis

Ein 96-Bit-Dezimalwert mit zu 28 Nachkommastellen. Der genaue darstellbare Zahlenbereich ist der VB.NET-Hilfe zu entnehmen.

Sonstige

+/– 79.228.162.514.264 .337.593.543.950.3 35 IntPtr

–

Eine ganze Zahl mit Vorzeichen, deren Größe von der zu Grunde liegenden Plattform abhängt (32Bit-Wert auf einer 32-BitPlattform und 64-BitWert auf einer 64-BitPlattform). Dieser Visual Basic .NET-Datentyp ist nicht CTS-kompatibel.

UIntPtr

–

Eine ganze Zahl, deren Größe von der zu Grunde liegenden Plattform abhängt (32-BitWert auf einer 32-BitPlattform und 64-BitWert auf einer 64-BitPlattform). Dieser Visual Basic .NET-Datentyp ist nicht CTS-kompatibel.

Object

Object

String

String

Klassen – objekte 0 bis ca. 2 Milliarden Unicode-Zeichen

Der Stamm der Objekthierarchie Eine unveränderliche Zeichenfolge fester Länge mit UnicodeZeichen

Tabelle 4.3: Visual Basic .NET-Datentypen (Forts.)

Auch die nicht zu CTS kompatiblen Visual Basic .NET-Datentypen werden durch .NET Framework bereitgestellt und lassen sich über den Namensraum System ansprechen.

127

Datentypen in Visual Basic

magnu num m

0

4.4.4

Zwei Beispiele zum Umgang mit Datentypen

An dieser Stelle möchte ich Ihnen an zwei Beispielen demonstrieren, wie sich Datentypen zuweisen lassen und wie Sie den Datentyp einer Konstanten bzw. Variablen abfragen können. Nebenbei lernen Sie noch den Umgang mit Ausgabemeldungen auf Konsolenebene kennen und erfahren, wie sich Datentypen ggf. konvertieren lassen.

Bild 4.1: Ausgaben im Fenster der Eingabeaufforderung

Im ersten Beispiel werden einige Konstanten definiert. Hierbei weise ich diesen zum Teil Datentypen aus dem Common Type System zu. Anschließend sollen die Werte der Konstanten im Fenster der Eingabeaufforderung angezeigt werden. Zusätzlich gibt das Programm noch den Datentyp der jeweiligen Konstanten aus (Abbildung 4.1). Die Visual Basic .NET-Anweisungen sind folgendem Listing zu entnehmen. '************************************************ ' File: Beisp04_04.vb ' Autor: G. Born www.borncity.de ' Definiert verschiedene Konstanten und weist diesen ' CTS-Datentypen zu. Listet die Werte und deren Typen ' in der Console auf. '************************************************ Imports System ' für Datentypen Imports System.Console ' Für WriteLine Class Test Shared Sub Main() ' das ist das Hauptmodul Const Test0 = "Ein Text" Const Test1 As System.Int32 = 100 Const Test2 As Int32 = 200 Const Test3 As Integer = 750 Const Test4 As Double = 50.01 ' Jetzt eine Benutzermeldung ausgeben Write("Der Wert für Test0 ist: " & Test0 ) WriteLine(" - und der Typ ist: " & Test0.GetType.toString) Write("Der Wert für Test1 ist: " & Test1 )

128

Kapitel 4 · Visual Basic-Grundlagen

WriteLine(" - und der Typ Write("Der Wert für Test2 WriteLine(" - und der Typ Write("Der Wert für Test3 WriteLine(" - und der Typ Write("Der Wert für Test4 WriteLine(" - und der Typ

ist: ist: ist: ist: ist: ist: ist:

" " " " " " "

& & & & & & &

Test1.GetType.toString) Test2 ) Test2.GetType.toString) Test3 ) Test3.GetType.toString) Test4 ) Test4.GetType.toString)

Write ("Bitte die Eingabetaste drücken") ReadLine ' verhindert das Schließen des Konsolefensters End Sub End Class Listing 4.8: Beisp04_04.vb zur Anzeige von Konstantenwerten

Schauen wir uns doch einmal die einzelnen Anweisungen des Beispiels etwas detaillierter an. Mit Const Test0 = "Ein Text"

wird eine Konstante Test0 vereinbart, der ein Text zugewiesen wird. Da wir keinen Datentyp spezifizieren, verwendet der Visual Basic-Compiler automatisch einen passenden Datentyp (hier wird wegen des Texts der Typ String benutzt). Die folgende Anweisung zeigt beispielhaft, wie ein Datentyp aus der Common Language Specification der Konstanten Test1 zugewiesen wird. Const Test1 As System.Int32 = 100

Diese Konstruktion ist bereits aus den Beispielen der vorherigen Seiten bekannt, es wurde lediglich an Stelle des Visual Basic .NET-Alias Integer der Namespace System.Int32 benutzt. Da in der Anweisung der Namensraum System angegeben wird, braucht es im Quellcode auch keine Imports-Anweisung. Anders sieht es bei der nachfolgenden Anweisung aus: Const Test2 As Int32 = 200

Der Datentyp Int32 ist Bestandteil des Namensraums System, d.h. der Compiler löst einen Übersetzungsfehler aus, falls keine Imports SystemDirektive gefunden wird. In den restlichen Deklarationen habe ich die in Visual Basic .NET für Datentypen zulässigen Aliase Integer und Double benutzt. Bleibt noch die Frage, wie das Programm dem Anwender Informationen über die Konstanten und deren Datentypen liefern kann. Denkbar wäre die Verwendung der MsgBox-Methode aus Visual Basic (die in den vorhergehenden Beispielen zum Einsatz kam). An dieser Stelle möchte ich aber eine Neuerung benutzen. .NET Framework unterstützt die Ausgabe auf Konsolenebene über die Methoden Write und WriteLine des System.Console-Objekts. Daher wird im Programmkopf der Namensraum System.Console über eine Imports-Anweisung vereinbart. Anschließend lassen sich die Methoden in der Form

129

Datentypen in Visual Basic

magnu num m

0

Write("Der Wert für Test0 ist: " & Test0) WriteLine(" - und der Typ ist: " & Test0.GetType.toString)

aufrufen. Write erzeugt eine einfache Textausgabe, während WriteLine nach der Textausgabe einen Zeilenvorschub auslöst. Der Ausgabetext ist der Methode als in Klammern gesetztes Textargument zu übergeben. Der Wert der betreffenden Konstante wird daher mit dem &-Operator mit der ebenfalls in Klammern stehenden Zeichenkettenkonstante verkettet (der Fachausdruck ist Konkatenation). Durch den &-Operator führt der Visual Basic-Compiler bei der Textausgabe automatisch eine Typumwandlung von Zahlenwerten durch – wie Sie dies durch die Option Strict-Direktive verhindern können, wird im nächsten Abschnitt gezeigt. Die Ausgabe mittels der WriteLine-Methode soll dem Benutzer den Typ des Ausgabewerts anzeigen. Dadurch erhalten wir eine Rückmeldung, was Visual Basic .NET aus den einzelnen Anweisungen gemacht hat. Den Datentyp einer Konstanten oder Variablen können Sie mit der GetTypeMethode ermitteln. Diese ist im Format Object.GetType anzugeben, wobei Object für den Namen der Konstanten (oder Variablen) steht. Verknüpfen Sie den Rückgabewert der Methode über & mit einer Zeichenkettenkonstante, meldet der Compiler, dass dies für den StringDatentyp nicht unterstützt wird. Sie müssen daher das Ergebnis des Methodenaufrufs explizit in eine Zeichenkette umwandeln. Daher kommt die toString-Methode zum Einsatz. Die Anweisung: Test0.GetType.toString

ermittelt durch Anwendung der GetType-Methode auf die Konstante Test0 (die ein Objekt darstellt) den aktuellen Datentyp. Dieses Ergebnis wird dann mittels der toString-Methode in eine Zeichenkette umgewandelt. Wenn Sie sich die Ausgaben des Beispiels ansehen, stellen Sie fest, dass Visual Basic trotz Verwendung der Aliase wie Double intern mit den Datentypen aus dem Namensraum System arbeitet. Die obige Anweisung zeigt sehr schön die Punktsyntax, die auf Objekte und Namensräume angewandt wird. Test0 ist zwar der Name einer Konstanten. Da Datentypen aber über die .NET Framework-Klassenbibliothek bereitgestellt werden, ist Test0 gleichzeitig ein Objekt. Und das Objekt stellt die benutzten Methoden bereit. Die Methodennamen werden jeweils durch einen Punkt vom Objektnamen getrennt. Die letzte WriteLine-Anweisung in Kombination mit ReadLine hat übrigens die Aufgabe, das Schließen des Konsolenfensters zu verhindern (falls das Programm aus Windows per Doppelklick aufgerufen wird). Erst wenn der Benutzer die (Enter)-Taste drückt, schließt sich das Konsolenfenster. Diese Technik kommt bei allen Beispielen zum Einsatz, die im Fenster der Eingabeaufforderung ablaufen. Im Vorgriff auf den kommenden Abschnitt demonstriert das zweite Beispiel die Zuweisung von Datentypen bei Variablen. Eine Variable deklariert sich über das Schlüsselwort Dim, wir brauchen also im Grunde nur die Const-Anweisung durch das Schlüsselwort Dim auszutauschen. Das

130

Kapitel 4 · Visual Basic-Grundlagen

folgende Listing zeigt, wie im Programm mehrere Variablen definiert, mit Wertenversehen und dann auf der Ebene der Eingabeaufforderung angezeigt werden. '************************************************ ' File: Beisp04_04a.vb ' Autor: G. Born www.borncity.de ' Definiert verschiedene Variablen und weist diesen ' CTS-Datentypen zu. Listet die Werte und deren Typen ' in der Console auf. '************************************************ Imports System ' Für die Datentypen Imports System.Console ' Für WriteLine Class Test Shared Sub Main() ' das ist das Hauptmodul Dim Test0 = "Ein Text" Dim Test1 As System.Int32 = 100 Dim Test2 As Int32 = 200 Dim Test3 As System.Double = 50.01 Dim Test4 As Object Test4 = "Noch ein Text"

' Zuweisen des Werts

' Jetzt eine Benutzermeldung ausgeben Write("Der Wert für Test0 ist: " & Test0.toString ) WriteLine(" - und der Typ ist: " & Test0.GetType.toString) Write("Der Wert für Test1 ist: " & Test1 ) WriteLine(" - und der Typ ist: " & Test1.GetType.toString) Write("Der Wert für Test2 ist: " & Test2 ) WriteLine(" - und der Typ ist: " & Test2.GetType.toString) Write("Der Wert für Test3 ist: " & Test3 ) WriteLine(" - und der Typ ist: " & Test3.GetType.toString) Write("Der Wert für Test4 ist: " & Test4.toString ) WriteLine(" - und der Typ ist: " & Test4.GetType.toString) Write ("Bitte die Eingabetaste drücken") ReadLine ' verhindert das Schließen des Konsolefensters End Sub End Class Listing 4.9: Anzeige von Variablenwerten in Beisp04_04a.vb

Falls Sie einer Variablen keinen Datentyp zuweisen, benutzt Visual Basic .NET den Datentyp Object. Dieser Datentyp kann verschiedene Werte verwenden. Zusätzlich habe ich die Variable Test4 explizit mit dem Datentyp Object belegt. Bei der Ausgabe der Werte der einzelnen Variablen mittels der Methoden Write und WriteLine ist beim Datentyp Object eine explizite Konvertierung in eine Zeichenkette erforderlich. Aus diesem Grund werden die Variablenwerte Test0 und Test4 mit der toStringMethode vor der Ausgabe in eine Zeichenkette konvertiert.

131

Arbeiten mit Variablen

magnu num m

0

Sie finden die beiden Dateien Beisp04_04.vb und Beisp04_04a.vb im Ordner \Beisp\Kap04 der Begleit-CD. Übersetzen Sie die Dateien im Fenster der Eingabeaufforderung mit der Anweisung vbc (also kein Schalter /t:winexe). Anschließend sollte sich bei der Ausführung die in Abbildung 4.1 gezeigte Ausgabe im Fenster der Eingabeaufforderung ergeben.

4.5 Arbeiten mit Variablen Variablen sind benannte Platzhalter, die im Programm in einzelnen Anweisungen auftreten können. Dabei kann der Wert der Variablen (im Gegensatz zur Konstanten) im Programm verändert werden. Bezüglich der Bildung der Variablennamen gelten die bereits weiter oben im Abschnitt »Regeln für Bezeichner« besprochenen Regeln. Variablen lassen sich in Visual Basic .NET durch das Schlüsselwort Dim deklarieren. Zudem kann der Variablen bei der Deklaration ein Datentyp zugewiesen werden. Die folgenden Anweisungen vereinbaren einige Variablen. Dim Dim Dim Dim Dim

Alter Monat, Tag, Jahr Limit As Long Grenze As System.Int32 Std, Min, Sek As Integer

Die ersten beiden Zeilen vereinbaren die Variable ohne die Angabe eines Datentyps. Visual Basic .NET weist dann implizit den Datentyp Object zu. Dieser Datentyp ist in der Lage, Werte unterschiedlicher Typen (Datum, Zahlen, Texte, Objektreferenzen) aufzunehmen. In der dritten Zeile wird ein Visual Basic .NET-Alias Long als Datentyp benutzt, die vierte Zeile greift dagegen auf die im Common Type System vereinbarten Datentypen zu und vereinbart einen 4-Byte-Integerwert. Sie können für jede Variable eine eigene Dim-Anweisung verwenden. Alternativ lassen sich, wie in der letzten Anweisungszeile gezeigt, mehrere Variablen in einer Anweisungszeile vereinbaren. Dann sind die Variablennamen durch Kommata zu trennen. Möchten Sie der Variablen einen Datentyp zuweisen, hängen Sie den Datentyp über eine As-Anweisung an. Leser, die bereits mit früheren Versionen von Visual Basic programmiert haben, seien auf eine Neuerung hingewiesen. Die Deklaration in der letzten Zeile der obigen Codesequenz vereinbart drei Variablen mit den Namen Std, Min und Sek. In früheren VB-Versionen hätte die Variable Sek den Datentyp Integer erhalten, während den Variablen Std und Min implizit der Datentyp Variant zugeordnet worden wäre. In Visual Basic .NET erhalten alle Variablen den Datentyp zugewiesen, der am Zeilenende hinter As angegeben wird.

132

Kapitel 4 · Visual Basic-Grundlagen

Die Vereinbarung eines Datentyps bewirkt, dass die Variable nur Daten dieses Typs aufnehmen kann. Eine Variable vom Datentyp Integer kann also keine Dezimalzahlen speichern. Bei Zuweisungen werden nicht passende Datentypen nach Möglichkeit konvertiert. Ist eine Konvertierung nicht möglich, löst dies einen Fehler aus. Bei der Entwicklung neuer Programme sollten Sie alleine aus Transparenzgründen Variablen mit Typen versehen und möglichst auf den impliziten Datentyp Object verzichten. Dies stellt sicher, dass eine Variable nur die jeweils passenden Werte enthält. Spätestens wenn die Werte solcher Variablen über die Programmgrenzen weitergegeben werden (z.B. beim Speichern in Datenbanken oder bei Aufrufen externer Funktionen), wirken sich falsche Inhalte fatal aus (es kommt dann zu den berüchtigten Laufzeitfehlern). Zudem kann der Compiler optimaleren Code erzeugen, wenn der Typ einer Variablen bereits zur Übersetzungszeit bekannt ist. Bei einer Variablen vom Typ Object muss der Compiler hingegen Code erzeugen, der ggf. eine Typumwandlung zur Laufzeit (wenn ein Wert zugewiesen wird) ermöglicht. Bei der Deklaration werden die Variablen mit einem so genannten Initialisierungswert belegt. Alle numerischen Datentypen (einschließlich Byte) erhalten den Wert 0, in Variablen vom Typ Char wird eine binäre Null hinterlegt (entspricht einem leeren Zeichen). Eine Boolesche Variable wird auf den Wert False gesetzt, ein Datumswert erhält den Vorgabewert 00:00 Uhr am 1. Januar des Jahres 1, mit dem die Datumsberechnung startet. Verweistypen wie Object oder String werden auf den Wert Nothing gesetzt. Nachdem eine Variable deklariert wurde, kann dieser im Programm ein Wert zugewiesen werden. Die Anweisung Alter = 10

weist der Variablen Alter einen Wert zu. Alternativ lassen sich Variablen bereits bei der Deklaration mit einem Initialisierungswert versehen. Die folgenden Anweisungen demonstrieren dies: Dim Dim Dim Dim

Alter As Integer = 18 Limit As Long = 300 Grenze As System.Int32 = -13 Text = "Hallo, dies ist ein Text"

Der Initialisierungswert wird einfach durch ein Gleichheitszeichen getrennt an die Deklaration angehängt. Beachten Sie, dass in der letzten Anweisung kein Datentyp vereinbart wurde. Der Visual Basic-Compiler verwendet den Datentyp Object und weist diesem dann den Text zu. Intern wird der Text als Datentyp String in der Variablen gespeichert.

133

Arbeiten mit Variablen

magnu num m

0

Leser, die mit älteren Versionen von Visual Basic Erfahrung haben, müssen sich ggf. an einige Neuerungen gewöhnen. So sollten Sie die implizite Typdefinition durch an den Variablennamen angehängte Sonderzeichen (z.B. Text$, Zahl&) nicht mehr verwenden. Diese Typvereinbarung ist zu untransparent und fehlerträchtig. Visual Basic .NET unterstützt auch keine DefTyp-Anweisungen wie DefBool mehr. Zudem sind einige Datentypen (z.B. Currency) entfallen oder es gibt Änderungen in der durch Datentypen belegten Speichergröße. Weiter oben finden Sie einen Abschnitt, der die in Visual Basic .NET zulässigen Datentypen beschreibt.

4.5.1

Wo kann ich Variablen deklarieren?

Die Variablendeklaration ist im Programm an verschiedenen Stellen möglich. Der Ort der Deklaration bestimmt auch die Gültigkeit der Variablen bzw. welche Schlüsselwörter zur Deklaration verwendet werden können. 쮿

Sie können Variablen innerhalb einer Prozedur (Sub) oder innerhalb einer Funktion (Function) mit Dim deklarieren. Dann ist die Variable innerhalb der Prozedur oder Funktion verwendbar.

쮿

Zusätzlich lassen sich Variablen auch in Blöcken (z.B. innerhalb eines If..End If-Blocks) vereinbaren. Dann sind die Variablen nur innerhalb dieses Blocks verwendbar.

쮿

Sie dürfen Variablen auch außerhalb einer Prozedur oder Funktion auf Modulebene oder auf Klassenebene vereinbaren. Dann ist die Variable innerhalb des Moduls oder innerhalb der Klasse verwendbar.

Das hört sich etwas kompliziert an. Schauen wir uns einfach einige Fälle von Programmbeispielen an. Das folgende Listing vereinbart eine lokale Variable Gewicht innerhalb einer Prozedur. '************************************************ ' File: Beisp04_05.vb ' Autor: G. Born www.borncity.de ' Zeigt, wie sich Variablen deklarieren lassen. '************************************************ Imports System.Console Class Test Shared Sub Main() ' das ist das Hauptmodul Dim Gewicht As Single = 200.00 ' Variable auf Sub-Ebene ' Gebe jetzt die Variablenwerte aus WriteLine ("Gewicht: {0}", Gewicht) Write ("Bitte die Eingabetaste drücken")

134

Kapitel 4 · Visual Basic-Grundlagen

ReadLine ' verhindert das Schließen des Konsolefensters End Sub End Class Listing 4.10: Verwendung einer lokalen Variablen in Beisp04_05.vb

Die Variable Gewicht ist nur innerhalb der Prozedur Sub Main sichtbar bzw. lässt sich nur dort benutzen. An dieser Stelle möchte ich Ihnen noch einen kleinen Hinweis zur Verwendung der WriteLine-Methode geben. Diese und die Write-Methode erlaubt das Arbeiten mit Platzhalterzeichen. Sie können der Methode mehrere Parameter übergeben. Die Zeichenkette im ersten Parameter darf dabei Platzhalter der Art {0}, {1} etc, enthalten. Dann ersetzt die Methode diese Platzhalter zur Laufzeit des Programms durch die Werte der folgenden Parameter. Der Platzhalter {0} wird durch den ersten Wert (d.h. durch das zweite Argument) ersetzt und so weiter. Betrachten wir jetzt die Situation, bei der auch Variablen auf Modulebene deklariert werden. Gemäß den Ausführungen am Kapitelanfang dürfen Sie ja aus Kompatibilitätsgründen noch die Module-Deklaration verwenden. Das folgende Listing vereinbart zusätzlich zur lokalen Variablen Gewicht noch eine Variable Alter auf Modulebene. Beide Variablen werden mit Dim vereinbart und der Einfachheit halber mit einem festen Wert initialisiert. Die WriteLine-Methode kommt hier mit zwei Platzhaltern zum Einsatz und sorgt für die Anzeige der beiden Werte auf der Konsole. '************************************************ ' File: Beisp04_05a.vb ' Autor: G. Born www.borncity.de ' Zeigt, wie sich Variablen deklarieren lassen. '************************************************ Imports System.Console Module Test Dim Alter As Integer = 18 Sub Main() ' das ist das Hauptmodul Dim Gewicht As Single = 200.00 ' Variable auf Sub-Ebene ' Gebe jetzt die Variablenwerte aus WriteLine ("Alter: {0} Gewicht: {1}", Alter, Gewicht) Write ("Bitte die Eingabetaste drücken") ReadLine ' verhindert das Schließen des Konsolefensters End Sub End Module Listing 4.11: Datei Beisp04_05a.vb mit lokalen und globalen Variablen

135

magnu num m

Arbeiten mit Variablen 0

Sie sehen im Listing, dass die global im Modulkopf vereinbarte Variable auch innerhalb der Prozedur genutzt werden kann. Dies liegt daran, dass die Prozedur Main innerhalb des Moduls liegt.

Bei Klassen heißt es aufpassen Die obigen Beispiele sind eigentlich recht einfach und leicht nachzuvollziehen. Am Kapitelanfang habe ich Ihnen aber empfohlen, den Programmcode für Prozeduren nicht in Modulen, sondern in Klassen zu kapseln. Sie können das obige Modulbeispiel 1:1 umsetzen und das Schlüsselwort Module durch den Bezeichner Class ersetzen. Zusätzlich müssen Sie dann aber das Schlüsselwort Shared vor die Sub Main()-Anweisung stellen (damit die Prozedur Main ohne explizite Instantiierung genutzt werden kann). Der Compiler wird aber beim Übersetzen eine Fehlermeldung bringen, sobald Sie in der Prozedur die auf Klassenebene vereinbarte Variable verwenden. Sie müssen zusätzlich das Schlüsselwort Shared innerhalb der Variablendeklaration mit Dim einfügen, damit die Variable auch ohne Instantiierung in der Prozedur verwendet werden kann. Das folgende Listing zeigt das betreffende an eine Klasse angepasste Beispiel. '************************************************ ' File: Beisp04_05b.vb ' Autor: G. Born www.borncity.de ' Zeigt, wie sich Variablen deklarieren lassen. '************************************************ Imports System.Console Class Test Dim Shared Alter As Integer = 18 Shared Sub Main()

' das ist das Hauptmodul

Dim Gewicht As Single = 200.00 ' Variable auf Sub-Ebene ' Gebe jetzt die Variablenwerte aus WriteLine ("Alter: {0} Gewicht: {1}", Alter, Gewicht) Write ("Bitte die Eingabetaste drücken") ReadLine ' verhindert das Schließen des Konsolefensters End Sub End Class Listing 4.12: Datei Beisp04_05b.vb mit globaler Variable in einer Klasse

Variablen in anderen Klassen Kommen wir noch auf eine weitere Variante zu sprechen. Als Einsteiger können Sie diesen Abschnitt ja übergehen und später nachschlagen. In einer Klasse ist es durchaus zulässig, Unterklassen neben Prozeduren oder Funktionen einzufügen. Dabei lässt sich vorstellen, dass eine solche

136

Kapitel 4 · Visual Basic-Grundlagen

Unterklasse ebenfalls Variablendeklarationen besitzt, die in Prozeduren verwendet werden müssen. Ich habe dies einmal an einem einfachen Beispiel realisiert. '************************************************ ' File: Beisp04_05c.vb ' Autor: G. Born www.borncity.de ' Zeigt, wie sich Variablen in einer Klasse deklarieren ' und in einer Prozedur verwenden lässt. '************************************************ Imports System.Console Class Test Dim Shared Alter As Integer = 18 Class MyData Public Shared Sex As String = "Männlich" Private Birth As Date = "15.3.2002" End Class Shared Sub Main() ' das ist das Hauptmodul Dim Gewicht As Single = 200.00 ' Variable auf Sub-Ebene ' Gebe jetzt die Variablenwerte aus WriteLine ("Alter: {0} Gewicht: {1}", Alter, Gewicht) WriteLine ("Geschlecht: {0}", MyData.Sex) Write ("Bitte die Eingabetaste drücken") ReadLine ' verhindert das Schließen des Konsolefensters End Sub End Class Listing 4.13: Datei Beisp04_05c.vb mit Variablen in einer Klasse

Die Variable Alter auf der obersten Ebene der Klasse Test wird mit dem Schlüsselwort Shared vereinbart, damit sie innerhalb der Klasse direkt (ohne Instantiierung) verwendbar ist. Neu hinzugekommen ist eine Unterklasse MyData, in der zwei Variablen Sex und Birth vereinbart wurden. Diese Variablen sind standardmäßig nur innerhalb dieser Unterklasse bekannt. Um die Variable Sex auch außerhalb der Klasse MyData verwenden zu können, habe ich diese mit dem Schlüsselwort Public als öffentlich erklärt. Zudem muss das Schlüsselwort Shared eingefügt werden, damit die Variable direkt in der Prozedur Main verwendbar ist. Die Variable Birth wird dagegen als Private deklariert und ist damit außerhalb der Unterklasse unbekannt. Um die öffentliche Variable Sex in der Prozedur Main ansprechen zu können, muss der komplette Namensraum mit angegeben werden. Die Variable lässt sich also über MyData.Sex ansprechen, wobei MyData der Klassenname ist, in dem sich die Variable befindet.

137

Arbeiten mit Variablen

magnu num m

0

4.5.2

Zugriffsberechtigung auf Variablen beeinflussen

Bei der Definition einer Variablen wird die Zugriffsberechtigung (d.h. von wo auf die Variable zugegriffen werden darf) implizit durch die Position im Programm beeinflusst. Dies wurde in den vorhergehenden Abschnitten skizziert. Auf eine mit Dim deklarierte Variable kann immer innerhalb des betreffenden Blocks zugegriffen werden. Sie können die Zugriffsberechtigungen auf Variablen aber durch verschiedene Schlüsselwörter beeinflussen. Die folgenden Anweisungen deklarieren ebenfalls Variable, legen gleichzeitig aber eine Gültigkeit fest. Public Alter As Integer = 20 Private Sex As String = "weiblich" Friend Gewicht As Single = 2.5

Nachfolgend finden Sie detailliertere Hinweise, wie diese optionalen Schlüsselwörter zu verwenden sind. 쮿

Public: Dieses Schlüsselwort ist nur innerhalb von Modulen, Klassen oder Strukturen verwendbar. In Prozeduren darf Public nicht angegeben werden. Wird das Schlüsselwort Public angegeben, kann das Schlüsselwort Dim entfallen. Als Public deklarierte Variablen haben

keine Zugriffsbeschränkungen. 쮿

Protected: Erlaubt eine Variable zu schützen, d.h. ist der Zugriff nur

쮿

Friend: Eine mit diesem Schlüsselwort deklarierte Variable lässt sich im gesamten Programm, welches die Deklaration enthält, sowie innerhalb der Assembly verwenden. Sie dürfen das Schlüsselwort nur innerhalb von Modulen, Klassen oder Strukturen verwenden. Zudem ist noch eine Kombination aus Protected und Friend zulässig.

쮿

Private: Wird eine Variable mit diesem Schlüsselwort deklariert, ist Sie nur im jeweiligen Deklarationskontext (z.B. innerhalb einer Klasse oder Prozedur) verwendbar. Sie können das Schlüsselwort innerhalb eines Moduls, einer Klasse oder einer Struktur (nicht jedoch in einer Prozedur) einsetzen.

in der eigenen Klasse oder in einer von dieser Klasse abgeleiteten Klasse zulässig. lässt sich Protected nur auf Klassenebene, nicht jedoch in Prozeduren oder Modulen, verwenden.

Neben diesen Schlüsselwörtern für die Zugriffsmodi gibt es bei der Variablendeklaration noch Anweisungen, die die Gültigkeit und Verfügbarkeit regeln. Eine in einer Prozedur (Sub xx End Sub) deklarierte Variable verliert ihre Gültigkeit, sobald die Prozedur beendet wird. Mit dem Schlüsselwort Static lässt sich erreichen, dass der Wert einer Variablen auch nach Beenden der Prozedur erhalten bleibt und den Wert behält. Das Schlüsselwort kann in Prozeduren und auf Blockebene verwendet werden. Beachten Sie aber, dass Static nicht zusammen mit Shared oder Shadows in einer Variablendeklaration auftreten darf.

138

Kapitel 4 · Visual Basic-Grundlagen

Wenn Sie eine Variable innerhalb einer Klasse deklarieren, können Sie diese zur Verwendung freigeben, indem Sie das Schlüsselwort Shared in der Deklaration (auf Modul-, Klassen- oder Strukturebene) angeben. Zum Zugriff auf die Variable ist dann der Klassen- oder Strukturname anzugeben (z.B. MyData.Sex). Bei Shared-Variablen ist die Option Static unzulässig. Auf der Ebene eines Moduls können Sie auch das Schlüsselwort Shadows verwenden, um eine Variable zu deklarieren, die den gleichen Bezeichner wie eine Variable einer Basisklasse besitzt. Dann wird der Bezeichner der Basisklasse durch die neu deklarierte Variable »überschattet«. Ein überschattetes Element ist in der abgeleiteten Klasse, von der es überschattet wird, nicht verfügbar. Zudem darf das StaticSchlüsselwort nicht zusammen mit Shadows benutzt werden. Eine mit dem Schlüsselwort ReadOnly deklarierte Variable lässt sich nicht beschreiben. Dies ist in Modulen, Klassen oder Strukturen hilfreich, wenn eine Konstante als Member einer Klasse vereinbart werden soll. Weitere Details sind der .NET Framework SDK-Hilfe zu entnehmen.

4.5.3

Was bedeuten Option Explicit und Option Strict

An dieser Stelle möchte ich noch auf zwei Steueranweisungen für den Compiler eingehen, die die Handhabung von Variablen beeinflussen. Wer bereits mit VBScript, VBA oder älteren Versionen von Visual Basic gearbeitet hat, kennt vielleicht die Option Option Explicit

die im Programmkopf vereinbart wurde. Sobald diese Anweisung auftritt, müssen Variablen explizit mittels einer Dim-Anweisung (oder einem der anderen Schlüsselwörter) vereinbart werden. Jede nicht deklarierte Variable wird dann durch den Compiler gemeldet. Der Vorteil: Tippfehler in Variablennamen, die sonst schwer zu finden sind, werden beim Übersetzen durch den Compiler gemeldet (Abbildung 4.2, untere Meldung).

Bild 4.2: Fehlermeldungen beim Übersetzen

139

Arbeiten mit Variablen

magnu num m

0

Visual Basic .NET zeigt hier ein geändertes Verhalten gegenüber älteren Versionen: Die Einstellung für Option Explicit ist standardmäßig auf On gesetzt, d.h. Sie müssen alle Variablen deklarieren. Möchten Sie dieses Verhalten deaktivieren (nicht empfohlen), können Sie die Anweisung Option Explicit Off

im Programmkopf (oberhalb des Moduls oder der Klasse) hinterlegen. Alternativ besteht die Möglichkeit, beim Übersetzen den Schalter /optionexplicit mit einem angehängten Plus- oder Minuszeichen ein- oder auszuschalten. Arbeiten Sie mit Visual Studio .NET, lässt sich diese Option in der Entwicklungsumgebung einstellen (Projekt im Projektmappen-Explorer wählen, dann im Menü PROJEKT den Befehl EIGENSCHAFTEN wählen, in der Gruppe ALLGEMEINE EIGENSCHAFTEN ist die Option Erstellen zu wählen, dann lassen sich die Optionen setzen). In den auf den vorhergehenden Seiten gezeigten Beispielen kam häufiger eine automatische Typkonvertierung durch Visual Basic zum Einsatz. Zum Beispiel wurden Integerwerte mit der MsgBox-Methode in einem Dialogfeld angezeigt. Die Verknüpfung mit einer Zeichenkette mittels des &-Operators (z.B. »Text « & Alter) führte dazu, dass Visual Basic automatisch die Zahlen in eine Zeichenkette umwandelte. Es ist aber nicht immer erwünscht, dass diese automatische Umwandlung erfolgt. Werden Variablen mit Datentypen versehen, soll der Compiler ggf. erkennen, wenn ein nicht kompatibler Wert zugewiesen wird. Dies lässt sich mit der Einstellung Option Strict

erreichen, die im Programmkopf hinterlegt wird. Alternativ besteht die Möglichkeit, beim Übersetzen den Schalter /optionstrict mit einem angehängten Plus- oder Minuszeichen ein- oder auszuschalten. Visual Studio .NET bietet zudem (wie bei Option Explict) die entsprechende Option in den Projekteigenschaften. Setzen Sie den Befehl Option Strict im Programm ein, wird der Compiler bei Typkonflikten eine Fehlermeldung bringen. Die Fehlermeldungen aus Abbildung 4.2 werden beim Übersetzen des folgenden Beispiels erzeugt. '************************************************ ' File: Beisp04_06.vb ' Autor: G. Born www.borncity.de ' Definiert verschiedene Variablen und weist diesen ' CTS-Datentypen zu. Listet die Werte und deren Typen ' in der Console auf. '************************************************ Option Strict 'Option Explicit Off Imports System.Console ' Für WriteLine Class Test Shared Sub Main() ' das ist das Hauptmodul

140

Kapitel 4 · Visual Basic-Grundlagen

Dim Alter As Integer Sex = "weiblich" Alter = 20.5

' Zuweisen des Werts

WriteLine("Alter {0} Geschlecht {1}", Alter, Sex) End Sub End Class Listing 4.14: Datei Beisp04_06.vb mit Compileroptionen

Die Anweisung Option Explicit Off

ist mit einem Kommentarzeichen versehen. Deshalb bemängelt der Compiler die nicht deklarierte Variable Sex. Entfernen Sie das Kommentarzeichen, ignoriert der Compiler die nicht deklarierte Variable. Der zweite Fehler wird durch die Zuweisung einer Dezimalzahl an die Integervariable Alter ausgelöst. Durch die Option Option Strict

darf der Compiler keine implizite Typumwandlung durchführen und löst folglich einen Fehler aus. Kommentieren Sie diese Anweisung, kann das Programm übersetzt werden. Sie finden die Datei Beisp04_06.vb mit den eingebauten Fehlern auf der Begleit-CD im Ordner \Beisp\Kap04.

141