2. Grundlagen der Sprache VB.NET

2.1. Einführung

Zunächst betrachten wir VB.NET als eine traditionelle Programmiersprache. Auf Objekte gehen wir später ein.

In einem Programm gibt es zwei Dinge

Daten
die Anweisungen, die sie bearbeiten

Im Allgemeinen versuchen wir, Daten von Anweisungen zu trennen:

2.2. VB.NET-Daten

VB.NET verwendet die folgenden Datentypen:

Ganzzahlen, reelle Zahlen und Dezimalzahlen

Zeichen und Zeichenfolgen
Boolesche Werte
Datumsangaben
Objekte

2.2.1. Vordefinierte Datentypen

VB-Typ	Entsprechender .NET-Typ	Größe	Wertebereich
Boolean	System.Boolean	2 Byte	True oder False.
Byte	System.Byte	1 Byte	0 bis 255 (vorzeichenlos).
Char	System.Char	2 Bytes	0 bis 65.535 (vorzeichenlos).
Date	System.DateTime	8 Byte	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; wobei die kleinste Zahl ungleich Null +/-0,0000000000000000000000000001 (+/-1E-28) ist.
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.
Integer	System.Int32	4 Byte	-2.147.483.648 bis 2.147.483.647.
Long	System.Int64	8 Byte	-9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807.
Objekt	System.Object	4 Byte	In einer Variablen vom Typ „Object“ kann jeder beliebige Typ gespeichert werden.
Short	System.Int16	2 Bytes	-32.768 bis 32.767.
Single	System.Single	4 Byte	-3,402823E+38 bis -1,401298E-45 für negative Werte; 1,401298E-45 bis 3,402823E+38 für positive Werte.
String	System.String (Klasse)		0 bis ca. 2 Milliarden Unicode-Zeichen.

In der obigen Tabelle sehen wir, dass es zwei mögliche Typen für eine 32-Bit-Ganzzahl gibt: Integer und System.Int32. Die beiden Typen sind austauschbar. Dasselbe gilt für andere VB-Typen und ihre Entsprechungen in der .NET-Plattform. Hier ist ein Beispielprogramm:


Module types
    Sub Main()
        ' whole numbers
        Dim var1 As Integer = 100
        Dim var2 As Long = 10000000000L
        Dim var3 As Byte = 100
        Dim var4 As Short = 4
        ' real numbers
        Dim var5 As Decimal = 4.56789D
        Dim var6 As Double = 3.4
        Dim var7 As Single = -0.000103F
        ' date
        Dim var8 As Date = New Date(2003, 1, 1, 12, 8, 4)
        ' boolean
        Dim var9 As Boolean = True
        ' character
        Dim var10 As Char = "A"c
        ' character string
        Dim var11 As String = "abcde"
        ' object
        Dim var12 As Object = New Object
        ' displays
        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. Literal-Notation

`Ganzzahl`	145, -7, &FF (hexadezimal)
`Long`	100000L
`Double`	134,789, -45E-18 (-45 × 10⁻¹⁸)
`Einfach`	134,789F, -45E-18F (-45 × 10⁻¹⁸)
`Dezimal`	100000D
`Zeichen`	"A"c
`Zeichenkette`	"today"
`Boolesche Variable`	wahr, falsch
`Datum`	New Date(2003, 1, 1) für den 01.01.2003

Beachten Sie folgende Punkte:

100000L, wobei L angibt, dass die Zahl als Long-Integer behandelt wird
134,789F, wobei F angibt, dass die Zahl als Gleitkommazahl mit einfacher Genauigkeit behandelt wird
100000D, wobei D angibt, dass die Zahl als dezimale reelle Zahl behandelt wird
"A"c, um die Zeichenkette "A" in das Zeichen 'A' zu konvertieren
Die Zeichenkette wird in das Zeichen „.“ eingeschlossen. Wenn die Zeichenkette das Zeichen „“ enthalten muss, wird es verdoppelt, wie in „abcd“„e“, um die Zeichenkette [abcd“e] darzustellen.

2.2.3. Datendeklaration

2.2.3.1. Rolle von Deklarationen

Ein Programm verarbeitet Daten, die durch einen Namen und einen Typ gekennzeichnet sind. Diese Daten werden im Speicher abgelegt. Bei der Kompilierung des Programms weist der Compiler jedem Datenelement einen Speicherplatz zu, der durch eine Adresse und eine Größe gekennzeichnet ist. Dies geschieht anhand der vom Programmierer vorgenommenen Deklarationen. Darüber hinaus ermöglichen diese Deklarationen dem Compiler, Programmierfehler zu erkennen. So wird beispielsweise die Operation x = x \* 2 als Fehler deklariert, wenn x eine Zeichenkette ist.

2.2.3.2. Deklaration von Konstanten

Die Syntax für die Deklaration einer Konstante lautet wie folgt:

const Bezeichner as Typ=Wert

Beispiel: [const PI as double=3.141592]. Warum Konstanten deklarieren?

Das Programm ist leichter zu lesen, wenn die Konstante einen aussagekräftigen Namen erhält: [const VAT_rate as single=0.186F]
Das Programm lässt sich leichter ändern, wenn die „Konstante“ angepasst werden muss. Wenn sich im vorigen Fall der Mehrwertsteuersatz auf 33 % ändert, muss lediglich die Anweisung geändert werden, die den Wert definiert: [const vatrate as single=0.336F]. Wäre 0.186 explizit im Programm verwendet worden, müssten zahlreiche Anweisungen geändert werden.

2.2.3.3. Variablendeklaration

Eine Variable wird durch einen Namen identifiziert und bezieht sich auf einen Datentyp. VB.NET unterscheidet nicht zwischen Groß- und Kleinbuchstaben. Daher sind die Variablen FIN und fin identisch. Variablen können bei ihrer Deklaration initialisiert werden. Die Syntax zum Deklarieren einer oder mehrerer Variablen lautet:

dim variable1,variable2,...,variablen as type_identifier

wobei typ_bezeichner ein vordefinierter Typ oder ein vom Programmierer definierter Typ ist.

2.2.4. Konvertierungen zwischen Zahlen und Zeichenfolgen

