2. Grundlagen der Sprache VB.NET
2.1. Einführung
Wir behandeln VB.NET zunächst als klassische Programmiersprache. Auf Objekte werden wir später eingehen.
In einem Programm gibt es zwei Arten von Elementen
- Daten
- Anweisungen, die diese bearbeiten
Man ist im Allgemeinen bestrebt, die Daten von den Anweisungen zu trennen:
 |
2.2. Die Daten von VB.NET
VB.NET verwendet die folgenden Datentypen:
- Ganzzahlen, reelle Zahlen und Dezimalzahlen
- Zeichen und Zeichenfolgen
- Boolesche Werte
- Datumsangaben
- Objekte
2.2.1. Vordefinierte Datentypen
Typ VB | Äquivalenter Typ .NET | Größe | Wertebereich |
Boolescher Wert | System.Boolean | 2 Byte | True oder False. |
Byte | System.Byte | 1 Byte | 0 bis 255 (vorzeichenlos). |
Zeichen | System.Char | 2 Bytes | 0 bis 65.535 (vorzeichenlos). |
Datum | System.DateTime | 8 Bytes | 0:00:00 am 1. Januar 0001 bis 23:59:59 am 31. Dezember 9999. |
Dezimal | System.Decimal | 16 Bytes | 0 bis +/-79 228 162 514 264 337 593 543 950 335 ohne Dezimalstellen; 0 bis +/-7,9228162514264337593543950335 mit 28 Dezimalstellen; die kleinste Zahl ungleich Null ist +/-0,0000000000000000000000000001 (+/-1E-28). |
Double | System.Double | 8 Byte | -1,79769313486231E+308 bis -4,94065645841247E-324 für negative Werte; 4,94065645841247E-324 bis 1,79769313486231E+308 für positive Werte. |
Ganzzahl | System.Int32 | 4 Byte | -2 147 483 648 bis 2 147 483 647. |
Long | System.Int64 | 8 Bytes | -9 223 372 036 854 775 808 bis 9 223 372 036 854 775 807. |
Objekt | System.Object | 4 Bytes | In einer Variablen vom Typ „Object“ kann ein beliebiger Typ gespeichert werden. |
Short | System.Int16 | 2 Bytes | -32.768 bis 32.767. |
Single | System.Single | 4 Bytes | -3,402823E+38 bis -1,401298E-45 für negative Werte; 1,401298E-45 bis 3,402823E+38 für positive Werte. |
Zeichenkette | System.String (Klasse) | 0 bis etwa 2 Milliarden Unicode-Zeichen. |
Aus der obigen Tabelle geht hervor, dass es zwei mögliche Typen für eine 32-Bit-Ganzzahl gibt: Integer und System.Int32. Beide Typen sind austauschbar. Das Gleiche gilt für die anderen Typen VB und ihre Entsprechungen auf der .NET-Plattform. Hier ein Programmbeispiel:
Module types
Sub Main()
' ganze Zahlen
Dim var1 As Integer = 100
Dim var2 As Long = 10000000000L
Dim var3 As Byte = 100
Dim var4 As Short = 4
' reelle Zahlen
Dim var5 As Decimal = 4.56789D
Dim var6 As Double = 3.4
Dim var7 As Single = -0.000103F
' Datum
Dim var8 As Date = New Date(2003, 1, 1, 12, 8, 4)
' Boolesche Werte
Dim var9 As Boolean = True
' Zeichen
Dim var10 As Char = "A"c
' Zeichenkette
Dim var11 As String = "abcde"
' Objekt
Dim var12 As Object = New Object
' Anzeigen
Console.Out.WriteLine("var1=" + var1.ToString)
Console.Out.WriteLine("var2=" + var2.ToString)
Console.Out.WriteLine("var3=" + var3.ToString)
Console.Out.WriteLine("var4=" + var4.ToString)
Console.Out.WriteLine("var5=" + var5.ToString)
Console.Out.WriteLine("var6=" + var6.ToString)
Console.Out.WriteLine("var7=" + var7.ToString)
Console.Out.WriteLine("var8=" + var8.ToString)
Console.Out.WriteLine("var9=" + var9.ToString)
Console.Out.WriteLine("var10=" + var10)
Console.Out.WriteLine("var11=" + var11)
Console.Out.WriteLine("var12=" + var12.ToString)
End Sub
End Module
Die Ausführung liefert folgende Ergebnisse:
var1=100
var2=10000000000
var3=100
var4=4
var5=4,56789
var6=3,4
var7=-0,000103
var8=01/01/2003 12:08:04
var9=True
var10=A
var11=abcde
var12=System.Object
2.2.2. Notation von Literalwerten
145, -7, &FF (hexadezimal) | |
100000L | |
134,789, -45E-18 (-45 × 10⁻¹⁸) | |
134.789F, -45E-18F (-45 × 10⁻¹⁸) | |
100000D | |
„A“c | |
„heute“ | |
true, false | |
New Date(2003, 1, 1) für den 01.01.2003 |
Beachten Sie folgende Punkte:
- 100000L, wobei das „L“ bedeutet, dass die Zahl als Long-Ganzzahl betrachtet wird
- 134.789F, das „F“ bedeutet, dass die Zahl als Gleitkommazahl mit einfacher Genauigkeit betrachtet wird
- 100000D, das „D“ bedeutet, dass die Zahl als Dezimalzahl betrachtet wird
- „A“c, um die Zeichenkette „A“ in das Zeichen 'A' umzuwandeln
- Die Zeichenkette wird vom Zeichen „.“ umschlossen. Wenn die Zeichenkette das Zeichen „“ enthalten soll, wird dieses doppelt geschrieben, wie in „abcd“„e“, um die Zeichenkette [abcd"e] darzustellen.
2.2.3. Datendeklaration
2.2.3.1. Rolle der Deklarationen
Ein Programm verarbeitet Daten, die durch einen Namen und einen Typ gekennzeichnet sind. Diese Daten werden im Speicher abgelegt. Bei der Übersetzung des Programms weist der Compiler jedem Datenelement einen Speicherplatz zu, der durch eine Adresse und eine Größe gekennzeichnet ist. Dabei stützt er sich auf die vom Programmierer vorgenommenen Deklarationen. Außerdem ermöglichen diese dem Compiler, Programmierfehler zu erkennen. So wird beispielsweise die Operation x = x * 2 als fehlerhaft gemeldet, wenn x eine Zeichenkette ist.
2.2.3.2. Deklaration von Konstanten
Die Syntax zur Deklaration einer Konstante lautet wie folgt:
const Bezeichner as Typ=Wert
zum Beispiel [const PI as double=3.141592]. Warum Konstanten deklarieren?
- Das Programm lässt sich leichter lesen, wenn man der Konstante einen aussagekräftigen Namen gegeben hat: [const taux_tva as single=0.186F]
- Die Änderung des Programms wird einfacher, falls sich die „Konstante“ ändern sollte. Im vorigen Fall müsste man also, wenn der Mehrwertsteuersatz auf 33 % steigt, lediglich die Anweisung ändern, die ihren Wert definiert: [const taux_tva as single=0.336F]. Hätte man 0,186 explizit im Programm verwendet, müssten zahlreiche Anweisungen geändert werden.
2.2.3.3. Deklaration von Variablen
Eine Variable wird durch einen Namen identifiziert und bezieht sich auf einen Datentyp. Bei VB.NET wird nicht zwischen Groß- und Kleinschreibung unterschieden. Somit sind die Variablen FIN und fin identisch. Variablen können bei ihrer Deklaration initialisiert werden. Die Syntax zur Deklaration einer oder mehrerer Variablen lautet:
dim variable1,variable2,...,variablen as Typbezeichner
wobei identificateur_de_type ein vordefinierter Typ oder ein vom Programmierer definierter Typ ist.
2.2.4. Konvertierungen zwischen Zahlen und Zeichenketten
nombre.ToString oder „“ & Zahl oder CType(Zahl, String) | |
objet.ToString | |
Integer.Parse(Zeichenkette) oder Int32.Parse | |
Long.Parse (Zeichenkette) oder Int64.Parse | |
Double.Parse (Zeichenkette) | |
Single.Parse (Zeichenkette) |
Die Konvertierung einer Zeichenfolge in eine Zahl kann fehlschlagen, wenn die Zeichenfolge keine gültige Zahl darstellt. In diesem Fall wird ein schwerwiegender Fehler ausgelöst, der in VB.NET als Ausnahme bezeichnet wird. Dieser Fehler kann durch die folgende Klausel try/catch behandelt werden:
try
appel de la fonction susceptible de générer l'exception
catch e as Exception
traiter l'exception e
end try
instruction suivante
Wenn die Funktion keine Ausnahme auslöst, wird zur nächsten Anweisung übergegangen; andernfalls wird der Hauptteil der Klausel catch ausgeführt und anschließend zur nächsten Anweisung übergegangen. Wir werden später noch auf die Ausnahmebehandlung zurückkommen. Hier ist ein Programm, das die wichtigsten Techniken zur Konvertierung zwischen Zahlen und Zeichenketten veranschaulicht. In diesem Beispiel gibt die Funktion den Wert ihres Parameters auf dem Bildschirm aus. So gibt affiche(S) den Wert von S auf dem Bildschirm aus.
' Anweisungen
Option Strict On
' importierte Namensräume
Imports System
' das Testmodul
Module Module1
Sub Main()
' Hauptprozedur
' lokale Daten
Dim S As String
Const i As Integer = 10
Const l As Long = 100000
Const f As Single = 45.78F
Dim d As Double = -14.98
' Zahl --> Zeichenkette
affiche(CType(i, String))
affiche(CType(l, String))
affiche(CType(f, String))
affiche(CType(d, String))
'Boolescher Wert --> Zeichenkette
Const b As Boolean = False
affiche(b.ToString)
' Zeichenkette --> int
Dim i1 As Integer = Integer.Parse("10")
affiche(i1.ToString)
Try
i1 = Integer.Parse("10.67")
affiche(i1.ToString)
Catch e As Exception
affiche("Erreur [10.67] : " + e.Message)
End Try
' Zeichenkette --> Long
Dim l1 As Long = Long.Parse("100")
affiche("" + l1.ToString)
Try
l1 = Long.Parse("10.675")
affiche("" & l1)
Catch e As Exception
affiche("Erreur [10.675] : " + e.Message)
End Try
' Zeichenkette --> Double
Dim d1 As Double = Double.Parse("100,87")
affiche(d1.ToString)
Try
d1 = Double.Parse("abcd")
affiche("" & d1)
Catch e As Exception
affiche("Erreur [abcd] : " + e.Message)
End Try
' Zeichenkette --> Single
Dim f1 As Single = Single.Parse("100,87")
affiche(f1.ToString)
Try
d1 = Single.Parse("abcd")
affiche(f1.ToString)
Catch e As Exception
affiche("Erreur [abcd] : " + e.Message)
End Try
End Sub
' Anzeige
Public Sub affiche(ByVal S As String)
Console.Out.WriteLine("S=" + S)
End Sub
End Module
Die folgenden Ergebnisse werden ausgegeben:
S=10
S=100000
S=45,78
S=-14,98
S=False
S=10
S=Erreur [10.67] : Le format de la chaîne d'entrée est incorrect.
S=100
S=Erreur [10.675] : Le format de la chaîne d'entrée est incorrect.
S=100,87
S=Erreur [abcd] : Le format de la chaîne d'entrée est incorrect.
S=100,87
S=Erreur [abcd] : Le format de la chaîne d'entrée est incorrect.
Beachten Sie, dass reelle Zahlen in Form einer Zeichenkette das Komma und nicht den Dezimalpunkt verwenden müssen. Daher schreibt man Dim d As Double = -14.98, aber Dim d1 As Double = Double.Parse("100,87")
2.2.5. Datenarrays
Ein Array VB.NET ist ein Objekt, mit dem Daten desselben Typs unter einem gemeinsamen Bezeichner zusammengefasst werden können. Es wird wie folgt deklariert:
Dim Array(n) as type oder Dim Array() as type = New type(n) {}
wobei n der Index des letzten Array-Elements ist. Die Syntax Tableau(i) bezeichnet den Datensatz Nr. i, wobei i zum Intervall [0,n] gehört. Jeder Verweis auf den Datenwert Tableau(i), bei dem i nicht zum Intervall [0,n] gehört, löst eine Ausnahme aus. Ein Array kann gleichzeitig mit seiner Deklaration initialisiert werden. In diesem Fall muss die Nummer des letzten Elements nicht angegeben werden.
Dim entiers() As Integer = {0, 10, 20, 30}
Arrays verfügen über eine Eigenschaft namens „Length“, die die Anzahl der Elemente des Arrays angibt. Hier ist ein Beispielprogramm:
Module tab0
Sub Main()
' eine erste Tabelle
Dim tab0(5) As Integer
For i As Integer = 0 To UBound(tab0)
tab0(i) = i
Next
For i As Integer = 0 To UBound(tab0)
Console.Out.WriteLine("tab0(" + i.ToString + ")=" + tab0(i).tostring)
Next
' eine zweite Tabelle
Dim tab1() As Integer = New Integer(5) {}
For i As Integer = 0 To tab1.Length - 1
tab1(i) = i * 10
Next
For i As Integer = 0 To tab1.Length - 1
Console.Out.WriteLine("tab1(" + i.ToString + ")=" + tab1(i).tostring)
Next
End Sub
End Module
und seine Ausführung:
tab0(0)=0
tab0(1)=1
tab0(2)=2
tab0(3)=3
tab0(4)=4
tab0(5)=5
tab1(0)=0
tab1(1)=10
tab1(2)=20
tab1(3)=30
tab1(4)=40
tab1(5)=50
Ein zweidimensionales Array kann wie folgt deklariert werden:
Dim Tableau(n,m) as Type oder Dim Tableau(,) as Type = New Type(n,m) {}
wobei n+1 die Anzahl der Zeilen und m+1 die Anzahl der Spalten ist. Die Syntax Tableau(i,j) bezeichnet das Element j in Zeile i von Tableau. Das zweidimensionale Array kann ebenfalls gleichzeitig mit seiner Deklaration initialisiert werden:
Dim réels(,) As Double = {{0.5, 1.7}, {8.4, -6}}
Die Anzahl der Elemente in jeder der Dimensionen kann mit der Methode GetLenth(i) ermittelt werden, wobei i=0 die Dimension mit dem ersten Index, i=1 die Dimension mit dem zweiten Index usw. darstellt. Hier ein Beispielprogramm:
Module Module2
Sub Main()
' eine erste Tabelle
Dim tab0(2, 1) As Integer
For i As Integer = 0 To UBound(tab0)
For j As Integer = 0 To tab0.GetLength(1) - 1
tab0(i, j) = i * 10 + j
Next
Next
For i As Integer = 0 To UBound(tab0)
For j As Integer = 0 To tab0.GetLength(1) - 1
Console.Out.WriteLine("tab0(" + i.ToString + "," + j.ToString + ")=" + tab0(i, j).tostring)
Next
Next
' eine zweite Tabelle
Dim tab1(,) As Integer = New Integer(2, 1) {}
For i As Integer = 0 To tab1.GetLength(0) - 1
For j As Integer = 0 To tab1.GetLength(1) - 1
tab1(i, j) = i * 100 + j
Next
Next
For i As Integer = 0 To tab1.GetLength(0) - 1
For j As Integer = 0 To tab1.GetLength(1) - 1
Console.Out.WriteLine("tab1(" + i.ToString + "," + j.ToString + ")=" + tab1(i, j).tostring)
Next
Next
End Sub
End Module
und die Ergebnisse seiner Ausführung:
tab0(0)=0
tab0(1)=1
tab0(2)=2
tab0(3)=3
tab0(4)=4
tab0(5)=5
tab1(0)=0
tab1(1)=10
tab1(2)=20
tab1(3)=30
tab1(4)=40
tab1(5)=50
Ein Array von Arrays wird wie folgt deklariert:
Dim Array(n)() as Type oder Dim Array()() as Type = new Type(n)()
Die obige Deklaration erstellt ein Array mit n+1 Zeilen. Jedes Element Tableau(i) ist ein eindimensionaler Array-Verweis. Diese Arrays werden bei der obigen Deklaration nicht erstellt. Das folgende Beispiel veranschaulicht die Erstellung eines Arrays von Arrays:
' ein Array von Arrays
Dim noms()() As String = New String(3)() {}
' Initialisierung
For i = 0 To noms.Length - 1
noms(i) = New String(i) {}
For j = 0 To noms(i).Length - 1
noms(i)(j) = "nom" & i & j
Next
Next
Hier ist noms(i) ein Array mit i+1 Elementen. Da noms(i) ein Array ist, entspricht noms(i).Length der Anzahl seiner Elemente. Hier ist ein Beispiel, das die drei soeben vorgestellten Array-Typen zusammenfasst:
' Richtlinien
Option Strict On
Option Explicit On
' Importe
Imports System
' Testklasse
Module test
Sub main()
' ein initialisiertes eindimensionales Array
Dim entiers() As Integer = {0, 10, 20, 30}
Dim i As Integer
For i = 0 To entiers.Length - 1
Console.Out.WriteLine("entiers[" & i & "]=" & entiers(i))
Next
' ein initialisiertes zweidimensionales Array
Dim réels(,) As Double = {{0.5, 1.7}, {8.4, -6}}
Dim j As Integer
For i = 0 To réels.GetLength(0) - 1
For j = 0 To réels.GetLength(1) - 1
Console.Out.WriteLine("réels[" & i & "," & j & "]=" & réels(i, j))
Next
Next
' ein Array von Arrays
Dim noms()() As String = New String(3)() {}
' Initialisierung
For i = 0 To noms.Length°- 1
noms(i) =°New String(i) {}
For j = 0 To noms(i).Length - 1
noms(i)(j) = "nom" & i & j
Next
Next
' Anzeige
For i = 0 To noms.Length°- 1
For j = 0 To noms(i).Length - 1
Console.Out.WriteLine("noms[" & i & "][" & j & "]=" & noms(i)(j))
Next
Next
End Sub
End Module
Bei der Ausführung erhalten wir folgende Ergebnisse:
entiers[0]=0
entiers[1]=10
entiers[2]=20
entiers[3]=30
réels[0,0]=0,5
réels[0,1]=1,7
réels[1,0]=8,4
réels[1,1]=-6
noms[0][0]=nom00
noms[1][0]=nom10
noms[1][1]=nom11
noms[2][0]=nom20
noms[2][1]=nom21
noms[2][2]=nom22
noms[3][0]=nom30
noms[3][1]=nom31
noms[3][2]=nom32
noms[3][3]=nom33
2.3. Die grundlegenden Anweisungen zu VB.NET
Man unterscheidet
1 die vom Computer ausgeführten Elementarbefehle.
2 die Befehle zur Steuerung des Programmablaufs.
Die elementaren Befehle werden deutlich, wenn man die Struktur eines Mikrocomputers und seiner Peripheriegeräte betrachtet.
 |
-
Einlesen von Informationen von der Tastatur
-
Verarbeitung von Informationen
-
Ausgabe von Informationen auf dem Bildschirm
-
Einlesen von Informationen aus einer Datei auf der Festplatte
-
Schreiben von Informationen in eine Datei auf der Festplatte
2.3.1. Schreiben auf dem Bildschirm
Es gibt verschiedene Befehle zum Schreiben auf dem Bildschirm:
Console.Out.WriteLine(expression)
Console.WriteLine(expression)
Console.Error.WriteLine (expression)
wobei expression ein beliebiger Datentyp ist, der in eine Zeichenkette umgewandelt werden kann, um auf dem Bildschirm angezeigt zu werden. In den bisher betrachteten Beispielen haben wir ausschließlich die Anweisung Console.Out.WriteLine(Ausdruck) verwendet.
Die Klasse System.Console ermöglicht den Zugriff auf Bildschirm-Schreiboperationen (Write, WriteLine). Die Klasse Console verfügt über zwei Eigenschaften, „Out“ und „Error“, bei denen es sich um Schreibströme vom Typ StreamWriter handelt:
- Console.WriteLine() entspricht Console.Out.WriteLine() und schreibt in den Out-Stream, der üblicherweise dem Bildschirm zugeordnet ist.
- Console.Error.WriteLine() schreibt in den Error-Stream, der in der Regel ebenfalls dem Bildschirm zugeordnet ist.
Die Streams Out und Error sind standardmäßig dem Bildschirm zugeordnet. Sie können jedoch zur Laufzeit des Programms in Textdateien umgeleitet werden, wie wir gleich sehen werden.
2.3.2. Einlesen von über die Tastatur eingegebenen Daten
Der Datenstrom von der Tastatur wird durch das Objekt Console.In vom Typ StreamReader bezeichnet. Mit Objekten dieses Typs lässt sich eine Textzeile mit der Methode ReadLine lesen:
Dim ligne As String = Console.In.ReadLine()
Die über die Tastatur eingegebene Zeile wird in der Variablen ligne gespeichert und kann anschließend vom programme.Le verarbeitet werden. Der In-Datenstrom kann wie die Out- und Error-Datenströme in eine Datei umgeleitet werden.
2.3.3. Beispiel für Ein- und Ausgabevorgänge
Hier ist ein kurzes Programm zur Veranschaulichung der Ein- und Ausgabeoperationen über Tastatur und Bildschirm:
' Optionen
Option Explicit On
Option Strict On
' Namensräume
Imports System
' Modul
Module io1
Sub Main()
' Schreiben in den Out-Stream
Dim obj As New Object
Console.Out.WriteLine(("" & obj.ToString))
' Schreiben in den Error-Stream
Dim i As Integer = 10
Console.Error.WriteLine(("i=" & i))
' Lesen einer über die Tastatur eingegebenen Zeile
Console.Out.Write("Tapez une ligne : ")
Dim ligne As String = Console.In.ReadLine()
Console.Out.WriteLine(("ligne=" + ligne))
End Sub
End Module
und die Ergebnisse der Ausführung:
Die Anweisungen
Dim obj As New Object
Console.Out.WriteLine(obj.ToString)
dienen lediglich dazu, zu zeigen, dass jedes beliebige Objekt angezeigt werden kann. Wir werden hier nicht näher auf die Bedeutung der angezeigten Inhalte eingehen.
2.3.4. E/A-Umleitung
Unter DOS/Windows gibt es drei Standardgeräte mit den Bezeichnungen:
- Standard-Eingabegerät – bezeichnet standardmäßig die Tastatur und trägt die Nummer 0
- Standard-Ausgabegerät – bezeichnet standardmäßig den Bildschirm und hat die Nummer 1
- Standard-Fehlergerät – bezeichnet standardmäßig den Bildschirm und trägt die Nummer 2
In VB.NET schreibt der Schreibstrom Console.Out auf Gerät 1, der Schreibstrom Console.Error schreibt auf Gerät 2 und der Lesestrom Console.In liest Daten von Gerät 0. Wenn man unter Windows ein Programm in einem DOS-Fenster startet, kann man festlegen, welche Geräte 0, 1 und 2 für das ausgeführte Programm verwendet werden sollen. Betrachten wir die folgende Befehlszeile:
Hinter den Argumenten argi des Programms pg können die Standard-E/A-Geräte auf Dateien umgeleitet werden:
Der Standardeingabestrom Nr. 0 wird in die Datei in.txt umgeleitet. Im Programm bezieht der Strom Console.In seine Daten somit aus der Datei in.txt. | ||||
leitet die Ausgabe Nr. 1 in die Datei out.txt um. Dies hat zur Folge, dass im Programm der Datenstrom Console.Out seine Daten in die Datei out.txt schreibt. | ||||
ebenso, jedoch werden die geschriebenen Daten zum aktuellen Inhalt der Datei out.txt hinzugefügt. | ||||
leitet die Ausgabe Nr. 2 in die Datei error.txt um. Dies hat zur Folge, dass im Programm der Datenstrom Console.Error seine Daten in die Datei error.txt schreibt | ||||
ebenso, jedoch werden die geschriebenen Daten an den aktuellen Inhalt der Datei error.txt angehängt. | ||||
Die Geräte 1 und 2 werden beide in Dateien umgeleitet | ||||
Es ist zu beachten, dass das Programm pg die E/A-Ströme in Dateien umleiten kann, ohne dass das Programm pg geändert werden muss. Das Programm OS legt die Art der Geräte 0, 1 und 2 fest. Betrachten wir das folgende Programm:
' Optionen
Option Explicit On
Option Strict On
' Namensräume
Imports System
' Umleitungen
Module console2
Sub Main()
' In-Stream lesen
Dim data As String = Console.In.ReadLine()
' Schreiben in den Out-Stream
Console.Out.WriteLine(("écriture dans flux Out : " + data))
' Schreiben in den Fehler-Stream
Console.Error.WriteLine(("écriture dans flux Error : " + data))
End Sub
End Module
Kompilieren wir dieses Programm:
dos>vbc es2.vb
Compilateur Microsoft (R) Visual Basic .NET version 7.10.3052.4 pour Microsoft (R) .NET Framework version 1.1.4322.573
Copyright (C) Microsoft Corporation 1987-2002. Tous droits réservés.
dos>dir
24/02/2004 15:39 416 es2.vb
11/03/2004 08:20 3 584 es2.exe
Führen wir eine erste Ausführung durch:
dos>es2.exe
un premier test
écriture dans flux Out : un premier test
écriture dans flux Error : un premier test
Der vorherige Lauf leitet keinen der Standard-E/A-Streams „In“, „Out“ und „Error“ um. Wir werden nun alle drei Streams umleiten. Der Stream „In“ wird in die Datei „in.txt“ umgeleitet, der Datenstrom „Out“ in die Datei „out.txt“ und der Datenstrom „Error“ in die Datei „error.txt“. Diese Umleitung erfolgt in der Befehlszeile in der Form
Die Ausführung liefert folgende Ergebnisse:
dos>more in.txt
un second test
dos>es2.exe 0<in.txt 1>out.txt 2>error.txt
dos>more out.txt
écriture dans flux Out : un second test
dos>more error.txt
écriture dans flux Error : un second test
Es ist deutlich zu erkennen, dass die Datenströme Out und Error nicht auf dieselben Peripheriegeräte schreiben.
2.3.5. Zuweisung des Werts eines Ausdrucks an eine Variable
Hier geht es um die Operation Variable = Ausdruck. Der Ausdruck kann folgende Typen haben: arithmetisch, relational, boolesch, Zeichen.
2.3.5.1. Liste der Operatoren
Aktion | Sprachelement |
^, –, *, /, \, Mod, +, = | |
=, ^=, *=, /=, \=, +=, -=, &= | |
=, <>, <, >, <=, >=, Like, Is | |
&, + | |
Nicht, Und, Oder, XOR, AndAlso, OrElse | |
AddressOf, GetType |
2.3.5.2. Arithmetischer Ausdruck
Die Operatoren für arithmetische Ausdrücke sind folgende:
^, –, *, /, \, Mod, +, = |
+: Addition, -: Subtraktion, *: Multiplikation, /: reelle Division, \: Quotient der ganzzahligen Division, Mod: Rest der ganzzahligen Division, ^: Potenzierung. Das folgende Programm lautet somit:
' Arithmetische Operatoren
Module operateursarithmetiques
Sub Main()
Dim i, j As Integer
i = 4 : j = 3
Console.Out.WriteLine(i & "/" & j & "=" & (i / j))
Console.Out.WriteLine(i & "\" & j & "=" & (i \ j))
Console.Out.WriteLine(i & " mod " & j & "=" & (i Mod j))
Dim r1, r2 As Double
r1 = 4.1 : r2 = 3.6
Console.Out.WriteLine(r1 & "/" & r2 & "=" & (r1 / r2))
Console.Out.WriteLine(r1 & "^2=" & (r1 ^ 2))
Console.Out.WriteLine(Math.Cos(3))
End Sub
End Module
liefert folgende Ergebnisse:
Es gibt verschiedene mathematische Funktionen. Hier sind einige davon:
| Quadratwurzel |
| Kosinus |
| Sinus |
| Tangente |
| x hoch y (x > 0) |
| Exponentialfunktion |
| Naturlogarithmus |
| Absolutwert |
Alle diese Funktionen sind in einer Klasse namens .NET definiert, die den Namen „Math“ trägt. Bei ihrer Verwendung muss ihnen der Name der Klasse vorangestellt werden, in der sie definiert sind. Man schreibt also:
Die vollständige Definition der Klasse Math lautet wie folgt:
Stellt die durch die Konstante e angegebene Basis des natürlichen Logarithmus dar. | ||||
Stellt das Verhältnis des Umfangs eines Kreises zu seinem Durchmesser dar, das durch die Konstante π definiert ist. | ||||
Überschrieben. Gibt den Absolutwert einer angegebenen Zahl zurück. | ||||
Gibt den Winkel zurück, dessen Kosinus der angegebene Wert ist. | ||||
Gibt den Winkel zurück, dessen Sinus der angegebene Wert ist. | ||||
Gibt den Winkel zurück, dessen Tangens der angegebene Wert ist. | ||||
Gibt den Winkel zurück, dessen Tangens der Quotient aus zwei angegebenen Zahlen ist. | ||||
Erzeugt das integrale Produkt zweier 32-Bit-Zahlen. | ||||
Gibt die kleinste ganze Zahl zurück, die größer oder gleich der angegebenen Zahl ist. | ||||
Gibt den Kosinus des angegebenen Winkels zurück. | ||||
Gibt den hyperbolischen Kosinus des angegebenen Winkels zurück. | ||||
Überschrieben. Gibt den Quotienten zweier Zahlen zurück und übergibt den Rest als Ausgabeparameter. | ||||
Gibt e hoch der angegebenen Potenz zurück. | ||||
Gibt die größte ganze Zahl zurück, die kleiner oder gleich der angegebenen Zahl ist. | ||||
Gibt den Rest der Division einer angegebenen Zahl durch eine andere Zahl zurück. | ||||
Überschrieben. Gibt den Logarithmus einer angegebenen Zahl zurück. | ||||
Gibt den Zehnerlogarithmus einer angegebenen Zahl zurück. | ||||
Überschrieben. Gibt die größere von zwei angegebenen Zahlen zurück. | ||||
Überschrieben. Gibt die kleinere von zwei Zahlen zurück. | ||||
Gibt eine angegebene Zahl zur angegebenen Potenz zurück. | ||||
Überschrieben. Gibt die Zahl zurück, die dem angegebenen Wert am nächsten liegt. | ||||
Überschrieben. Gibt einen Wert zurück, der das Vorzeichen einer Zahl angibt. | ||||
Gibt den Sinus des angegebenen Winkels zurück. | ||||
Gibt den hyperbolischen Sinus des angegebenen Winkels zurück. | ||||
Gibt die Quadratwurzel einer angegebenen Zahl zurück. | ||||
Gibt die Tangente des angegebenen Winkels zurück. | ||||
Gibt die hyperbolische Tangente des angegebenen Winkels zurück. | ||||
Wenn eine Funktion als „überladen“ bezeichnet wird, bedeutet dies, dass sie für verschiedene Parametertypen existiert. Beispielsweise existiert die Funktion Abs(x) für x vom Typ Integer, Long, Decimal, Single und Float. Für jeden dieser Typen gibt es eine separate Definition der Funktion Abs. Man sagt dann, dass sie überladen ist.
2.3.5.3. Prioritäten bei der Auswertung arithmetischer Ausdrücke
Die Priorität der Operatoren bei der Auswertung eines arithmetischen Ausdrucks ist wie folgt (von der höchsten zur niedrigsten Priorität):
Kategorie | Operatoren |
Alle Ausdrücke ohne Operator: Funktionen, Klammern | |
^ | |
+, - | |
*, / | |
\ | |
Mod | |
+, - |
2.3.5.4. Relationale Ausdrücke
Es gibt folgende Operatoren:
=, <>, <, >, <=, >=, Like, Is |
=: gleich, <>: ungleich, <: kleiner als (strikt), >: größer als (strikt), <=: kleiner oder gleich, >=: größer oder gleich, Like: entspricht einem Muster, Is: Objektidentität. Alle diese Operatoren haben die gleiche Priorität. Sie werden von links nach rechts ausgewertet. Das Ergebnis eines relationalen Ausdrucks ist ein boolescher Wert.
Vergleich von Zeichenketten: Betrachten wir das folgende Programm:
' Namensräume
Imports System
Module string1
Sub main()
Dim ch1 As Char = "A"c
Dim ch2 As Char = "B"c
Dim ch3 As Char = "a"c
Console.Out.WriteLine("A<B=" & (ch1 < ch2))
Console.Out.WriteLine("A<a=" & (ch1 < ch3))
Dim chat As String = "chat"
Dim chien As String = "chien"
Dim chaton As String = "chaton"
Dim chat2 As String = "CHAT"
Console.Out.WriteLine("chat<chien=" & (chat < chien))
Console.Out.WriteLine("chat<chaton=" & (chat < chaton))
Console.Out.WriteLine("chat<CHAT=" & (chat < chat2))
Console.Out.WriteLine("chaton like chat*=" & ("chaton" Like "chat*"))
End Sub
End Module
und das Ergebnis seiner Ausführung:
Seien zwei Zeichen C1 und C2. Sie können mit den Operatoren <, <=, =, <>, >, >= verglichen werden. Dabei werden ihre Unicode-Werte, also Zahlen, miteinander verglichen. Gemäß der Unicode-Reihenfolge gelten folgende Beziehungen:
Leerzeichen < .. < '0' < '1' < .. < '9' < .. < 'A' < 'B' < .. < 'Z' < .. < 'a' < 'b' < .. < 'z'
Zeichenketten werden Zeichen für Zeichen verglichen. Die erste Ungleichheit, auf die zwischen zwei Zeichen gestoßen wird, führt zu einer Ungleichheit gleicher Richtung bei den Zeichenketten. Mit diesen Erläuterungen wird der Leser dazu eingeladen, die Ergebnisse des vorherigen Programms zu untersuchen.
2.3.5.5. Boolesche Ausdrücke
Es gibt folgende Operatoren:
Not, And, Or, Xor, AndAlso, OrElse |
Not: logisches Und, Or: logisches Oder, Not: Negation, Xor: exklusives Oder.
op1 AndAlso op2: Wenn op1 falsch ist, wird op2 nicht ausgewertet und das Ergebnis ist falsch.
op1 OrElse op2: Wenn op1 wahr ist, wird op2 nicht ausgewertet und das Ergebnis ist wahr.
Die Priorität dieser Operatoren untereinander ist wie folgt:
Nicht | |
Und, AndAlso | |
Oder: OrElse | |
XOR |
Das Ergebnis eines booleschen Ausdrucks ist ein boolescher Wert.
2.3.5.6. Bitoperationen
Zum einen gibt es dieselben Operatoren wie bei den booleschen Operatoren mit derselben Priorität. Außerdem gibt es zwei Verschiebungsoperatoren: << und >>. Seien i und j zwei ganze Zahlen.
verschiebt i um n Bits nach links. Die neu hinzukommenden Bits sind Nullen. | |
verschiebt i um n Bits nach rechts. Ist i eine vorzeichenbehaftete Ganzzahl (signed char, int, long), bleibt das Vorzeichenbit erhalten. | |
führt die bitweise logische Verknüpfung von i und j durch (ET). | |
führt die bitweise logische Verknüpfung von i und j gemäß OU durch. | |
komplementiert i auf 1 | |
führt die Operation OU EXCLUSIF mit i und j durch |
Nehmen wir folgendes Programm:
Module operationsbit
Sub main()
' Bitmanipulation
Dim i As Short = &H123F
Dim k As Short = &H7123
Console.Out.WriteLine("i<<4=" & (i << 4).ToString("X"))
Console.Out.WriteLine("i>>4=" & (i >> 4).ToString("X"))
Console.Out.WriteLine("k>>4=" & (k >> 4).ToString("X"))
Console.Out.WriteLine("i and 4=" & (i And 4).ToString("X"))
Console.Out.WriteLine("i or 4 =" & (i Or 4).ToString("X"))
Console.Out.WriteLine("not i=" & (Not i).ToString("X"))
End Sub
End Module
Seine Ausführung liefert folgende Ergebnisse:
2.3.5.7. Mit einer Zuweisung verbundener Operator
Man kann a+=b schreiben, was a=a+b bedeutet. Die Liste der Operatoren, die mit der Zuweisungsoperation kombiniert werden können, lautet wie folgt:
^=, *=, /=, \=, +=, -=, &= |
2.3.5.8. Allgemeine Operatorpriorität
Kategorie | Operatoren |
Alle Ausdrücke ohne Operator | |
^ | |
+, - | |
*, / | |
\ | |
Mod | |
+, - | |
& | |
<<, >> | |
=, <>, <, >, <=, >=, Like, Is, TypeOf...Is | |
Nicht | |
Und, AndAlso | |
Oder: OrElse | |
XOR |
Befindet sich ein Operand zwischen zwei Operatoren gleicher Priorität, bestimmt die Assoziativität der Operatoren die Reihenfolge, in der die Operationen ausgeführt werden. Alle Operatoren sind linksassoziativ, was bedeutet, dass die Operationen von links nach rechts ausgeführt werden. Priorität und Assoziativität können mithilfe von Ausdrücken in Klammern gesteuert werden.
2.3.5.9. Typkonvertierungen
Es gibt eine Reihe vordefinierter Funktionen, mit denen man von einem Datentyp zu einem anderen wechseln kann. Die Liste lautet wie folgt:
Diese Funktionen akzeptieren als Argument einen numerischen Ausdruck oder eine Zeichenkette. Der Typ des Ergebnisses ist in der folgenden Tabelle angegeben:
Funktion | Ergebnis | Wertebereich des Funktionsparameters |
Boolean | Jede gültige Zeichenfolge oder jeder gültige numerische Ausdruck. | |
Byte | 0 bis 255; Bruchteile werden gerundet. | |
Zeichen | Jeder gültige String-Ausdruck; der Wert kann zwischen 0 und 65.535 liegen. | |
Datum | Jede gültige Darstellung von Datum und Uhrzeit. | |
Double | -1,79769313486231E+308 bis -4,94065645841247E-324 für negative Werte; 4,94065645841247E-324 bis 1,79769313486231E+308 für positive Werte. | |
Dezimal | +/-79 228 162 514 264 337 593 543 950 335 für Zahlen ohne Dezimalstellen. Der Wertebereich für Zahlen mit 28 Dezimalstellen beträgt +/-7,9228162514264337593543950335. Die kleinste Zahl ungleich Null ist 0,0000000000000000000000000001. | |
Ganzzahl | -2 147 483 648 bis 2 147 483 647; Bruchteile werden gerundet. | |
Long | -9 223 372 036 854 775 808 bis 9 223 372 036 854 775 807; Bruchteile werden gerundet. | |
| Objekt | Jeder gültige Ausdruck. |
Kurz | -32.768 bis 32.767; Bruchteile werden gerundet. | |
Single | -3,402823E+38 bis -1,401298E-45 für negative Werte; 1,401298E-45 bis 3,402823E+38 für positive Werte. | |
Zeichenkette | Die von der Funktion Cstr zurückgegebenen Werte hängen vom Argument „expression“ ab. |
Hier ein Beispielprogramm:
Module conversion
Sub main()
Dim var1 As Boolean = CBool("true")
Dim var2 As Byte = CByte("100")
Dim var3 As Char = CChar("A")
Dim var4 As Date = CDate("30 janvier 2004")
Dim var5 As Double = CDbl("100,45")
Dim var6 As Decimal = CDec("1000,67")
Dim var7 As Integer = CInt("-30")
Dim var8 As Long = CLng("456")
Dim var9 As Short = CShort("-14")
Dim var10 As Single = CSng("56,78")
Console.Out.WriteLine("var1=" & var1)
Console.Out.WriteLine("var2=" & var2)
Console.Out.WriteLine("var3=" & var3)
Console.Out.WriteLine("var4=" & var4)
Console.Out.WriteLine("var5=" & var5)
Console.Out.WriteLine("var6=" & var6)
Console.Out.WriteLine("var7=" & var7)
Console.Out.WriteLine("var8=" & var8)
Console.Out.WriteLine("var9=" & var9)
Console.Out.WriteLine("var10=" & var10)
End Sub
End Module
und die Ergebnisse ihrer Ausführung:
var1=True
var2=100
var3=A
var4=30/01/2004
var5=100,45
var6=1000,67
var7=-30
var8=456
var9=-14
var10=56,78
Man kann auch die Funktion CType(expression, type) verwenden, wie das folgende Programm zeigt:
Module ctype1
Sub main()
Dim var1 As Boolean = CType("true", Boolean)
Dim var2 As Byte = CType("100", Byte)
Dim var3 As Char = CType("A", Char)
Dim var4 As Date = CType("30 janvier 2004", Date)
Dim var5 As Double = CType("100,45", Double)
Dim var6 As Decimal = CType("1000,67", Decimal)
Dim var7 As Integer = CType("-30", Integer)
Dim var8 As Long = CType("456", Long)
Dim var9 As Short = CType("-14", Short)
Dim var10 As Single = CType("56,78", Single)
Dim var11 As String = CType("47,89", String)
Dim var12 As String = 47.89.ToString
Dim var13 As String = "" & 47.89
Console.Out.WriteLine("var1=" & var1)
Console.Out.WriteLine("var2=" & var2)
Console.Out.WriteLine("var3=" & var3)
Console.Out.WriteLine("var4=" & var4)
Console.Out.WriteLine("var5=" & var5)
Console.Out.WriteLine("var6=" & var6)
Console.Out.WriteLine("var7=" & var7)
Console.Out.WriteLine("var8=" & var8)
Console.Out.WriteLine("var9=" & var9)
Console.Out.WriteLine("var10=" & var10)
Console.Out.WriteLine("var11=" & var11)
Console.Out.WriteLine("var12=" & var12)
Console.Out.WriteLine("var13=" & var13)
End Sub
End Module
was zu folgenden Ergebnissen führt:
var1=True
var2=100
var3=A
var4=30/01/2004
var5=100,45
var6=1000,67
var7=-30
var8=456
var9=-14
var10=56,78
var11=47,89
var12=47,89
var13=47,89
2.4. Anweisungen zur Steuerung des Programmablaufs
2.4.1. Beenden
Mit der in der Klasse Environment definierten Methode Exit lässt sich die Ausführung eines Programms anhalten:
[Visual Basic]
Public Shared Sub Exit(ByVal exitCode As Integer )
beendet den laufenden Prozess und gibt den Wert exitCode an den übergeordneten Prozess zurück. Der Wert von exitCode kann von diesem verwendet werden. Unter DOS wird diese Statusvariable an DOS in der Systemvariablen ERRORLEVEL zurückgegeben, deren Wert in einer Batch-Datei überprüft werden kann. Unter Unix wird der Wert von exitCode in der Variablen $? gespeichert.
beendet die Ausführung des Programms mit einem Statuswert von 0.
2.4.2. Einfache Auswahlstruktur
- Jede Aktion steht in einer eigenen Zeile
- Die Klausel else kann fehlen.
Auswahlstrukturen können verschachtelt werden, wie das folgende Beispiel zeigt:
' Optionen
Option Explicit On
Option Strict On
' Namensräume
Imports System
Module if1
Sub main()
Dim i As Integer = 10
If i > 4 Then
Console.Out.WriteLine(i & " est > " & 4)
Else
If i = 4 Then
Console.Out.WriteLine(i & " est = " & 4)
Else
Console.Out.WriteLine(i & " est < " & 4)
End If
End If
End Sub
End Module
Das Ergebnis lautet:
2.4.3. Fallstruktur
Die Syntax lautet wie folgt:
select case expression
case liste_valeurs1
actions1
case liste_valeurs2
actions2
...
case else
actions_sinon
end select
- Der Typ von [expression] muss einer der folgenden Typen sein:
- Die Klausel [case else] kann fehlen.
- [liste_valeursi] sind mögliche Werte des Ausdrucks. [listes_valeursi] steht für eine Liste von Bedingungen: Bedingung1, Bedingung2, …, Bedingungx. Wenn [expression] eine der Bedingungen erfüllt, werden die hinter der Klausel [liste_valeursi] stehenden Aktionen ausgeführt. Die Bedingungen können folgende Form annehmen:
- val1 to val2: wahr, wenn [expression] zum Bereich [val1,val2] gehört
- val1: wahr, wenn [expression] gleich val1 ist
- is > val1: wahr, wenn [expression] > val1 ist. Das Schlüsselwort [is] kann fehlen
- Das Gleiche gilt für die Operatoren =, <, <=, >, >=, <>
- Es werden nur die Aktionen ausgeführt, die mit der ersten überprüften Bedingung verknüpft sind.
Betrachten wir das folgende Programm:
' Optionen
Option Explicit On
Option Strict On
' Namensräume
Imports System
Module selectcase1
Sub main()
Dim i As Integer = 10
Select Case i
Case 1 To 4, 7 To 8
Console.Out.WriteLine("i est dans l'intervalle [1,4] ou [7,8]")
Case Is > 12
Console.Out.WriteLine("i est > 12")
Case Is < 15
Console.Out.WriteLine("i est < 15")
Case Is < 20
Console.Out.WriteLine("i est < 20")
End Select
End Sub
End Module
Es liefert folgende Ergebnisse:
2.4.4. Wiederholungsstruktur
2.4.4.1. Anzahl der Wiederholungen bekannt
For counter [ As datatype ] = start To end [ Step step ]
actions
Next [ counter ]
Die Aktionen werden für jeden Wert der Variablen [counter] ausgeführt. Betrachten wir das folgende Programm:
' Optionen
Option Explicit On
Option Strict On
' Namensräume
Imports System
Module for1
Sub main()
Dim somme As Integer = 0
Dim résultat As String = "somme("
For i As Integer = 0 To 10 Step 2
somme += i
résultat += " " + i.ToString
Next
résultat += ")=" + somme.ToString
Console.Out.WriteLine(résultat)
End Sub
End Module
Die Ergebnisse:
Eine weitere Iterationsstruktur mit bekannter Iterationsanzahl sieht wie folgt aus:
For Each element [ As datatype ] In groupe
[ actions ]
Next [ element ]
- groupe ist eine Sammlung von Objekten. Die uns bereits bekannte Sammlung von Objekten ist das Array
- datatype ist der Typ der Objekte in der Sammlung. Bei einem Array wäre dies der Typ der Array-Elemente
- element ist eine lokale Variable der Schleife, die nacheinander alle Werte der Sammlung annimmt.
Somit lautet der folgende Code:
' Optionen
Option Explicit On
Option Strict On
' Namensräume
Imports System
Module foreach1
Sub main()
Dim amis() As String = {"paul", "hélène", "jacques", "sylvie"}
For Each nom As String In amis
Console.Out.WriteLine(nom)
Next
End Sub
End Module
würde Folgendes anzeigen:
2.4.4.2. Anzahl der Wiederholungen unbekannt
Für diesen Fall gibt es zahlreiche Strukturen in VB.NET.
Do { While | Until } condition
[ statements ]
Loop
Die Schleife wird so lange wiederholt, wie die Bedingung erfüllt ist (while) oder bis die Bedingung erfüllt ist (until). Die Schleife wird möglicherweise nie ausgeführt.
Do
[ statements ]
Loop { While | Until } condition
Die Schleife wird so lange wiederholt, wie die Bedingung erfüllt ist (while) oder bis die Bedingung erfüllt ist (until). Die Schleife wird immer mindestens einmal ausgeführt.
While condition
[ statements ]
End While
Die Schleife wird so lange ausgeführt, wie die Bedingung erfüllt ist. Die Schleife wird möglicherweise nie ausgeführt. Die folgenden Schleifen berechnen alle die Summe der ersten 10 ganzen Zahlen.
' Optionen
Option Explicit On
Option Strict On
' Namensräume
Imports System
Module boucles1
Sub main()
Dim i, somme As Integer
i = 0 : somme = 0
Do While i < 11
somme += i
i += 1
Loop
Console.Out.WriteLine("somme=" + somme.ToString)
i = 0 : somme = 0
Do Until i = 11
somme += i
i += 1
Loop
Console.Out.WriteLine("somme=" + somme.ToString)
i = 0 : somme = 0
Do
somme += i
i += 1
Loop Until i = 11
Console.Out.WriteLine("somme=" + somme.ToString)
i = 0 : somme = 0
Do
somme += i
i += 1
Loop While i < 11
Console.Out.WriteLine("somme=" + somme.ToString)
End Sub
End Module
2.4.4.3. Anweisungen zur Schleifenverwaltung
Verlässt eine do ... loop-Schleife | |
Beendet eine „for“-Schleife |
2.5. Der Aufbau eines Programms VB.NET
Ein Programm VB.NET, das weder benutzerdefinierte Klassen noch andere Funktionen als die Hauptfunktion Main verwendet, kann folgende Struktur haben:
' Optionen
Option Explicit On
Option Strict On
' Namensräume
Imports espace1
Imports ....
Module nomDuModule
Sub main()
....
End Sub
End Module
- Die Direktive [Option Explicit on] erzwingt die Deklaration von Variablen. In VB.NET ist dies nicht zwingend erforderlich. Eine nicht deklarierte Variable hat dann den Typ „Object“.
- Die Direktive [Option Strict on] verbietet jede Datenumwandlung, die zu Datenverlust führen könnte, sowie jede Umwandlung zwischen numerischen Typen und Zeichenketten. Es müssen daher explizit Konvertierungsfunktionen verwendet werden.
- Das Programm importiert alle benötigten Namensräume. Dieses Konzept haben wir bisher noch nicht behandelt. In den vorangegangenen Programmen sind wir häufig auf Anweisungen der folgenden Art gestoßen:
Wir hätten eigentlich schreiben müssen:
wobei „System“ der Namespace ist, der die Klasse „[Console]“ enthält. Wenn man den Namespace [System] mit einer Imports-Anweisung importiert, durchsucht VB.NET diesen systematisch, sobald er auf eine ihm unbekannte Klasse stößt. Er wiederholt die Suche in allen deklarierten Namespaces, bis er die gesuchte Klasse findet. Man schreibt dann:
' Namensräume
Imports System
....
Console.Out.WriteLine(unechaine)
Ein Beispiel für ein Programm könnte wie folgt aussehen:
' Optionen
Option Explicit On
Option Strict On
'Namensräume
Imports System
' Hauptmodul
Module main1
Sub main()
Console.Out.WriteLine("main1")
End Sub
End Module
Dasselbe Programm lässt sich wie folgt schreiben:
' Optionen
Option Explicit On
Option Strict On
'Namensräume
Imports System
' Testklasse
Public Class main2
Public Shared Sub main()
Console.Out.WriteLine("main2")
End Sub
End Class
Hier verwenden wir das Konzept der Klasse, das im nächsten Kapitel vorgestellt wird. Wenn eine solche Klasse eine statische (shared) Prozedur namens „main“ enthält, wird diese ausgeführt. Wir führen diese Schreibweise hier ein, weil die Schwestersprache von VB.NET, nämlich C#, ausschließlich das Konzept der Klasse kennt, c.a.d, wonach jeder ausgeführte Code zwangsläufig zu einer Klasse gehört. Der Begriff der Klasse gehört zur objektorientierten Programmierung. Ihn bei der Konzeption jedes Programms zwingend vorzuschreiben, ist etwas ungeschickt. Das zeigt sich hier in Version 2 des vorherigen Programms, wo man dazu gezwungen ist, ein Konzept von Klasse und statischer Methode einzuführen, wo es gar nicht benötigt wird. Daher werden wir im weiteren Verlauf das Konzept der Klasse nur dann einführen, wenn es notwendig ist. In allen anderen Fällen werden wir den Begriff des Moduls verwenden, wie in der obigen Version 1.
2.6. Kompilierung und Ausführung eines Programms VB.NET
Für die Kompilierung eines Programms VB.NET wird lediglich das Programm SDK.NET benötigt. Betrachten wir das folgende Programm:
' Optionen
Option Explicit On
Option Strict On
' Namensräume
Imports System
Module boucles1
Sub main()
Dim i, somme As Integer
i = 0 : somme = 0
Do While i < 11
somme += i
i += 1
Loop
Console.Out.WriteLine("somme=" + somme.ToString)
i = 0 : somme = 0
Do Until i = 11
somme += i
i += 1
Loop
Console.Out.WriteLine("somme=" + somme.ToString)
i = 0 : somme = 0
Do
somme += i
i += 1
Loop Until i = 11
Console.Out.WriteLine("somme=" + somme.ToString)
i = 0 : somme = 0
Do
somme += i
i += 1
Loop While i < 11
Console.Out.WriteLine("somme=" + somme.ToString)
End Sub
End Module
Nehmen wir an, es befindet sich in einer Datei namens [boucles1.vb]. Um es zu kompilieren, gehen wir wie folgt vor:
dos>dir boucles1.vb
11/03/2004 15:55 583 boucles1.vb
dos>vbc boucles1.vb
Compilateur Microsoft (R) Visual Basic .NET version 7.10.3052.4
pour Microsoft (R) .NET Framework version 1.1.4322.573
Copyright (C) Microsoft Corporation 1987-2002. Tous droits réservés.
dos>dir boucles1.*
11/03/2004 16:04 601 boucles1.vb
11/03/2004 16:04 3 584 boucles1.exe
Das Programm vbc.exe ist der Compiler VB.NET. Hier war es im PATH des DOS:
dos>path
PATH=E:\Program Files\Microsoft Visual Studio .NET 2003\Common7\IDE;E:\Program Files\Microsoft Visual Studio .NET 2003\VC7\BIN;E:\Program Files\Microsoft Visual Studio .NET 2003\Common7\Tools;E:\Program Files\Microsoft Visual Studio .NET 2003\Common7\Tools\bin\prerelease;E:\Program Files\Microsoft Visual Studio .NET 2003\Common7\Tools\bin;E:\Program Files\Microsoft Visual Studio .NET 2003\SDK\v1.1\bin;E:\WINNT\Microsoft.NET\Framework\v1.1.4322;e:\winnt\system32;e:\winnt;
dos>dir E:\WINNT\Microsoft.NET\Framework\v1.1.4322\vbc.exe
21/02/2003 10:20 737 280 vbc.exe
Der Compiler [vbc] erzeugt eine ausführbare .exe-Datei für die virtuelle Maschine .NET:
2.7. Das Beispiel IMPOTS
Wir wollen ein Programm schreiben, mit dem sich die Steuer eines Steuerpflichtigen berechnen lässt. Wir betrachten den vereinfachten Fall eines Steuerpflichtigen, der nur sein Gehalt anzugeben hat:
- Man berechnet die Anzahl der Anteile des Arbeitnehmers nbParts = nbEnfants/2 + 1, wenn er unverheiratet ist, nbEnfants/2+2, wenn er verheiratet ist, wobei nbEnfants die Anzahl seiner Kinder ist.
- Wenn er mindestens drei Kinder hat, erhält er einen halben Anteil zusätzlich
- sein steuerpflichtiges Einkommen R wird berechnet als R = 0,72 * S, wobei S sein Jahresgehalt ist
- man berechnet seinen Familienkoeffizienten QF = R / nbParts
- Man berechnet seine Steuer I. Betrachten wir die folgende Tabelle:
12620,0 | 0 | 0 |
13.190 | 0,05 | 631 |
15640 | 0,1 | 1290,5 |
24.740 | 0,15 | 2072,5 |
31.810 | 0,2 | 3309,5 |
39.970 | 0,25 | 4900 |
48360 | 0,3 | 6898,5 |
55.790 | 0,35 | 9316,5 |
92.970 | 0,4 | 12106 |
127.860 | 0,45 | 16.754,5 |
151250 | 0,50 | 23.147,5 |
172.040 | 0,55 | 30.710 |
195.000 | 0,60 | 39312 |
0 | 0,65 | 49062 |
Jede Zeile enthält 3 Felder. Um die Steuer I zu berechnen, wird die erste Zeile gesucht, in der QF <= Feld 1 gilt. Wenn beispielsweise QF = 23000 ist, wird die Zeile
Die Steuer I beträgt dann 0,15*R – 2072,5*nbParts. Wenn QF so ist, dass die Beziehung QF <= Feld1 niemals erfüllt ist, werden die Koeffizienten der letzten Zeile verwendet. Hier:
was die Steuer I = 0,65 * R – 49062 * nbParts ergibt. Das entsprechende Programm VB.NET lautet wie folgt:
' Optionen
Option Explicit On
Option Strict On
' Namensräume
Imports System
Module impots
' ------------ Hauptprogramm
Sub Main()
' für die Steuerberechnung erforderliche Datentabellen
Dim Limites() As Decimal = {12620D, 13190D, 15640D, 24740D, 31810D, 39970D, 48360D, 55790D, 92970D, 127860D, 151250D, 172040D, 195000D, 0D}
Dim CoeffN() As Decimal = {0D, 631D, 1290.5D, 2072.5D, 3309.5D, 4900D, 6898.5D, 9316.5D, 12106D, 16754.5D, 23147.5D, 30710D, 39312D, 49062D}
' Der Familienstand wird abgerufen
Dim OK As Boolean = False
Dim reponse As String = Nothing
While Not OK
Console.Out.Write("Etes-vous marié(e) (O/N) ? ")
reponse = Console.In.ReadLine().Trim().ToLower()
If reponse <> "o" And reponse <> "n" Then
Console.Error.WriteLine("Réponse incorrecte. Recommencez")
Else
OK = True
End If
End While
Dim Marie As Boolean = reponse = "o"
' Anzahl der Kinder
OK = False
Dim NbEnfants As Integer = 0
While Not OK
Console.Out.Write("Nombre d'enfants : ")
reponse = Console.In.ReadLine()
Try
NbEnfants = Integer.Parse(reponse)
If NbEnfants >= 0 Then
OK = True
Else
Console.Error.WriteLine("Réponse incorrecte. Recommencez")
End If
Catch
Console.Error.WriteLine("Réponse incorrecte. Recommencez")
End Try
End While
' Gehalt
OK = False
Dim Salaire As Integer = 0
While Not OK
Console.Out.Write("Salaire annuel : ")
reponse = Console.In.ReadLine()
Try
Salaire = Integer.Parse(reponse)
If Salaire >= 0 Then
OK = True
Else
Console.Error.WriteLine("Réponse incorrecte. Recommencez")
End If
Catch
Console.Error.WriteLine("Réponse incorrecte. Recommencez")
End Try
End While
' Berechnung der Anzahl der Anteile
Dim NbParts As Decimal
If Marie Then
NbParts = CDec(NbEnfants) / 2 + 2
Else
NbParts = CDec(NbEnfants) / 2 + 1
End If
If NbEnfants >= 3 Then
NbParts += 0.5D
End If
' steuerpflichtiges Einkommen
Dim Revenu As Decimal
Revenu = 0.72D * Salaire
' Familienquotient
Dim QF As Decimal
QF = Revenu / NbParts
' Ermittlung der Steuerklasse entsprechend QF
Dim i As Integer
Dim NbTranches As Integer = Limites.Length
Limites((NbTranches - 1)) = QF
i = 0
While QF > Limites(i)
i += 1
End While
' die Steuer
Dim impots As Integer = CInt(i * 0.05D * Revenu - CoeffN(i) * NbParts)
' Das Ergebnis wird angezeigt
Console.Out.WriteLine(("Impôt à payer : " & impots))
End Sub
End Module
Das Programm wird in einem DOS-Fenster wie folgt kompiliert:
dos>vbc impots1.vb
Compilateur Microsoft (R) Visual Basic .NET version 7.10.3052.4 pour Microsoft (R) .NET Framework version 1.1.4322.573
dos>dir impots1.exe
24/02/2004 15:42 5 632 impots1.exe
Die Kompilierung erzeugt eine ausführbare Datei namens impots.exe. Es ist zu beachten, dass impots.exe nicht direkt vom Prozessor ausgeführt werden kann. Es enthält vielmehr Zwischencode, der nur auf einer .NET-Plattform ausgeführt werden kann. Die erzielten Ergebnisse lauten wie folgt:
dos>impots1
Etes-vous marié(e) (O/N) ? o
Nombre d'enfants : 3
Salaire annuel : 200000
Impôt à payer : 16400
dos>impots1
Etes-vous marié(e) (O/N) ? n
Nombre d'enfants : 2
Salaire annuel : 200000
Impôt à payer : 33388
dos>impots1
Etes-vous marié(e) (O/N) ? w
Réponse incorrecte. Recommencez
Etes-vous marié(e) (O/N) ? q
Réponse incorrecte. Recommencez
Etes-vous marié(e) (O/N) ? o
Nombre d'enfants : q
Réponse incorrecte. Recommencez
Nombre d'enfants : 2
Salaire annuel : q
Réponse incorrecte. Recommencez
Salaire annuel : 1
Impôt à payer : 0
2.8. Argumente des Hauptprogramms
Die Hauptprozedur Main kann als Parameter ein Array von Zeichenketten entgegennehmen:
Sub main(ByVal args() As String)
Der Parameter „args“ ist ein Array von Zeichenfolgen, das die beim Aufruf des Programms über die Befehlszeile übergebenen Argumente enthält.
- args.Length ist die Anzahl der Elemente des Arrays args
- args(i) ist das i-te Element des Arrays
Wenn das Programm P mit dem Befehl P arg0 arg1 … argn und wenn die Prozedur Main des Programms P wie folgt deklariert ist:
Sub main(ByVal args() As String)
dann gilt: arg(0) = „arg0“, arg(1) = „arg1“ … Hier ein Beispiel:
' Richtlinien
Option Strict On
Option Explicit On
' Namensräume
Imports System
Module arg
Sub main(ByVal args() As String)
' Anzahl der Argumente
console.out.writeline("Il y a " & args.length & " arguments")
Dim i As Integer
For i = 0 To args.Length - 1
Console.Out.WriteLine("argument n° " & i & "=" & args(i))
Next
End Sub
End Module
Die Ausführung liefert folgende Ergebnisse:
2.9. Aufzählungen
Eine Aufzählung ist ein Datentyp, dessen Wertebereich aus einer Menge ganzzahliger Konstanten besteht. Betrachten wir ein Programm, das Prüfungsnoten verwalten soll. Es gäbe fünf davon: Befriedigend, AssezBien, Gut, TrèsBien, Sehr gut. Man könnte dann eine Aufzählung für diese fünf Konstanten definieren:
Enum mention
Passable
AssezBien
Bien
TrésBien
Excellent
End Enum
Intern werden diese fünf Konstanten durch aufeinanderfolgende Ganzzahlen kodiert, beginnend mit 0 für die erste Konstante, 1 für die nächste usw. Eine Variable kann so deklariert werden, dass sie diese Werte aus der Aufzählung annimmt:
' eine Variable, deren Werte aus der angegebenen Aufzählung stammen
Dim maMention As mention = mention.Passable
Eine Variable kann mit den verschiedenen möglichen Werten der Aufzählung verglichen werden:
' Prüfung mit einem Wert aus der Aufzählung
If (maMention = mention.Passable) Then
Console.Out.WriteLine("Peut mieux faire")
End If
Man kann alle Werte der Aufzählung abrufen:
For Each m In mention.GetValues(maMention.GetType)
Console.Out.WriteLine(m)
Next
Genauso wie der einfache Typ Integer der Struktur Int32 entspricht, entspricht der einfache Typ Enum der Struktur Enum. Diese Klasse verfügt über eine statische Methode GetValues, mit der alle Werte eines Aufzählungstyps abgerufen werden können, der als Parameter übergeben wird. Dieser muss ein Objekt vom Typ „Type“ sein, bei dem es sich um eine Klasse handelt, die Informationen über den Datentyp enthält. Der Typ einer Variablen v wird über v.GetType() ermittelt. Hier liefert also maMention.GetType() das Objekt Type der Aufzählung mentions und Enum.GetValues(maMention.GetType()) die Liste der Werte der Aufzählung mentions.
Dies zeigt das folgende Programm:
' Anweisungen
Option Strict On
Option Explicit On
' Namensräume
Imports System
Public Module enum2
' eine Aufzählung
Enum mention
Passable
AssezBien
Bien
TrèsBien
Excellent
End Enum
' Test-Seite
Sub Main()
' eine Variable, deren Werte aus der genannten Aufzählung stammen
Dim maMention As mention = mention.Passable
' Anzeige des Variablenwerts
Console.Out.WriteLine("mention=" & maMention)
' Test mit einem Wert aus der Aufzählung
If (maMention = mention.Passable) Then
Console.Out.WriteLine("Peut mieux faire")
End If
' Liste der Literalangaben
For Each m As mention In [Enum].GetValues(maMention.GetType)
Console.Out.WriteLine(m.ToString)
Next
' Liste der vollständigen Bezeichnungen
For Each m As Integer In [Enum].GetValues(maMention.GetType)
Console.Out.WriteLine(m)
Next
End Sub
End Module
Die Ausführungsergebnisse lauten wie folgt:
dos>enum2
mention=0
Peut mieux faire
Passable
AssezBien
Bien
TrèsBien
Excellent
0
1
2
3
4
2.10. Ausnahmebehandlung
Zahlreiche Funktionen von VB.NET können Ausnahmen, d. h. Fehler, auslösen. Wenn eine Funktion eine Ausnahme auslösen kann, sollte der Programmierer diese behandeln, um fehlerresistentere Programme zu erhalten: Ein unkontrollierter „Absturz“ einer Anwendung ist stets zu vermeiden.
Die Behandlung einer Ausnahme erfolgt nach folgendem Schema:
try
appel de la fonction susceptible de générer l'exception
catch e as Exception e)
traiter l'exception e
end try
instruction suivante
Wenn die Funktion keine Ausnahme auslöst, wird zur nächsten Anweisung übergegangen; andernfalls wird in den Hauptteil der Klausel catch verzweigt und anschließend zur nächsten Anweisung übergegangen. Beachten Sie folgende Punkte:
- e ist ein vom Typ Exception abgeleitetes Objekt. Man kann genauer sein, indem man Typen wie IOException, SystemException usw. verwendet: Es gibt mehrere Ausnahmetypen. Mit der Anweisung „catch e as Exception“ geben wir an, dass wir alle Ausnahmetypen behandeln wollen. Wenn der Code der Klausel try mehrere Ausnahmetypen erzeugen kann, möchten wir möglicherweise genauer vorgehen und die Ausnahme mit mehreren Klauseln vom Typ catch behandeln:
try
appel de la fonction susceptible de générer l'exception
catch e as IOException
traiter l'exception e
catch e as SystemException
traiter l'exception e
end try
instruction suivante
- Den Klauseln try/catch kann eine „finally“-Klausel hinzugefügt werden:
try
appel de la fonction susceptible de générer l'exception
catch e as Exception
traiter l'exception e
finally
code exécuté après try ou catch
end try
instruction suivante
Unabhängig davon, ob eine Ausnahme vorliegt oder nicht, wird der Code der Klausel finally immer ausgeführt.
- In der Klausel catch möchte man möglicherweise das verfügbare Objekt Exception nicht verwenden. Anstatt „catch e as Exception“ zu schreiben, schreibt man dann catch.
- Die Klasse Exception verfügt über eine Eigenschaft „Message“, die eine Meldung enthält, in der der aufgetretene Fehler näher beschrieben wird. Um diese anzuzeigen, schreibt man also:
catch e as Exception
Console.Error.WriteLine("L'erreur suivante s'est produite : "+e.Message);
...
end try
- Die Klasse Exception verfügt über eine Methode ToString, die eine Zeichenkette zurückgibt, die den Typ der Ausnahme sowie den Wert der Eigenschaft Message angibt. Man kann also Folgendes schreiben:
catch ex as Exception
Console.Error.WriteLine("L'erreur suivante s'est produite : "+ex.ToString)
...
end try
Das folgende Beispiel zeigt eine Ausnahme, die durch die Verwendung eines nicht vorhandenen Array-Elements ausgelöst wird:
' Optionen
Option Explicit On
Option Strict On
' Namensräume
Imports System
Module tab1
Sub Main()
' Deklaration und Initialisierung eines Arrays
Dim tab() As Integer = {0, 1, 2, 3}
Dim i As Integer
' Anzeige eines Arrays mit einer „for“-Schleife
For i = 0 To tab.Length - 1
Console.Out.WriteLine(("tab[" & i & "]=" & tab(i)))
Next i
' Ausgabe eines Arrays mit einer „for each“-Schleife
Dim élmt As Integer
For Each élmt In tab
Console.Out.WriteLine(élmt)
Next élmt
' Auslösen einer Ausnahme
Try
tab(100) = 6
Catch e As Exception
Console.Error.WriteLine(("L'erreur suivante s'est produite : " & e.Message))
End Try
End Sub
End Module
Die Ausführung des Programms liefert folgende Ergebnisse:
dos>exception1
tab[0]=0
tab[1]=1
tab[2]=2
tab[3]=3
0
1
2
3
L'erreur suivante s'est produite : L'index se trouve en dehors des limites du tableau.
Hier ist ein weiteres Beispiel, in dem die Ausnahme behandelt wird, die durch die Zuweisung einer Zeichenkette zu einer Zahl ausgelöst wird, wenn die Zeichenkette keine Zahl darstellt:
' Optionen
Option Strict On
Option Explicit On
'Importe
Imports System
Public Module console1
Public Sub Main()
' Der Name wird abgefragt
System.Console.Write("Nom : ")
' Antwort auslesen
Dim nom As String = System.Console.ReadLine()
' Nach dem Alter wird gefragt
Dim age As Integer
Dim ageOK As Boolean = False
Do While Not ageOK
' Frage
Console.Out.Write("âge : ")
' Antwort lesen und überprüfen
Try
age = Int32.Parse(System.Console.ReadLine())
If age < 0 Then Throw New Exception
ageOK = True
Catch
Console.Error.WriteLine("Age incorrect, recommencez...")
End Try
Loop
' Endanzeige
Console.Out.WriteLine("Vous vous appelez [" & nom & "] et vous avez [" & age & "] ans")
End Sub
End Module
Einige Ausführungsergebnisse:
dos>console1
Nom : dupont
âge : xx
Age incorrect, recommencez...
âge : 12
Vous vous appelez dupont et vous avez 12 ans
2.11. Übergabe von Parametern an eine Funktion
Wir befassen uns hier mit der Art und Weise, wie Parameter an eine Funktion übergeben werden. Betrachten wir die Funktion:
Sub changeInt(ByVal a As Integer)
a = 30
Console.Out.WriteLine(("Paramètre formel a=" & a))
End Sub
In der Definition der Funktion wird a als formaler Parameter bezeichnet. Er dient ausschließlich der Definition der Funktion changeInt. Er hätte genauso gut b heißen können. Betrachten wir nun eine Verwendung dieser Funktion:
Sub Main()
Dim age As Integer = 20
changeInt(age)
Console.Out.WriteLine(("Paramètre effectif age=" & age))
End Sub
Hier in der Anweisung changeInt(age) ist age der effektive Parameter, der seinen Wert an den formalen Parameter a übergibt. Uns interessiert, wie ein formaler Parameter den Wert des ihm zugeordneten effektiven Parameters übernimmt.
2.11.1. Wertübergabe
Das folgende Beispiel zeigt, dass die Parameter einer Funktion/Prozedur standardmäßig per Wert übergeben werden: Das bedeutet, dass der Wert des effektiven Parameters in den entsprechenden formalen Parameter kopiert wird. Es handelt sich um zwei getrennte Einheiten. Wenn die Funktion den formalen Parameter ändert, bleibt der effektive Parameter davon unberührt.
' Optionen
Option Explicit On
Option Strict On
' Übergabe von Parametern als Wert an eine Funktion
Imports System
Module param1
Sub Main()
Dim age As Integer = 20
changeInt(age)
Console.Out.WriteLine(("Paramètre effectif age=" & age))
End Sub
Sub changeInt(ByVal a As Integer)
a = 30
Console.Out.WriteLine(("Paramètre formel a=" & a))
End Sub
End Module
Die Ergebnisse lauten wie folgt:
Der Wert 20 des effektiven Parameters wurde in den formalen Parameter a kopiert. Dieser wurde anschließend geändert. Der effektive Parameter blieb hingegen unverändert. Diese Übergabemethode eignet sich für Eingabeparameter einer Funktion.
2.11.2. Übergabe per Referenz
Bei der Übergabe per Referenz sind der effektive Parameter und der formale Parameter ein und dasselbe. Wenn die Funktion den formalen Parameter ändert, wird auch der effektive Parameter geändert. Bei VB.NET muss dem formalen Parameter das Schlüsselwort ByRef vorangestellt werden. Hier ein Beispiel:
' Optionen
Option Explicit On
Option Strict On
' Übergabe von Parametern als Wert an eine Funktion
Imports System
Module param2
Sub Main()
Dim age As Integer = 20
changeInt(age)
Console.Out.WriteLine(("Paramètre effectif age=" & age))
End Sub
Sub changeInt(ByRef a As Integer)
a = 30
Console.Out.WriteLine(("Paramètre formel a=" & a))
End Sub
End Module
und die Ausführungsergebnisse:
Der effektive Parameter wurde entsprechend der Änderung des formalen Parameters angepasst. Diese Übergabemethode eignet sich für Ausgabeparameter einer Funktion.