`Zahl -> Zeichenkette`	number.ToString oder "" & number oder CType(number, String)
`Objekt -> Zeichenfolge`	Objekt.ToString
`Zeichenkette -> Ganzzahl`	Integer.Parse(Zeichenkette) oder Int32.Parse
`Zeichenfolge -> Long`	Long.Parse(Zeichenkette) oder Int64.Parse
`Zeichenkette -> Double`	Double.Parse(string)
`Zeichenkette -> Single`	Single.Parse(string)

Die Umwandlung einer Zeichenfolge in eine Zahl kann fehlschlagen, wenn die Zeichenfolge keine gültige Zahl darstellt. Dies führt zu einem schwerwiegenden Fehler, der in VB.NET als Ausnahme bezeichnet wird. Dieser Fehler kann mithilfe des folgenden try/catch-Blocks abgefangen 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, fahren wir mit der nächsten Anweisung fort; andernfalls springen wir in den Körper der catch-Klausel und fahren dann mit der nächsten Anweisung fort. Wir werden später auf die Ausnahmebehandlung zurückkommen. Hier ist ein Programm, das die wichtigsten Techniken zur Konvertierung zwischen Zahlen und Zeichenketten demonstriert. In diesem Beispiel gibt die Funktion display den Wert ihres Parameters auf dem Bildschirm aus. Somit gibt display(S) den Wert von S auf dem Bildschirm aus.


' guidelines
Option Strict On
 
' imported namespaces
Imports System
 
' the test module
Module Module1
 
    Sub Main()
        ' main proceedings
        ' local data
        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
 
        ' number --> string
        affiche(CType(i, String))
        affiche(CType(l, String))
        affiche(CType(f, String))
        affiche(CType(d, String))
 
        'boolean --> string
        Const b As Boolean = False
        affiche(b.ToString)
 
        ' string --> 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
 
        ' chain --> 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
 
        ' chain --> 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
 
        ' chain --> 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
 
    ' poster
    Public Sub affiche(ByVal S As String)
        Console.Out.WriteLine("S=" + S)
    End Sub
End Module

Die Ergebnisse lauten wie folgt:

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 Zeichenfolgenform ein Komma und keinen Dezimalpunkt verwenden müssen. Daher schreiben wir Dim d As Double = -14.98, aber Dim d1 As Double = Double.Parse("100.87")

2.2.5. Daten-Arrays

Ein VB.NET-Array ist ein Objekt, mit dem Daten desselben Typs unter einem einzigen 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 Array(i) bezieht sich auf die Daten am Index i, wobei i zum Bereich [0,n] gehört. Jeder Verweis auf die Daten Array(i), bei dem i nicht zum Bereich [0,n] gehört, löst eine Ausnahme aus. Ein Array kann gleichzeitig mit seiner Deklaration initialisiert werden. In diesem Fall muss der Index des letzten Elements nicht angegeben werden.


        Dim entiers() As Integer = {0, 10, 20, 30}

Arrays verfügen über eine Length-Eigenschaft, die die Anzahl der Elemente im Array angibt. Hier ist ein Beispielprogramm:


Module tab0
    Sub Main()
        ' a first picture
        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
 
        ' a second panel
        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 dessen 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 Array(n, m) As Typ oder Dim Array(,) As Typ = New Typ(n, m) {}

wobei n+1 die Anzahl der Zeilen und m+1 die Anzahl der Spalten ist. Die Syntax Array(i,j) bezieht sich auf das Element j in Zeile i von Array. Das zweidimensionale Array kann auch gleichzeitig mit seiner Deklaration initialisiert werden:


        Dim réels(,) As Double = {{0.5, 1.7}, {8.4, -6}}

Die Anzahl der Elemente in jeder Dimension kann mit der Methode GetLength(i) ermittelt werden, wobei i=0 die dem ersten Index entsprechende Dimension, i=1 die dem zweiten Index entsprechende Dimension usw. darstellt. Hier ist ein Beispielprogramm:


Module Module2
    Sub Main()
        ' a first picture
        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
 
        ' a second panel
        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 der 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 Array(i) ist eine Referenz auf ein eindimensionales Array. Diese Arrays werden bei der obigen Deklaration nicht erstellt. Das folgende Beispiel veranschaulicht die Erstellung eines Arrays von Arrays:


        ' a table of tables
        Dim noms()() As String = New String(3)() {}
        ' initialization
        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 names(i) ein Array mit i+1 Elementen. Da names(i) ein Array ist, gibt names(i).Length die Anzahl der darin enthaltenen Elemente an. Hier ist ein Beispiel, das die drei gerade besprochenen Array-Typen kombiniert:


' guidelines
Option Strict On
Option Explicit On 
 
' imports
Imports System
 
' test class
Module test
    Sub main()
        ' an initialized 1-dimensional 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
 
        ' an initialized 2-dimensional 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
 
        ' an array°of arrays
        Dim noms()() As String = New String(3)() {}
 
        ' initialization
        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
 
        ' display
        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. Grundlegende VB.NET-Anweisungen

Wir unterscheiden zwischen

1 die grundlegenden Anweisungen, die vom Computer ausgeführt werden.

2 Anweisungen, die den Programmablauf steuern.

Grundlegende Befehle werden verständlich, wenn man die Struktur eines Mikrocomputers und seiner Peripheriegeräte betrachtet.

Einlesen von Informationen über die Tastatur
Informationsverarbeitung
Schreiben von Informationen auf den Bildschirm
Lesen von Informationen aus einer Datei
Schreiben von Informationen in eine Datei

2.3.1. Schreiben auf den Bildschirm

Es gibt verschiedene Befehle zum Schreiben auf den Bildschirm:

Console.Out.WriteLine(expression)
Console.WriteLine(expression)
Console.Error.WriteLine (expression)

wobei Ausdruck ein beliebiger Datentyp ist, der in eine Zeichenfolge konvertiert werden kann, um auf dem Bildschirm angezeigt zu werden. In den bisher gezeigten Beispielen haben wir nur die Anweisung Console.Out.WriteLine(Ausdruck) verwendet.

Die Klasse „System.Console“ bietet Zugriff auf Funktionen zum Schreiben auf den Bildschirm (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 normalerweise mit dem Bildschirm verknüpft ist.
Console.Error.WriteLine() schreibt in den Error-Stream, der ebenfalls in der Regel mit dem Bildschirm verknüpft ist.

Die Streams „Out“ und „Error“ sind standardmäßig mit dem Bildschirm verknüpft. Sie können jedoch zur Laufzeit in Textdateien umgeleitet werden, wie wir gleich sehen werden.

2.3.2. Lesen von über die Tastatur eingegebenen Daten

Der Datenstrom von der Tastatur wird durch das Console.In-Objekt vom Typ StreamReader dargestellt. Mit diesem Objekttyp können Sie mithilfe der ReadLine-Methode eine Textzeile lesen:


        Dim ligne As String = Console.In.ReadLine()

Die über die Tastatur eingegebene Zeile wird in der Variablen line* gespeichert und kann dann vom Programm verwendet werden. Der In-Stream kann genau wie die Out- und Error*-Streams in eine Datei umgeleitet werden.

2.3.3. Beispiel für Ein- und Ausgabe

Hier ist ein kurzes Programm, das Eingabe- und Ausgabeoperationen über Tastatur und Bildschirm veranschaulicht:


' options
Option Explicit On 
Option Strict On
 
' namespaces
Imports System
 
' module
Module io1
    Sub Main()
        ' write to Out feed
        Dim obj As New Object
        Console.Out.WriteLine(("" & obj.ToString))
 
        ' write to the Error stream
        Dim i As Integer = 10
        Console.Error.WriteLine(("i=" & i))
 
        ' reading a line entered on the keyboard
        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:

System.Object
i=10
Tapez une ligne : ceci est un essai
ligne=ceci est un essai

Die Anleitung


        Dim obj As New Object
        Console.Out.WriteLine(obj.ToString)

dienen lediglich dazu, zu zeigen, dass jedes Objekt angezeigt werden kann. Wir werden hier nicht versuchen, die Bedeutung des Angezeigten zu erklären.

2.3.4. E/A-Umleitung

Unter DOS/Windows gibt es drei Standard-Eingabegeräte mit den Namen:

Standard-Eingabegerät – bezieht sich standardmäßig auf die Tastatur und hat die Nummer 0
Standardausgabegerät – standardmäßig der Bildschirm und mit der Nummer 1
Standard-Ausgabegerät – bezieht sich standardmäßig auf den Bildschirm und hat die Nummer 2

In VB.NET schreibt der Ausgabestrom Console.Out auf Gerät 1, der Ausgabestrom Console.Error schreibt auf Gerät 2 und der Eingabestrom Console.In liest Daten von Gerät 0. Wenn Sie ein Programm in einem DOS-Fenster unter Windows ausführen, können Sie festlegen, welche Geräte für das laufende Programm die Nummern 0, 1 und 2 erhalten sollen. Betrachten Sie die folgende Befehlszeile:

pg arg1 arg2 .. argn

Nach den Argumenten argi des pg-Programms können Sie die Standard-E/A-Geräte in Dateien umleiten:

`0<in.txt`	Der Standardeingabestrom Nr. 0 wird in die Datei in.txt umgeleitet. Im Programm liest der Console.In-Strom daher seine Daten aus der Datei in.txt.
`1>out.txt`	leitet den Ausgabestrom Nr. 1 in die Datei „out.txt“ um. Das bedeutet, dass der „Console.Out“-Strom im Programm seine Daten in die Datei „out.txt“ schreibt
`1>>out.txt`	Wie oben, jedoch werden die geschriebenen Daten an den aktuellen Inhalt der Datei „out.txt“ angehängt.
`2>error.txt`	leitet die Ausgabe Nr. 2 in die Datei „error.txt“ um. Das bedeutet, dass im Programm der Stream „Console.Error“ seine Daten in die Datei „error.txt“ schreibt
`2>>error.txt`	Wie oben, jedoch werden die geschriebenen Daten an den aktuellen Inhalt der Datei „error.txt“ angehängt.
`1>out.txt 2>error.txt`	Die Geräte 1 und 2 werden beide in Dateien umgeleitet

Beachten Sie, dass das pg-Programm nicht geändert werden muss, um seine Ein- und Ausgabeströme in Dateien umzuleiten. Es ist das Betriebssystem, das die Art der Geräte 0, 1 und 2 festlegt. Betrachten Sie das folgende Programm:


' options
Option Explicit On 
Option Strict On
 
' namespaces
Imports System
 
' redirections
Module console2
    Sub Main()
        ' lecture flux In
        Dim data As String = Console.In.ReadLine()
        ' write Out feed
        Console.Out.WriteLine(("écriture dans flux Out : " + data))
        ' écriture flux Error
        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 es zum ersten Mal aus:

dos>es2.exe
un premier test
écriture dans flux Out : un premier test
écriture dans flux Error : un premier test

Die vorherige Ausführung leitet keinen der Standard-E/A-Streams In, Out oder Error um. Wir werden nun alle drei Streams umleiten. Der In-Stream wird in eine Datei namens in.txt umgeleitet, der Out-Stream in eine Datei namens out.txt und der Error-Stream in eine Datei namens error.txt. Diese Umleitung wird in der Befehlszeile wie folgt durchgeführt

dos>es2.exe 0<in.txt 1>out.txt 2>error.txt

Die Ausführung liefert die folgenden 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 klar, dass die Out- und Error-Streams nicht auf dieselben Geräte schreiben.

2.3.5. Zuweisung des Werts eines Ausdrucks an eine Variable

Hier interessiert uns die Operation variable=ausdruck. Der Ausdruck kann folgende Typen haben: arithmetisch, relational, boolesch oder Zeichenkette.

2.3.5.1. Liste der Operatoren

Aktion	Sprachelement
`Arithmetik`	^, –, *, /, \, Mod, +, =
`Zuweisung`	=, ^=, *=, /=, \=, +=, -=, &=
`Vergleich`	=, <>, <, >, <=, >=, Like, Is
`Verkettung`	&, +
`Logische/bitweise Operationen`	Nicht, Und, Oder, XOR, UndAuch, OderSonst
`Verschiedene Operationen`	AddressOf, GetType

2.3.5.2. Arithmetischer Ausdruck

Die Operatoren für arithmetische Ausdrücke lauten wie folgt:

Arithmetik

^, –, *, /, \, Mod, +, =

+: Addition, -: Subtraktion, *: Multiplikation, /: Gleitkommadivision, \: Quotient der ganzzahligen Division, Mod: Rest der ganzzahligen Division, ^: Potenzierung. Somit ergibt sich folgendes Programm:


' arithmetic operators
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:

4/3=1,33333333333333
4\3=1
4 mod 3=1
4,1/3,6=1,13888888888889
4,1^2=16,81
-0,989992496600445

Es gibt verschiedene mathematische Funktionen. Hier sind einige davon:

`Public Shared Function Sqrt(ByVal d As Double) As Double`	Quadratwurzel
`[Visual Basic] Öffentliche Shared-Funktion Cos(ByVal d As Double) As Double`	Kosinus
`Öffentliche Shared-Funktion Sin(ByVal a As Double) As Double`	Sinus
`[Visual Basic] Öffentliche gemeinsam genutzte Funktion Tan(ByVal a As Double) As Double`	Tangens
`[Visual Basic] Public Shared Function Pow(ByVal x As Double, ByVal y As Double) As Double`	x hoch y (x > 0)
`[Visual Basic] Public Shared Function Exp(ByVal d As Double) As Double`	Exponential
`[Visual Basic] Überladungen Public Shared Function Log( ByVal d As Double ) As Double`	Natürlicher Logarithmus
`Überladungen Public Shared Function Abs(ByVal value As Double) As Double`	Absolutwert
`....`

Alle diese Funktionen sind in einer .NET-Klasse namens Math definiert. Wenn Sie sie verwenden, müssen Sie ihnen den Namen der Klasse voranstellen, in der sie definiert sind. Sie würden also schreiben:

        Dim r1, r2 As Double
        r2 = Math.Sqrt(9)
        r1 = Math.Cos(3)

Die vollständige Definition der Math-Klasse lautet wie folgt:

`E`	Stellt den natürlichen Logarithmus zur Basis e dar, die durch die Konstante e angegeben wird.
`PI`	Bezeichnet das Verhältnis des Umfangs eines Kreises zu seinem Durchmesser, das durch die Konstante π angegeben wird.
`Abs`	Überladen. Gibt den Absolutwert einer angegebenen Zahl zurück.
`Acos`	Gibt den Winkel zurück, dessen Kosinus die angegebene Zahl ist.
`Asin`	Gibt den Winkel zurück, dessen Sinus der angegebene Wert ist.
`Atan`	Gibt den Winkel zurück, dessen Tangens der angegebene Wert ist.
`Atan2`	Gibt den Winkel zurück, dessen Tangens der Quotient aus zwei angegebenen Zahlen ist.
`BigMul`	Erzeugt das ganzzahlige Produkt zweier 32-Bit-Zahlen.
`Ceiling`	Gibt die kleinste ganze Zahl zurück, die größer oder gleich der angegebenen Zahl ist.
`Cos`	Gibt den Kosinus des angegebenen Winkels zurück.
`Cosh`	Gibt den hyperbolischen Kosinus des angegebenen Winkels zurück.
`DivRem`	Überladen. Gibt den Quotienten zweier Zahlen zurück und übergibt den Rest als Ausgabeparameter.
`Exp`	Gibt e hoch der angegebenen Potenz zurück.
`Floor`	Gibt die größte ganze Zahl zurück, die kleiner oder gleich der angegebenen Zahl ist.
`IEEE-Rest`	Gibt den Rest der Division einer Zahl durch eine andere zurück.
`Log`	Überladen. Gibt den Logarithmus einer angegebenen Zahl zurück.
`Log10`	Gibt den Logarithmus zur Basis 10 einer angegebenen Zahl zurück.
`Max`	Überladen. Gibt die größere der beiden angegebenen Zahlen zurück.
`Min`	Überladen. Gibt die kleinere der beiden Zahlen zurück.
`Pow`	Gibt eine angegebene Zahl zur angegebenen Potenz zurück.
`Round`	Überladen. Gibt die Zahl zurück, die dem angegebenen Wert am nächsten liegt.
`Vorzeichen`	Überladen. Gibt einen Wert zurück, der das Vorzeichen einer Zahl angibt.
`Sin`	Gibt den Sinus des angegebenen Winkels zurück.
`Sinh`	Gibt den hyperbolischen Sinus des angegebenen Winkels zurück.
`Sqrt`	Gibt die Quadratwurzel einer angegebenen Zahl zurück.
`Tan`	Gibt den Tangens des angegebenen Winkels zurück.
`Tanh`	Gibt den hyperbolischen Tangens des angegebenen Winkels zurück.

Wenn eine Funktion als „überladen“ deklariert 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 Abs-Funktion. Man spricht dann von einer überladenen Funktion.

2.3.5.3. Operatoren bei der Auswertung arithmetischer Ausdrücke

Die Operatorpriorität bei der Auswertung eines arithmetischen Ausdrucks ist wie folgt (von der höchsten zur niedrigsten):

Kategorie	Operatoren
`Primär`	Alle Ausdrücke ohne Operatoren: Funktionen, Klammern
`Potenzieren`	^
`Unäre Negation`	+, -
`Multiplikation`	*, /
`Division durch eine ganze Zahl`	\
`Modulo`	Mod
`Addition`	+, -

2.3.5.4. Relationale Ausdrücke

Es gibt folgende Operatoren:

Vergleich

=, <>, <, >, <=, >=, 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 denselben Vorrang. Sie werden von links nach rechts ausgewertet. Das Ergebnis eines relationalen Ausdrucks ist ein Boolescher Wert.

Zeichenfolgenvergleich: Betrachten Sie das folgende Programm:


' namespaces
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 der Ausführung:

A<B=True
A<a=True
chat<chien=True
chat<chaton=True
chat<CHAT=False
chaton like chat*=True

Es seien zwei Zeichen C1 und C2 gegeben. Sie können mit den Operatoren <, <=, =, <>, >, >= verglichen werden. Verglichen werden ihre Unicode-Werte – also Zahlen. Gemäß der Unicode-Reihenfolge gelten die folgenden Beziehungen:

Leerzeichen < .. < '0' < '1' < .. < '9' < .. < 'A' < 'B' < .. < 'Z' < .. < 'a' < 'b' < .. < 'z'

Zeichenketten werden Zeichen für Zeichen verglichen. Die erste Ungleichheit, auf die man zwischen zwei Zeichen stößt, impliziert eine Ungleichheit gleichen Vorzeichens für die Zeichenketten. Mit diesen Erläuterungen sei der Leser eingeladen, die Ergebnisse des vorherigen Programms zu untersuchen.

2.3.5.5. Boolesche Ausdrücke

Die Operatoren lauten wie folgt:

Logische/bitweise Operationen

Nicht, Und, Oder, XOR, UndAuch, OderSonst

Nicht: logisches UND, Oder: logisches ODER, Nicht: 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 Rangfolge dieser Operatoren zueinander ist wie folgt:

`Logisches NOT`	Logisches NICHT
`Logisches UND`	Und, Und-Auch
`Logisches ODER`	ODER, OrElse
`Logisches XOR`	XOR

Das Ergebnis eines booleschen Ausdrucks ist ein Boolescher Wert.

2.3.5.6. Bitweise Operationen

Einerseits finden wir 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.

`i<<n`	verschiebt i um n Bits nach links. Die eingehenden Bits sind Nullen.
`i>>n`	verschiebt i um n Bits nach rechts. Wenn i eine vorzeichenbehaftete Ganzzahl ist (signed char, int, long), bleibt das Vorzeichenbit erhalten.
`i & j`	führt eine bitweise logische UND-Verknüpfung von i und j durch.
`i \| j`	führt eine bitweise ODER-Operation auf i und j aus.
`~i`	komplementiert i zu 1
`i^j`	führt die XOR-Operation von i und j durch

Betrachten Sie das folgende Programm:


Module operationsbit
    Sub main()
        ' bit manipulation
        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

Die Ausführung liefert folgende Ergebnisse:

i<<4=23F0
i>>4=123
k>>4=712
i and 4=4
i or k =123F
not i=EDC0

2.3.5.7. Mit der Zuweisung verbundener Operator

Es ist möglich, a+=b zu schreiben, was a=a+b bedeutet. Die Liste der Operatoren, die mit der Zuweisungsoperation kombiniert werden können, lautet wie folgt:

Kombination von Operatoren

^=, *=, /=, \=, +=, -=, &=

2.3.5.8. Allgemeine Operatorpriorität

Kategorie	Operatoren
`Primär`	Alle Ausdrücke ohne Operatoren
`Potenzierung`	^
`Unäre Negation`	+, -
`Multiplikation`	*, /
`Division durch eine ganze Zahl`	\
`Modulo`	Mod
`Addition`	+, -
`Verkettung`	&
`Verschiebung`	<<, >>
`Relational`	=, <>, <, >, <=, >=, Like, Is, TypeOf...Is
`Logisch NOT`	Nicht
`Logisches UND`	Und, UndAuch
`Logisches ODER`	ODER, OrElse
`Logisches XOR`	XOR

Wenn ein Operand zwischen zwei Operatoren gleicher Priorität steht, bestimmt die Assoziativität der Operatoren die Reihenfolge, in der die Operationen ausgeführt werden. Alle Operatoren sind linksassoziativ, was bedeutet, dass 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 Sie von einem Datentyp in einen anderen konvertieren können. Die Liste lautet wie folgt:

CBool,CByte,CChar,CDate,CDbl,CDec,CInt,CLng,CObj,CShort,CSng,CStr

Diese Funktionen akzeptieren einen numerischen Ausdruck oder eine Zeichenfolge als Argument. Der Ergebnistyp ist in der folgenden Tabelle aufgeführt:

Funktion	Ergebnis	Wertebereich des Funktionsparameters
`CBool`	Boolescher Wert	Jeder gültige Zeichenfolgen- oder numerische Ausdruck.
`CByte`	Byte	0 bis 255; Bruchteile werden gerundet.
`CChar`	Char	Jeder gültige String-Ausdruck; der Wert kann zwischen 0 und 65.535 liegen.
`CDate`	Date	Jede gültige Darstellung von Datum und Uhrzeit.
`CDbl`	Double	-1,79769313486231E+308 bis -4,94065645841247E-324 für negative Werte; 4,94065645841247E-324 bis 1,79769313486231E+308 für positive Werte.
`CDec`	Dezimal	+/-79.228.162.514.264.337.593.543.950.335 für nicht-dezimale Zahlen. Der Wertebereich für 28-stellige Dezimalzahlen beträgt +/-7,9228162514264337593543950335. Die kleinste Zahl ungleich Null ist 0,0000000000000000000000000001.
`CInt`	Ganzzahl	-2.147.483.648 bis 2.147.483.647; Bruchteile werden gerundet.
`CLng`	Long	-9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807; Bruchteile werden gerundet.
`CObj`	Objekt	Jeder gültige Ausdruck.
`CShort`	Short	-32.768 bis 32.767; Bruchteile werden gerundet.
`CSng`	Einzeln	-3,402823E+38 bis -1,401298E-45 für negative Werte; 1,401298E-45 bis 3,402823E+38 für positive Werte.
`CStr`	Zeichenkette	Die von der Funktion Cstr zurückgegebenen Werte hängen vom Argument „expression“ ab.

Hier ist 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 der 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

Sie können auch die Funktion CType(Ausdruck, Typ) verwenden, wie im folgenden Programm gezeigt:


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 der Programmausführung

2.4.1. Stopp

Mit der in der Klasse „Environment“ definierten Methode „Exit“ können Sie die Ausführung eines Programms anhalten:


[Visual Basic]
Public Shared Sub Exit(ByVal exitCode As Integer )

beendet den aktuellen Prozess und gibt den Wert von exitCode an den übergeordneten Prozess zurück. Der Wert von exitCode kann vom übergeordneten Prozess verwendet werden. Unter DOS wird diese Statusvariable in der Systemvariablen ERRORLEVEL an DOS zurückgegeben, deren Wert in einer Batch-Datei überprüft werden kann. Unter Unix ruft die Variable $? den Wert von exitCode ab.

    Environment.Exit(0)

beendet das Programm mit einem Exit-Status von 0.

2.4.2. Einfache Entscheidungsstruktur

if condition then
    actions_alors
else
    actions_sinon
end if

Jede Aktion steht in einer eigenen Zeile
Die else-Klausel kann weggelassen werden.

Sie können Entscheidungsstrukturen wie im folgenden Beispiel gezeigt verschachteln:


' options
Option Explicit On 
Option Strict On
 
' namespaces
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 erzielte Ergebnis:

10 est > 4

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 [Ausdruck] muss einer der folgenden Typen sein:

Boolean, Byte, Char, Date, Decimal, Double, Integer, Long, Object, Short, Single et String

Die Klausel [case else] kann weggelassen werden.
[list_of_values] sind mögliche Werte des Ausdrucks. [lists_of_values] stellt eine Liste von Bedingungen condition1, condition2, ..., conditionx dar. Wenn [expression] eine der Bedingungen erfüllt, werden die auf die [list_of_values]-Klausel folgenden Aktionen ausgeführt. Die Bedingungen können folgende Form annehmen:
val1 bis val2: wahr, wenn [Ausdruck] im Bereich [val1,val2] liegt
val1: wahr, wenn [Ausdruck] gleich val1 ist
ist > val1: wahr, wenn [Ausdruck] > val1 ist. Das Schlüsselwort [ist] kann weggelassen werden
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 Sie das folgende Programm:


' options
Option Explicit On 
Option Strict On
 
' namespaces
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

Dies führt zu folgenden Ergebnissen:

i est < 15

2.4.4. Schleifenstruktur

2.4.4.1. Bekannte Anzahl von Iterationen


For counter [ As datatype ] = start To end [ Step step ]
   actions
Next [ counter ]

Aktionen werden für jeden Wert der Variablen [Zähler] ausgeführt. Betrachten Sie das folgende Programm:


' options
Option Explicit On 
Option Strict On

' namespaces
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:

somme( 0 2 4 6 8 10)=30

Eine weitere Iterationsstruktur mit einer bekannten Anzahl von Iterationen sieht wie folgt aus:


For Each element [ As datatype ] In groupe
   [ actions ]
Next [ element ]

Eine Gruppe ist eine Sammlung von Objekten. Die uns bereits bekannte Sammlung von Objekten ist das Array
Der Datentyp 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 die Werte der Sammlung annimmt.

Daher gilt für den folgenden Code:


' options
Option Explicit On 
Option Strict On
 
' namespaces
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:

paul
hélène
jacques
sylvie

2.4.4.2. Anzahl der Wiederholungen unbekannt

In VB.NET gibt es für diesen Fall viele Strukturen.


Do { While | Until } condition
   [ statements ]
Loop

Die Schleife wird so lange fortgesetzt, wie die Bedingung wahr ist (while) oder bis die Bedingung wahr ist (until). Die Schleife wird möglicherweise nie ausgeführt.


Do
   [ statements ]
Loop { While | Until } condition

Die Schleife wird so lange fortgesetzt, wie die Bedingung wahr ist (while) oder bis die Bedingung wahr ist (until). Die Schleife wird immer mindestens einmal ausgeführt.


While condition
   [ statements ]
End While

Die Schleife wird so lange fortgesetzt, wie die Bedingung wahr ist. Die Schleife wird möglicherweise nie ausgeführt. Die folgenden Schleifen berechnen alle die Summe der ersten 10 ganzen Zahlen.


' options
Option Explicit On 
Option Strict On
 
' namespaces
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

somme=55
somme=55
somme=55
somme=55

2.4.4.3. Schleifenanweisungen

`exit do`	Beendet eine do...loop-Schleife
`exit for`	Beendet eine for-Schleife

2.5. Der Aufbau eines VB.NET-Programms

Ein VB.NET-Programm, das außer der Hauptfunktion Main keine benutzerdefinierten Klassen oder Funktionen verwendet, kann folgende Struktur aufweisen:


' options
Option Explicit On 
Option Strict On
 
' namespaces
Imports espace1
Imports ....
 
Module nomDuModule
    Sub main()
....
    End Sub
End Module

Die Anweisung [Option Explicit on] erzwingt die Deklaration von Variablen. In VB.NET ist dies nicht zwingend erforderlich. Eine nicht deklarierte Variable ist dann vom Typ Object.
Die Anweisung [Option Strict on] verbietet alle Datentypkonvertierungen, die zu Datenverlust führen könnten, sowie alle Konvertierungen zwischen numerischen Typen und Zeichenfolgen. Konvertierungsfunktionen müssen daher explizit verwendet werden.
Das Programm importiert alle benötigten Namespaces. Dieses Konzept haben wir bisher noch nicht behandelt. In früheren Programmen sind wir oft auf Anweisungen wie die folgenden gestoßen:

        Console.Out.WriteLine(unechaine)

Eigentlich hätten wir schreiben sollen:

        System.Console.Out.WriteLine(unechaine)

wobei System der Namespace ist, der die Klasse [Console] enthält. Durch das Importieren des Namespaces [System] mit einer Imports-Anweisung durchsucht VB.NET diesen systematisch, sobald es auf eine Klasse stößt, die es nicht erkennt. Die Suche wird in allen deklarierten Namespaces wiederholt, bis die betreffende Klasse gefunden wird. Wir schreiben daher:


' namespaces
Imports System
....
 
        Console.Out.WriteLine(unechaine)

Ein Beispielprogramm könnte wie folgt aussehen:


' options
Option Explicit On 
Option Strict On
 
'namespaces
Imports System
 
' main module
Module main1
    Sub main()
        Console.Out.WriteLine("main1")
    End Sub
End Module

Das gleiche Programm lässt sich wie folgt schreiben:


' options
Option Explicit On 
Option Strict On
 
'namespaces
Imports System
 
' test class
Public Class main2
    Public Shared Sub main()
        Console.Out.WriteLine("main2")
    End Sub
End Class

Hier verwenden wir das Konzept einer Klasse, das im nächsten Kapitel vorgestellt wird. Wenn eine solche Klasse eine statische (gemeinsam genutzte) Prozedur namens main enthält, wird diese ausgeführt. Wir fügen diesen Code hier ein, da C#, die Schwestersprache von VB.NET, nur das Konzept von Klassen kennt – das heißt, jeder ausgeführte Code muss zu einer Klasse gehören. Das Konzept der Klassen ist Teil der objektorientierten Programmierung. Es auf das Design jedes Programms anzuwenden, ist etwas umständlich. Wir sehen dies hier in Version 2 des vorherigen Programms, wo wir gezwungen sind, die Konzepte von Klassen und statischen Methoden einzuführen, wo sie nicht benötigt werden. Daher werden wir von nun an das Konzept einer Klasse nur dann einführen, wenn es notwendig ist. In anderen Fällen werden wir das Konzept eines Moduls verwenden, wie in Version 1 oben.

2.6. Kompilieren und Ausführen eines VB.NET-Programms

Zum Kompilieren eines VB.NET-Programms ist lediglich das .NET SDK erforderlich. Betrachten Sie das folgende Programm:


' options
Option Explicit On 
Option Strict On
 
' namespaces
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 [loops1.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 VB.NET-Compiler. Hier befand es sich im DOS-PATH:


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 [vbc]-Compiler erzeugt eine .exe-Datei, die von der .NET-Virtual Machine ausgeführt werden kann:

dos>boucles1
somme=55
somme=55
somme=55
somme=55

2.7. Beispiel zur Steuerberechnung

Wir schlagen vor, ein Programm zu schreiben, das die Steuer eines Steuerpflichtigen berechnet. Wir betrachten den vereinfachten Fall eines Steuerpflichtigen, der nur sein Gehalt anzugeben hat:

Wir berechnen die Anzahl der Steuerklassen für den Arbeitnehmer als nbParts = nbEnfants / 2 + 1, wenn er unverheiratet ist, und als nbEnfants / 2 + 2, wenn er verheiratet ist, wobei nbEnfants die Anzahl der Kinder ist.
Wenn er mindestens drei Kinder hat, erhält er einen zusätzlichen halben Anteil
Wir berechnen sein zu versteuerndes Einkommen R = 0,72 * S, wobei S sein Jahresgehalt ist
Wir berechnen ihren Familienkoeffizienten QF = R / nbParts
Wir berechnen ihre Steuer I. Betrachten Sie die folgende Tabelle:

12620,0	0	0
13.190	0,05	631
15.640	0,1	1.290,5
24.740	0,15	2.072,5
31.810	0,2	3.309,5
39.970	0,25	4900
48.360	0,3	6.898,5
55.790	0,35	9.316,5
92.970	0,4	12.106
127.860	0,45	16.754,5
151.250	0,50	23.147,5
172.040	0,55	30.710
195.000	0,60	39.312
0	0,65	49062

Jede Zeile enthält 3 Felder. Um die Steuer I zu berechnen, suchen Sie die erste Zeile, in der QF <= Feld1 ist. Wenn beispielsweise QF = 23.000 ist, lautet die gefundene Zeile

    24740        0.15        2072.5

Steuer I ist dann gleich 0,15*R – 2072,5*nbParts. Wenn QF so ist, dass die Bedingung QF<=field1 nie erfüllt ist, werden die Koeffizienten aus der letzten Zeile verwendet. Hier:

    0                0.65        49062

was die Steuer I = 0,65*R - 49062*nbParts ergibt. Das entsprechende VB.NET-Programm lautet wie folgt:


' options
Option Explicit On 
Option Strict On
 
' namespaces
Imports System
 
Module impots
    ' ------------ hand
    Sub Main()
 
        ' data tables required for tax calculation
        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}
 
        ' we recover marital status
        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"
 
        ' number of children
        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
        ' salary
        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
        ' calculating the number of shares
        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
        ' taxable income
        Dim Revenu As Decimal
        Revenu = 0.72D * Salaire
 
        ' family quotient
        Dim QF As Decimal
        QF = Revenu / NbParts
 
        ' search for tax bracket corresponding to 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
        ' tax
        Dim impots As Integer = CInt(i * 0.05D * Revenu - CoeffN(i) * NbParts)
 
        ' the result is displayed
        Console.Out.WriteLine(("Impôt à payer : " & impots))
    End Sub
End Module

Das Programm wird in einem DOS-Fenster mit folgendem Befehl 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. Beachten Sie, dass impots.exe nicht direkt vom Prozessor ausgeführt werden kann. Sie enthält tatsächlich Zwischencode, der nur auf einer .NET-Plattform ausführbar ist. Die erhaltenen 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. Hauptargumente des Programms

Die Hauptprozedur „Main“ kann ein Array von Zeichenfolgen als Parameter entgegennehmen:


    Sub main(ByVal args() As String)

Der Parameter „args“ ist ein Array von Zeichenfolgen, das die bei Aufruf des Programms über die Befehlszeile übergebenen Argumente empfängt.

args.Length ist die Anzahl der Elemente im Array args
args(i) ist das i-te Element des Arrays

Wenn wir das Programm P mit dem Befehl P arg0 arg1 … argn und wenn die Main-Prozedur von Programm P wie folgt deklariert ist:


    Sub main(ByVal args() As String)

dann gilt arg(0)="arg0", arg(1)="arg1" … Hier ein Beispiel:


' guidelines
Option Strict On
Option Explicit On 
 
' namespaces
Imports System
 
Module arg
    Sub main(ByVal args() As String)
        ' number of arguments
        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:

dos>arg1 a b c
Il y a 3 arguments
argument n° 0=a
argument n° 1=b
argument n° 2=c

2.9. Aufzählungen

Eine Aufzählung ist ein Datentyp, dessen Wertebereich eine Menge von ganzzahligen Konstanten ist. Stellen wir uns ein Programm vor, das Prüfungsnoten verarbeiten muss. Es gäbe fünf Noten: Bestanden, Befriedigend, Gut, Sehr gut, Ausgezeichnet. Wir könnten 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 dargestellt, beginnend mit 0 für die erste Konstante, 1 für die nächste und so weiter. Eine Variable kann so deklariert werden, dass sie diese Werte in der Aufzählung annimmt:


        ' a variable that takes its values from the enumeration mentioned
        Dim maMention As mention = mention.Passable

Eine Variable kann mit den verschiedenen möglichen Werten der Aufzählung verglichen werden:


        ' test avec valeur de l'énumération
        If (maMention = mention.Passable) Then
            Console.Out.WriteLine("Peut mieux faire")
        End If

Sie können 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 Sie alle Werte eines als Parameter übergebenen Aufzählungstyps abrufen können. Dieser Parameter muss ein Objekt vom Typ „Type“ sein, einer Klasse, die Informationen über einen Datentyp bereitstellt. Der Typ einer Variablen v wird über v.GetType() ermittelt. Hier gibt also maMention.GetType() das Type-Objekt für die Aufzählung „mentions“ zurück, und Enum.GetValues(maMention.GetType()) gibt die Liste der Werte für die Aufzählung „mentions“ zurück.

Dies wird im folgenden Programm veranschaulicht:


' guidelines
Option Strict On
Option Explicit On 
 
' namespaces
Imports System

Public Module enum2
 
    ' an enumeration
    Enum mention
        Passable
        AssezBien
        Bien
        TrèsBien
        Excellent
    End Enum
 
    ' test pg
    Sub Main()
 
        ' a variable that takes its values from the enumeration mentioned
        Dim maMention As mention = mention.Passable
 
        ' variable value display
        Console.Out.WriteLine("mention=" & maMention)
 
        ' test with enumeration value
        If (maMention = mention.Passable) Then
            Console.Out.WriteLine("Peut mieux faire")
        End If
 
        ' list of literal mentions
        For Each m As mention In [Enum].GetValues(maMention.GetType)
            Console.Out.WriteLine(m.ToString)
        Next
 
        ' list of full mentions
        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

Viele VB.NET-Funktionen können Ausnahmen, d. h. Fehler, auslösen. Wenn eine Funktion eine Ausnahme auslösen kann, sollte der Programmierer diese behandeln, um Programme zu erstellen, die widerstandsfähiger gegen Fehler sind: Sie sollten stets vermeiden, dass eine Anwendung unerwartet „abstürzt“.

Die Ausnahmebehandlung folgt diesem Muster:

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, fährt das Programm mit der nächsten Anweisung fort; andernfalls springt es in den Körper der catch-Klausel und fährt dann mit der nächsten Anweisung fort. Beachten Sie folgende Punkte:

e ist ein vom Typ Exception abgeleitetes Objekt. Wir können genauer sein, indem wir Typen wie IOException, SystemException usw. verwenden: Es gibt verschiedene Arten von Ausnahmen. Indem wir catch e als Exception schreiben, geben wir an, dass wir alle Arten von Ausnahmen behandeln wollen. Wenn der Code im try-Block wahrscheinlich mehrere Arten von Ausnahmen erzeugt, möchten wir vielleicht genauer sein, indem wir die Ausnahme mit mehreren catch-Blöcken 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

Sie können try/catch-Blöcken eine finally-Klausel hinzufügen:

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 auftritt oder nicht, wird der Code in der finally-Klausel immer ausgeführt.

In der catch-Klausel möchten Sie möglicherweise nicht das verfügbare Exception-Objekt verwenden. Anstatt catch e as Exception zu schreiben, schreiben Sie catch.
Die Exception-Klasse verfügt über eine Message-Eigenschaft, die eine Meldung enthält, die den aufgetretenen Fehler detailliert beschreibt. Wenn Sie diese Meldung also anzeigen möchten, würden Sie schreiben:

catch e as Exception
    Console.Error.WriteLine("L'erreur suivante s'est produite : "+e.Message);
    ...
end try

Die Klasse „Exception“ verfügt über eine ToString-Methode, die eine Zeichenfolge zurückgibt, die den Ausnahmetyp und den Wert der Message-Eigenschaft angibt. Wir können daher 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:


' options
Option Explicit On 
Option Strict On
 
' namespaces
Imports System
 
Module tab1
    Sub Main()
        ' declaring & initializing an array
        Dim tab() As Integer = {0, 1, 2, 3}
        Dim i As Integer
 
        ' table display with for
        For i = 0 To tab.Length - 1
            Console.Out.WriteLine(("tab[" & i & "]=" & tab(i)))
        Next i
 
        ' table display with a for each
        Dim élmt As Integer
        For Each élmt In tab
            Console.Out.WriteLine(élmt)
        Next élmt
 
        ' generating an exception
        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 wir die Ausnahme behandeln, die dadurch verursacht wird, dass einer Zahl eine Zeichenkette zugewiesen wird, obwohl die Zeichenkette keine Zahl darstellt:


' options
Option Strict On
Option Explicit On 
 
'imports
Imports System
 
Public Module console1
  Public Sub Main()
    ' We ask for the name
    System.Console.Write("Nom : ")
 
        ' reading response
    Dim nom As String = System.Console.ReadLine()
 
        ' age requested
    Dim age As Integer
    Dim ageOK As Boolean = False
    Do While Not ageOK
      ' question
      Console.Out.Write("âge : ")
      ' reading-checking response
      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
 
        ' final display
    Console.Out.WriteLine("Vous vous appelez [" & nom & "] et vous avez [" & age & "] ans")
  End Sub
End Module

Einige Ausführungsergebnisse:

dos>console1
Nom : dupont
âge : 23
Vous vous appelez dupont et vous avez 23 ans

dos>console1
Nom : dupont
âge : xx
Age incorrect, recommencez...
âge : 12
Vous vous appelez dupont et vous avez 12 ans

2.11. Parameter an eine Funktion übergeben

Hier interessiert uns, wie Parameter an eine Funktion übergeben werden. Betrachten Sie die Funktion:


    Sub changeInt(ByVal a As Integer)
        a = 30
        Console.Out.WriteLine(("Paramètre formel a=" & a))
    End Sub

In der Funktionsdefinition 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 ein Beispiel für die 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 tatsächliche Parameter, der seinen Wert an den formalen Parameter a übergibt. Uns interessiert, wie ein formaler Parameter den Wert des entsprechenden tatsächlichen Parameters abruft.

2.11.1. Wertübergabe

Das folgende Beispiel zeigt, dass die Parameter einer Funktion/Prozedur standardmäßig per Wert übergeben werden: Das heißt, der Wert des tatsächlichen Parameters wird in den entsprechenden formalen Parameter kopiert. Es handelt sich um zwei unterschiedliche Entitäten. Wenn die Funktion den formalen Parameter ändert, bleibt der tatsächliche Parameter unverändert.


' options
Option Explicit On 
Option Strict On
 
' passing parameters by value to a function
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:

Paramètre formel a=30
Paramètre effectif age=20

Der Wert 20 des tatsächlichen Parameters wurde in den formalen Parameter a kopiert. Der formale Parameter wurde anschließend geändert. Der tatsächliche Parameter blieb unverändert. Diese Übergabemethode eignet sich für die Eingabeparameter einer Funktion.

2.11.2. Übergabe per Referenz

Bei einer Übergabe per Referenz sind der tatsächliche Parameter und der formale Parameter ein und dieselbe Entität. Wenn die Funktion den formalen Parameter ändert, wird auch der tatsächliche Parameter geändert. In VB.NET muss dem formalen Parameter das Schlüsselwort ByRef vorangestellt werden. Hier ein Beispiel:


' options
Option Explicit On 
Option Strict On
 
' passing parameters by value to a function
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:

Paramètre formel a=30
Paramètre effectif age=30

Der tatsächliche Parameter folgte der Änderung des formalen Parameters. Diese Übergabemethode eignet sich für die Ausgabeparameter einer Funktion.