Um Eingaben von der Konsole auszulesen, bietet uns die Console-Klasse die Methoden Read() und ReadLine() an. Die Read()-Methode gibt einen Integer zurück (Tastencode für das eingegebene Zeichen), sobald die Eingabe beendet wurde (z.B. mit ENTER). Um sich Ärger mit dem Zeilenabschlusszeichen zu sparen, verwenden Sie lieber die ReadLine()-Methode, welche die komplette Zeile einliest (das Zeilenabschlusszeichen ist in dem zurückgegebenen String nicht mit enthalten). Hier ein kleiner "Zufallszahlengenerator" als Beispiel:

Option Explicit On 
Option Strict On
 
Imports System
 
Module MainModule
 
  Sub Main()
    Dim gelesen As String   ' enthält die gelesene Zahl als String
    Dim zahl As Integer     ' speichert die Zufallszahl
    Console.WriteLine("Glückszahlgenerator")
    Console.Write("Geben Sie eine Startzahl ein: ")
    gelesen = Console.ReadLine()
    Dim r As New Random(Integer.Parse(gelesen))
    zahl = r.Next(0, 9)
    Console.WriteLine("Ihre Glückzahl ist die {0}.", zahl.ToString())
    Console.ReadLine()
  End Sub
End Module

Die ersten 8 Zeilen sind nichts Unbekanntes. In der Sub Main() werden zunächst zwei Variablen deklariert, die im weiteren Programmverlauf benötigt werden (eigentlich wären keine Variablen nötig, aber durch die Verwendung von Variablen ist der Code leichter zu lesen). In den nächsten zwei Zeilen werden je eine Meldung ausgegeben und dann wird die eingegebene Zahl ausgelesen und in die Variable gelesen gespeichert.

In Zeile 14 wird eine Instanz der Klasse Random mit dem Namen r erstellt, mit der wir auf die Methoden der Klasse zugreifen, die eine "zufällige" Zahl erstellt. Um die Zahlen wirklich zufällig zu erstellen, wird ein Initiationswert für die Klasse angegeben, da ansonsten immer dieselben Zahlen ausgegeben werden würden. Dieser Initiationswert ist die eingegebene Zahl vom Benutzer. Leider haben wir diese nur als String vorliegen, wir brauchen sie aber als Integer. Die Lösung - wir parsen den String in einen Integer (ein CInt wäre auch möglich, ist letztlich aber egal). r.Next() gibt uns eine Zufallszahl zurück, die wir in die Variable zahl zwischenspeichern.

Dann geben wir die Zufallszahl aus und fügen am Ende noch ein Console.ReadLine() ein, damit das Programm erst bei Betätigung der ENTER-Taste beendet wird. Damit wir die letzte Zeichenkette nicht zerlegen müssen, setzen wir für die Variable zahl den Platzhalter {0} ein, schreiben unseren String fertig, setzen ein Komma und Konvertieren unsere Zahl in einen String. Diese Platzhalter werden einfach durchnummeriert und die Nummerierung beginnt mit jeder neuen Codezeile wieder von vorne.

Mehr gibt es über die Konsole eigentlich nicht zu sagen, da mehr Funktionen nicht enthalten sind (zumindest im .NET Framework 1.1). Sie können zum Lesen und Schreiben auch eine Instanz der TextReader- bzw. der TextWriter-Klasse verwenden, aber diese Klassen werden im Kapitel 6 ausführlich behandelt.

2.2.8. Schleifen
Mit Schleifen kann man beliebig viele Anweisungen wiederholen lassen. In VB.NET gibt es die For…Next-Schleife, die For Each…Next-Schleife, die Do…Loop-Schleife und die While…End While-Schleife.

2.2.8.1. Die For…Next-Schleife
Die For…Next-Schleife ist eine s.g. Zählschleife, weil sie eine Variable hoch- oder runterzählt.

Die Syntax ist recht einfach:

For VARIABLE = STARTWERT To ENDWERT Step SCHRITTWEITE
  Anweisungen
Next [VARIABLE]

Zur Erklärung: Eine Variable wird einem Startwert zugewiesen gefolgt vom To-Schlüsselwort mit dem Endwert, bei dem die Schleife dann beendet werden soll. Mit der Step-Angabe kann man angeben, um wie viele Schritte die Variable erhöht / vermindert werden soll. Mit einem negativen Step wird eine Variable runtergezählt.

For i As Integer = 10 To 0 Step -1
  Console.WriteLine(i.ToString())
Next i

Hinweis: Wer das .NET Framework in der Version 1.0 verwendet, der kann keine Variablen direkt in der Schleife deklarieren. Diese Deklaration muss ausgelagert werden. Das obige Beispiel sieht umgeschrieben dann so aus:

Dim i As Integer
For i = 10 To 0 Step -1
  Console.WriteLine(i.ToString())
Next i

Wenn Sie eine Single-, Double oder Decimalvariable verwenden, können Sie als Step auch eine Kommazahl verwenden.

2.2.8.2. Die For Each…Next-Schleife
Diese Schleife wird verwendet, um Arrays und Auflistungen zu durchlaufen. Diese Schleife wird im Kapitel "Arrays und Auflistungen" behandelt.

2.2.8.3. Die Do…Loop-Schleife
Mit der Do…Loop-Schleife können Sie Anweisungen von einer Bedingung abhängig machen. Sie haben die Möglichkeiten, die Bedingung vor der Schleife zu prüfen oder nach der Schleife, wodurch die Schleife mindestens einmal durchlaufen wird. Außerdem haben Sie die Möglichkeit, die Anweisungen solange zu wiederholen, solange die Bedingung True ist oder bis die Bedingung True wird.

Wiederholung solange die Bedingung True ist
Um anzugeben, dass die Schleife solange durchlaufen wird, solange die Bedingung zutrifft (True), verwenden Sie das While-Schlüsselwort. Das folgende Beispiel zählt einen Countdown von 10 bis 0:

Dim zahl As Integer = 10
Do While zahl >= 0
  Console.WriteLine(zahl.ToString())
  zahl -= 1
Loop

Wenn die Bedingung am Schleifenende geprüft werden soll, dann schreiben Sie das While-Schlüsselwort mit der Bedingung nach dem Loop. Dann sieht die Schleife so aus:

Dim zahl As Integer = 10
Do
  Console.WriteLine(zahl.ToString())
  zahl -= 1
Loop While zahl >= 0

Wiederholung bis die Bedingung True wird
Mit dem Until-Schlüsselwort sagen Sie, dass die Schleife beendet werden soll, wenn die Bedingung True wird. Oder anders gesagt, die Schleife läuft so lange, bis die Bedingung False ist. Unser Countdown sieht dann so aus:

Dim zahl As Integer = 10
Do Until zahl = -1
  Console.WriteLine(zahl.ToString())
  zahl -= 1
Loop

Wenn die Bedingung am Ende geprüft werden soll, dann passiert dasselbe wie bei der While-Variante - das Until mit der Bedingung wird hinter dem Loop gesetzt und fertig.
Hinweis: Stellen Sie sicher, dass Ihre Bedingungen zutreffen, sonst haben Sie eine Endlosschleife, die unendlich lange läuft und so den Eindruck vermitteln kann, dass Ihre Anwendung abgestürzt ist. 

2.2.8.4. Die While…End While-Schleife
Die While…End While-Schleife ist im Grunde genommen dasselbe wie eine Do While…Loop-Schleife. Dazu ein Beispiel, mehr Erklärung ist nicht nötig:

Dim zahl As Integer = 10
While zahl >= 0
  Console.WriteLine(zahl.ToString())
  zahl -= 1
End While

Im Gegensatz zu der Do…Loop-Schleife muss bei der While…End While-Schleife nach dem While eine Bedingung folgen, ansonsten wird ein Compilerfehler generiert.

2.2.8.5. Schleifen vorzeitig beenden
Schleifen können mit Exit Do, Exit While bzw. Exit For (für For…Next-Schleife wie auch For Each…Next-Schleife) vorzeitig beendet werden. Dies ist in einigen Situationen ganz hilfreich. So können z.B. Endlosschleifen beendet werden:

Dim zahl As Integer = 0
Do
  Console.WriteLine(zahl.ToString())
  zahl += 1
 
  If zahl = 100 Then
    Exit Do
  End If
Loop

Ohne die If-Anweisung würde diese Schleife unendlich lang durchlaufen werden. Sobald aber die If-Anweisung zutrifft, wird die Schleife abgebrochen.

2.3 Arrays und Auflistungen

In diesem Abschnitt soll es um Arrays und Auflistungen (im englischen Collections) gehen.

2.3.1 Arrays

Was sind Arrays? Arrays sind Variablen, die über einen Index angesprochen werden, wodurch Sie mehrere Werte in einer Variable speichern können.

2.3.1.1. Arrayinitialisierung
Die Arrayinitialisierung ist nicht sonderlich schwer. Im folgenden Beispiel wird ein String-Array namens Sprachen angelegt und mit drei Programmiersprachen gefüllt.

Dim Sprachen(2) As String = {"VB.NET", "C#", "C++"}

Dieses Beispiel erstellt ein Array mit 3 Elementen (die Zählung beginnt bei Null).

2.3.1.2. Zugriff auf einzelne Arrayelemente
Um auf ein einzelnes Element eines Arrays zu zugreifen, schreiben Sie den Namen des Arrays hin und in Klammern den Index des gewünschten Elementes. Das nachfolgende Beispiel speichert in den Double-Array Wurzeln die Quadratwurzeln der Zahlen 0 bis 19 unter Verwendung einer Schleife:

Dim Wurzeln(19) As Double
For i As Integer = 0 To Wurzeln.GetUpperBound(0)
  Wurzeln(i) = Math.Sqrt(i)
Next i

Wenn Sie auf jedes Element nacheinander zugreifen (durch iterieren) wollen, dann können Sie auch die For Each-Schleife verwenden:

For Each Wurzel As Double In Wurzeln
  Console.WriteLine(Wurzel)
Next

Allgemein sieht die For Each-Schleife so aus:

For Each EINZELWERT In ARRAY
  Anweisungen()
Next

2.3.1.3. Dynamische Arrays
Dynamische Arrays sind in VB.NET nichts Besonderes. Aber was sind dynamische Arrays? Darunter versteht man die Größenanpassung des Arrays zur Laufzeit. Um die Größe des Arrays neu zu setzen, verwenden Sie den ReDim-Befehl:

ReDim Sprachen(4)

Wenn Sie dies aber ausführen, werden Sie feststellen, dass Ihre Daten verschwunden sind. Ursache liegt im Speicher: Bei einem ReDim-Befehl muss VB.NET (oder besser gesagt, die CLR) das Array neu aufbauen. Aus Performancegründen wird standardmäßig auf ein Kopieren der Werte verzichtet. Um ein kopieren der Werte zu erzwingen, setzen Sie nach dem ReDim noch ein Preserve:

ReDim Preserve Sprachen(4)

2.3.1.4. Funktionen für Arrays
Alle Arrays sind von der Array-Klasse des .NET Frameworks abgeleitet und diese enthält einige interessante Funktionen. Einige von ihnen musste man unter VB6 selbst noch schreiben. Die folgende Tabelle soll einen Überblick über die Arrayfunktionen geben:

Funktion	Beschreibung	Rückgabewert
GetLength()	Gibt die Länge einer Dimension zurück.	Integer
GetLowerBound()	Gibt die untere Grenze einer Dimension zurück.	Integer
GetUpperBound()	Gibt die obere Grenze einer Dimension zurück.	Integer
Clear()	Löscht alle Elemente des Arrays	Keinen
IndexOf()	Gibt in einem Array das erste Vorkommen eines Objektes zurück.	Integer
LastIndexOf()	Wie IndexOf(), nur dass das letzte Vorkommen des Objektes zurückgegeben wird.	Integer
Reverse()	Kehrt ein Array um.	Keinen
Sort()	Sortiert ein Array (Quicksort)	Keinen

Arrayfunktionen

2.3.1.5. Mehrdimensionale Arrays
Natürlich können Sie statt den bereits kennen gelernten eindimensionalen Arrays auch mehrdimensionale Arrays verwenden. Sie können mit so vielen Dimensionen arbeiten wie Sie wollen, da gibt es (fast) keine Grenzen, jedoch ist die Verwendung von Arrays mit mehr als 3 Dimensionen doch recht selten. Hierzu ein Beispiel (2-dimensionales Array):

Dim Array(,) As Integer = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
Dim i, j As Integer
For i = 0 To 2
  For j = 0 To 2
    Console.Write(Array(i, j) & " ")
  Next j
  Console.WriteLine()
Next i

Hiermit möchten wir unseren "Array-Exkurs“ beenden. Wer mehr über Arrays lesen möchte, dem sei einem Blick in die VB.NET-Hilfe (entweder MSDN Online oder die MSDN Library) empfohlen.

2.3.2. Auflistungen

Unter einer Auflistung, oder im englischen Collection, versteht man eine Klasse, die die Elemente nach einem ganz bestimmten Muster ordnet. Die .NET Framework-Klassenbibliothek enthält viele Collectionklassen, wie z.B. Stack, Queue, ArrayList, Hashtable, ListDirectory, HybridDirectory oder SortedList.

In diesem Abschnitt wollen wir uns einige Auflistungen genauer anschauen. Auch hier ist ein Blick in die .NET Framework-Dokumentation sinnvoll. Die meisten Auflistungen finden Sie im Namespace System.Collections, die spezialisierten Auflistungen im Namespace System.Collections.Specialized. Leider haben die Collections einen Nachteil (außer die spezialisierten) – sie nehmen alle Object-Variablen an, was es aber dagegen gibt, erfahren Sie weiter unten.

2.3.2.1. Ein erstes Beispiel: ArrayList
Die ArrayList ist eine Liste, welche sich automatisch dynamisch vergrößert. Elemente werden mit der Add-Methode hinzugefügt, mit der AddRange-Methode können mehrere Elemente mit einem Aufruf hinzugefügt werden. Elemente, die Sie mit der Add- bzw. AddRange-Methode hinzugefügt haben, werden am Ende der Liste eingefügt.

Wenn Sie ein Element an einer ganz bestimmten Stelle einfügen wollen, dann verwenden Sie die Insert-Methode, welcher Sie einen Index und einen Wert übergeben. Es gibt auch eine InsertRange-Methode, die genauso funktioniert wie die Insert-Methode, nur dass diese Methode mehrere Elemente hinzufügt.

Wollen Sie ein ganz bestimmtes Element entfernen? Dann verwenden Sie die Remove-Methode. Oder wollen Sie ein Element an einer ganz bestimmten Stelle löschen? Kein Problem für RemoveAt(). Mehrere Elemente in einem Rutsch zu entfernen – dafür gibt es RemoveRange(). 

Dies sind die wichtigsten Methoden der ArrayList und dazu gibt es jetzt noch kleines Beispiel:

Option Explicit On 
Option Strict On
 
Imports System
Imports System.Collections
 
Module MainModule
  Sub Main()
    ' "Begrüßung" ausgeben
    Console.WriteLine("ArrayList-Beispiel")
    Console.WriteLine()
 
    ' Collection erzeugen und mit Werten füllen
    Dim CarCollection As New ArrayList
    Dim Cars() As String = {"Opel Astra", "Audi A4", "VW Golf", _
    "BMW Z3", "Mercedes S-Serie"}
    CarCollection.AddRange(Cars)
 
    ' Werte ausgeben
    Console.WriteLine("Diese Elemente wurden hinzugefügt:")
    For Each item As String In CarCollection
      Console.WriteLine(item)
    Next
    Console.WriteLine()
 
    ' Element nach dem ersten Element hinzufügen
    CarCollection.Insert(1, "Trabi")
    Console.WriteLine("Folgendes Element wurde nach dem 1. eingefügt:")
    Console.WriteLine(CarCollection.Item(1))
    Console.WriteLine()
 
    ' Element "Mercedes S-Serie" entfernen
    CarCollection.Remove("Mercedes S-Serie")
    Console.WriteLine("'Mercedes S-Serie' wurde entfernt")
    Console.WriteLine()
 
    ' Collection sortieren und ausgeben
    CarCollection.Sort()
    Console.WriteLine("Die ArrayList wird nun sortiert ausgegeben:")
    For Each item As String In CarCollection
      Console.WriteLine(item)
    Next
    Console.WriteLine()
 
    ' Die letzten beiden Elemente werden entfernt
    Console.WriteLine("Es werden Elemente entfernt.")
    CarCollection.RemoveRange(3, 2)
    Console.WriteLine()
 
    ' Verbliebene Elemente ausgeben
    Console.WriteLine("Diese Elemente sind noch enthalten:")
    For Each item As String In CarCollection
      Console.WriteLine(item)
    Next
 
    Console.ReadLine()
  End Sub
End Module

Die anderen Collections funktionieren fast genauso wie die ArrayList. Da sich vieles gleicht und wiederholt, möchte ich hiermit nur auf die .NET Framework Dokumentation verweisen, dort sind die einzelnen Collections beschrieben inkl. Beispiele.

2.3.2.2. Typsicherheit in Collections
Dass die Collections alle Object-Variablen annehmen, hat zwar den Vorteil, dass wir ihr zwar alles reinstecken können, aber wenn wir Werte wieder abrufen, müssen wir diese casten – dies kostet Zeit und kann daneben gehen. Um dieses Problem zu beseitigen, kann man eigene (typsichere) Collections schreiben, was aber aufwendig ist. Einen eleganteren Weg geht hier Visual Basic .NET 2005 mit dem .NET Framework 2.0, welches es mittlerweile als Beta 2 gibt. Hier werden Generics verwendet. Bei der Erstellung muss man einen Typ angeben, welchen die Collection annehmen soll. Diese Generics befinden sich im Namespace System.Collections.Generic, den man importieren sollte, um sich Tipparbeit zu sparen. Wie Generics verwendet werden, dazu ein Beispiel:

Option Explicit On
Option Strict On
 
Imports System
Imports System.Collections.Generic
 
Module MainModule
  Sub Main()
    Dim StringList As New List(Of String)
 
    ' Weitere Verwendung hier
  End Sub
End Module

Wie Sie sehen, geben Sie nach dem Of an, von welchem Typ die Collection sein soll (hier eine Liste). Sie können jeden beliebigen Typ da hinschreiben, auch selbst definierte Typen (Strukturen und Klassen), zu denen wir aber später kommen. Natürlich können Sie auch selber generische Klassen erstellen, aber dies führt zu weit. Wenn Sie sich dafür interessieren, dann kann ich Ihnen nur die MSDN Webcasts und die Beta 2 von VB.NET 2005 empfehlen.

2.4. Prozeduren und Funktionen

In diesem Abschnitt werden Sie lernen, was Prozeduren und Funktionen eigentlich sind und wie Sie diese einsetzen und eigene schreiben können. Außerdem lernen Sie einige wichtige Prozeduren und Funktionen kennen, die im .NET Framework enthalten sind.

2.4.1. Was sind Prozeduren und Funktionen?

Prozeduren und Funktionen fassen mehrere Programmanweisungen unter einem Namen zusammen und diese können Sie mit diesem Namen beliebig oft aufrufen. Damit spart man sich das mehrmalige schreiben derselben Codezeilen und Änderungen müssen nur an einer Stelle zentral gemacht werden und nicht an vielen, wodurch Zeit gespart wird.

Damit der Compiler weiß, dass es sich um eine Prozedur oder Funktion handelt, folgt nach dem Namen ein Paar runder Klammern ( () ).
Der Unterschied zwischen beiden ist, dass Prozeduren keinen Wert zurückgeben, Funktionen hingegen schon.

2.4.2. Schreiben und Aufrufen von Prozeduren & Funktionen
2.4.2.1. Prozeduren
In diesem Abschnitt geht es um das Schreiben und Verwenden von Prozeduren.

Prozeduren werden wie folgt definiert:

Sub ProzedurName()
  Anweisungen
End Sub

Als erstes kommt das Sub-Schlüsselwort, mit dem Sie die Definition einer Prozedur einleiten. Nach dem Sub-Schlüsselwort folgt der Name der Prozedur, der die gleichen Beschränkungen wie Variablennamen aufweist, gefolgt von einem Paar runden Klammern, die evtl. Parameter angeben (mehr zu Parametern und Argumenten später). Danach gibt man die Befehle ein, die ausgeführt werden sollen, wenn die Prozedur aufgerufen wird. Beendet wird die Prozedur mit End Sub.

Hier ein komplettes Beispiel:

Option Explicit On
Option Strict On
 
Imports System
 
Module MainModule
 
  ' Diese Prozedur gibt auf der Konsole den angemeldeten User aus
  Sub CurrentUser()
    Console.WriteLine("Angemeldeter User: {0}", Environment.UserName)
  End Sub
 
  Sub Main()
    ' Aufruf unserer Methode 2x nacheinander
    CurrentUser()
    CurrentUser()
    Console.ReadLine()
  End Sub
End Module

In dem Modul wird zuerst eine eigene Prozedur definiert mit dem Namen CurrentUser(). Diese gibt auf der Konsole aus, welcher User gerade am System angemeldet ist. Der Benutzername wird mit Environment.UserName ermittelt.

In der Sub Main() wird unsere Prozedur zweimal nacheinander aufgerufen. Wie Sie sehen, wird eine Prozedur aufgerufen, indem man einfach ihren Namen hinschreibt gefolgt von ein Paar runden Klammern, in denen die s.g. Argumente stehen (mehr dazu später). 

2.4.2.2. Funktionen
Funktionen werden ähnlich wie Prozeduren erstellt und verwendet. Funktionen werden wie folgt definiert:

Function Funktionsname() As Rückgabetyp
  Anweisungen
  Return Wert
End Function

Die Definition beginnt mit dem Function-Schlüsselwort gefolgt von dem Namen der Funktion. In runden Klammern stehen Parameter (wenn vorhanden). Da Funktionen einen Wert zurückgeben, muss natürlich auch angegeben werden, von welchem Typ der zurückgegebene Wert ist. Dies wird mit der As-Klausel erreicht. In der Funktion werden die auszuführenden Anweisungen hineingeschrieben. Der Wert, der zurückgegeben werden soll, sollte mit Return zurückgegeben werden. Es gibt auch eine andere Variante, die auch unter VB6 verwendet wurde, aber ich finde die Verwendung von Return eleganter, sodass ich Ihnen den alten "Mist" verschweige.

Das folgende Beispiel veranschaulicht die Definition und Verwendung von Funktionen:

Option Explicit On
Option Strict On
 
Imports System
 
Module MainModule
 
  Function Zufallszahl() As Integer
    Dim r As New Random(Environment.TickCount)
    Return r.Next(0, 10)
  End Function
 
  Sub Main()
    Dim zahl As Integer = Zufallszahl()
    Console.WriteLine("Ihre Zufallszahl ist die {0}.", _
    zahl.ToString())
    Console.ReadLine()
  End Sub
End Module

In dem Modul wird als erstes eine eigene Funktion mit dem Namen Zufallszahl definiert, die einen Integer zurückgibt. Wenn die Funktion aufgerufen wird, wird zuerst eine Instanz der Klasse Random erstellt und mit Return r.Next(0, 10) wird eine Zufallszahl zwischen 0 und 10 zurückgegeben. In unserer Sub Main() wird eine Variable mit dem Namen zahl definiert und sie bekommt ihren Wert durch unsere Funktion. Der Rest der Sub Main() dürfte verständlich sein.

Wenn Sie den Rückgabewert einer Funktion nicht in einer Variablen speichern, geht dieser verloren. Wenn Sie natürlich den Rückgabewert nicht benötigen, dann brauchen Sie ihn auch nicht speichern.

2.4.3. Parameter und Argumente

In diesem Abschnitt lernen Sie kennen, was Parameter und Argumente sind und erweitern Ihr Wissen über Prozeduren und Funktionen, da diese erst bei Verwendung von Parametern richtig nützlich werden.

2.4.3.1. Was sind Parameter und Argumente?
Wenn Sie eine Prozedur oder Funktion definieren, und Sie wollen ihr Werte übergeben, mit der sie arbeiten soll, z.B. bei mathematischen Berechnungen, dann legen Sie bei der Definition der Prozedur / Funktion auch gleich die Parameter (Platzhalter) fest. Mit diesen Parameternamen können Sie in der Prozedur / Funktion die übergebenen Werte, die Argumente, ansprechen.

Wenn Sie also eine Prozedur / Funktion erstellen, legen Sie die Parameter fest, wenn Sie Ihre Prozedur / Funktion aufrufen, dann übergeben Sie Argumente, also im Endeffekt beides dasselbe, aber je nach Kontext werden sie anders benannt.

2.4.3.2. Definieren von Parametern
Die Definition von Parametern ist einfach und verläuft bei Prozeduren und Funktionen gleich. Unsere obige Zufallsfunktion soll erweitert so werden, dass man ihr ein Minimum und Maximum übergeben kann, zwischen denen die Zufallszahl erzeugt werden soll:

Function Zufallszahl(ByVal minimum As Integer, _
ByVal maximum As Integer) As Integer
  Dim r As New Random(Environment.TickCount)
  Return r.Next(minimum, maximum)
End Function

Wie Sie sehen, ist die Definition von Parametern einfach und dürfte keine Probleme bereiten. Wie viele Parameter Sie angeben oder von welchem Typ sie sind, legen Sie fest. Vergeben Sie als Parameternamen aussagekräftige Namen, damit man auch nach längerer Zeit noch weiß, was die Prozedur / Funktion erwartet.

2.4.3.3. ByVal vs. ByRef
Das VS.NET setzt automatisch vor unseren Parametern ein ByVal, wenn wir nichts angeben. Was sich hinter ByVal und ByRef verbirgt, soll folgendes Beispiel veranschaulichen:

Sub Main()
  Dim i As Integer = 1
  ByValAdd(i)
  Console.WriteLine("i nach dem Aufruf der ByVal-Funktion: " & i)
  ByRefAdd(i)
  Console.WriteLine("i nach dem Aufruf der ByRef-Funktion: " & i)
End Sub
 
Function ByValAdd(ByVal zahl As Integer) As Integer
  zahl += 1
End Function
 
Function ByRefAdd(ByRef zahl As Integer) As Integer
  zahl += 1
End Function

Das Programm erzeugt folgende Ausgabe:

1
2

Wie Sie sehen, hat sich der Wert der Variable i nach dem Aufruf der Funktion ByRefAdd erhöht, bei ByValAdd nicht. Dies würde bedeuten, dass die ByRefAdd-Funktion den Wert direkt ändert. Und so ist es auch, wenn Sie eine Variable mit ByVal - By Value - übergeben, dann übergeben Sie nur eine Kopie des Variablenwertes und die Variable selbst wird nicht verändert. Im Gegensatz zu ByRef - By Reference - hier wird die Referenz (Verweis, Zeiger) der Variable übergeben und Änderungen haben Auswirkungen auf die Variable, eine "Sicherungskopie" gibt es nicht. Da sich durch die Verwendung von ByRef schnell Fehler einschleichen können, ist ByVal Standard. Mit ByRef ergibt sich auch die Möglichkeit, mehr als einen Wert "zurückzugeben" - dies kann in einigen Situationen recht nützlich sein, wenn mehrere Werte auf einmal zurückgegeben werden müssen.

2.4.3.4. Optionale Parameter
Es gibt auch die Möglichkeit, wie auch in Visual Basic 6, optionale Parameter zu definieren. In VB6 hat man dann mit der IsMissing()-Funktion festgestellt, ob der Parameter fehlt oder nicht. In VB.NET existiert diese Funktion nicht mehr, viel mehr definiert man einen Standardwert, der verwendet wird, wenn der Parameter nicht übergeben wurde. Hier ein Beispiel:

Sub PrintText(Optional text As String = "Hallo Welt!")
  Console.WriteLine(text)
End Sub

Folgende Aufrufe sind möglich:

PrintText("Dies ist ein Testaufruf mit eigenem Text.")
PrintText()

Diese Aufrufe ergeben dann folgende Ausgabe:

Dies ist ein Testaufruf mit eigenem Text.
Hallo Welt!

Ich denke, die Funktionsweise von optionalen Parametern ist verstanden worden.

2.4.3.5. Beliebig viele Parameter übergeben
Unter VB6 und VB.NET gibt es die Möglichkeit, beliebig viele Parameter einer Prozedur oder Funktion zu übergeben. Damit dies geht, setzen Sie vor dem Parameter das Schlüsselwort ParamArray und nach dem Parameter ein Paar runde Klammern - fertig. Intern übergeben Sie ein Array, von dem Sie natürlich auch die Methoden verwenden können. Dazu ein Beispiel:

Sub PrintStringsToConsole(ByVal ParamArray strings() As String)
  For Each s As String In strings
    Console.WriteLine(s)
  Next
End Sub

2.4.4. Funktionen überladen

Neu in VB.NET ist es, Funktionen zu überladen. Beim Überladen definieren Sie Funktionen (natürlich auch Prozeduren), welche zwar alle denselben Namen haben, aber ihre Signatur so unterschiedlich ist, dass eine Unterscheidung möglich ist und der Compiler weiß, welche Funktion er aufrufen soll. Die Signatur einer Funktion oder Prozedur ist die erste Zeile (also die, wo das Sub- bzw. Function-Schlüsselwort auftaucht).

Zur Signatur zählt:

• die Anzahl der Parameter
• der Typ des Parameters

Zur Signatur zählt nicht:

• ByVal oder ByRef
• Parametername
• Rückgabewert

Um eine Prozedur oder Funktion zu überladen, setzt man vorne ran das Schlüsselwort Overloads (Overloads wird standardmäßig angenommen, also Sie brauchen es nicht anzugeben, ich persönlich schreibe es explizit davor um zu verdeutlichen, dass eine Prozedur/Funktion überladen ist). Hier das Beispiel zur Überladung von Funktionen:

Option Explicit On 
Option Strict On
 
Imports System
Module MainModule
 
  Overloads Function Dividieren(ByVal zahl1 As Integer, _
    ByVal zahl2 As Integer) As Integer
      Return zahl1 \ zahl2
  End Function
 
  Overloads Function Dividieren(ByVal zahl1 As Double, _
    ByVal zahl2 As Double) As Double
      Return zahl1 / zahl2
  End Function
 
  Sub Main()
    Dim i1 As Integer = 45
    Dim i2 As Integer = 9
    Dim i3 As Integer = Dividieren(i1, i2)
 
    Dim d1 As Double = 43.58
    Dim d2 As Double = 6.42
    Dim d3 As Double = Dividieren(d1, d2)
 
    Console.WriteLine("{0} durch {1} ist {2}.", i1, i2, i3)
    Console.WriteLine("{0} durch {1} ist {2}.", d1, d2, d3)
 
    Console.ReadLine()
  End Sub
End Module

2.4.5 Rekursive Funktionen

Rekursive Funktionen sind Funktionen, die sich selber aufrufen. Dies klingt erst mal komisch, findet aber, vor allem in der Mathematik, Verwendung. 

So wird die Fakultät so definiert: n! = (n-1)*n
Das heißt, die Fakultät von 4 ist 1*2*3*4, also 24. 

Dies lässt sich natürlich gut in eine rekursive Funktion stecken:

Function Fakultät(ByVal zahl As Integer) As Integer
  If zahl = 1 Then Return 1
  Return Fakultät(zahl - 1)
End Function

Und so funktioniert die Funktion: Als erstes wird überprüft, ob der Parameter den Wert 1 hat, wenn ja, gibt die Funktion 1 zurück. Ansonsten ruft die Funktion sich selbst mit dem um eins verminderten Wert auf.

Dass die Funktion überprüft, ob der Parameter den Wert 1 hat, ist wichtig. Wenn diese Überprüfung nicht wäre, würde die Funktion sich unendlich lange aufrufen (na gut, nicht unendlich lange, sondern solange, bis der Stack überläuft - jedenfalls, die Funktion läuft ziemlich lange).

Eine rekursive Funktion kann man zwar auch in eine Schleife umwandeln, dies ist meistens aber weniger elegant und auch weniger verständlich. Achten Sie nur auf eine Abbruchbedingung, die auch erfüllt wird, und nichts geht schief.

2.4.6. Mathematische Funktionen

Das .NET Framework enthält natürlich die mathematischen Funktionen wie Sinus, Kosinus, Tangens, Absolutbetrag, … Diese Funktionen müssen Sie nicht selber schreiben, sondern für den ganzen mathematischen Kram gibt es eine Klasse - Math im System-Namespace.

2.4.6.1. Die Math-Klasse
Die Math-Klasse enthält als erstes zwei Felder - die Kreiszahl PI und die Konstante e (Basis des natürlichen Logarithmus). Die wahre Stärke der Math-Klasse sind aber die vielen Methoden. Dazu eine Tabelle mit allen Funktionen und ihrer Funktion:

Methode	Funktion
Abs()	Gibt den Absolutbetrag einer Zahl zurück
Acos()	Berechnet aus einem gegebenen Kosinuswert den entsprechenden Winkel im Bogenmaß
Asin()	Berechnet aus einem gegebenen Sinuswert den entsprechenden Winkel im Bogenmaß
Atan()	Berechnet aus einem gegebenen Tangenswert den entsprechenden Winkel im Bogenmaß
Atan2()	Gibt einen Winkel zurück, dessen Tangens der Quotient zweier angegebener Zahlen ist.
BigMul()	Berechnet das vollständige Produkt zweier 32-Bit-Zahlen
Ceiling()	Gibt die nächst größere Ganzzahl zurück.
Cos()	Gibt den Kosinus des angegebenen Winkel (im Bogenmaß) zurück.
Cosh()	Gibt den Hyperbelkosinus des angegebenen Winkel (im Bogenmaß) zurück
DivRem()	Dividiert zwei Zahlen, bei der auch der Rest über einen ByRef-Parameter zurückgegeben wird.
Exp()	Gibt die angegebene Potenz von e zurück.
Floor()	Gibt die nächst kleinere Ganzzahl zurück.
IEEERemainder()	Gibt den Rest einer Division zurück.
Log()	Gibt den Logarithmus einer angegebenen Zahl und Basis (wenn keine Basis angegeben ist, dann zur Basis e) zurück.
Log10()	Gibt den Logarithmus zur Basis 10 zurück.
Max()	Gibt die größere Zahl zweier Zahlen zurück.
Min()	Gibt die kleinere Zahl zweier Zahlen zurück.
Pow()	Potenziert zwei Zahlen.
Round()	Rundet eine angegebene Zahl auf die angegebenen Stellen.
Sign()	Gibt das Vorzeichen (-1 für Zahlen < 0, 0 für Zahlen = 0, +1 für Zahlen > 0) einer Zahl zurück.
Sin()	Gibt den Sinus eines Winkels (im Bogenmaß) zurück.
Sinh()	Gibt den Hyperbelsinus eines Winkels (im Bogenmaß) zurück.
Sqrt()	Gibt die Quadratwurzel einer Zahl zurück.
Tan()	Gibt den Tangens eines Winkels (im Bogenmaß) zurück.
Tanh()	Gibt den Hyperbeltangens eines Winkels (im Bogenmaß) zurück.

Wer nicht mehr weiß, wie man Grad ins Bogenmaß umrechnet und umgekehrt, hier die Formeln:

Bogenmaß = Winkel * (PI / 180)
Winkel = Bogenmaß * (180 / PI)

Sie können diese Methoden sofort verwenden, indem Sie Math.Methode(Parameter) schreiben.

2.4.6.2. Parsen

Wenn Sie einen String, der eine Zahl darstellt, wieder als Zahl verwenden wollen / müssen (z.B. für Berechnungen), dann haben Sie verschiedene Möglichkeiten:

• Casten (CInt & Konsorten)
• Die VB6-Funktion Val
• Parse-Methode des Datentyps

Das Casten ist zwar möglich, sobald aber ein Währungssymbol auftaucht funktioniert dies nicht mehr. Fällt also weg.

Die VB6-Funktion Val kann zwar Parsen, sie ist aber nicht länderabhängig, was einem ganz schönen Ärger einhandeln kann. Außerdem sollte man VB6-Funktionen in den „Ruhestand" schicken, weil man nie weiß, wie lange die nötigen DLLs mitgeliefert werden in zukünftigen Versionen.

Am besten ist die Parse-Methode, die wir uns auch näher betrachten wollen.

Die Parse-Methode
Die Parse-Methode wird von jedem Zahlentyp angeboten und in der einfachsten Form übergeben wir ihr einfach den Wert (oder Variable), der geparst werden soll.

Dim wert As Single
Dim s As String = "124,54"
 
wert = Single.Parse(s)
Console.WriteLine(wert)
 
wert = Single.Parse("1.12")
Console.WriteLine(wert)

Wie Sie sehen, werden bei der Parse-Methode die Ländereinstellungen berücksichtigt und wir müssen uns an diese halten.

Interessanter ist aber die Überladung, welche zwei Parameter annimmt. Mit dem zweiten Parameter können wir das Format des Strings angeben. Dazu ein Beispiel:

Console.WriteLine(Single.Parse("F0", _
  Globalization.NumberStyles.AllowHexSpecifier))

Mit Globalization.NumberStyles.AllowHexSpecifier geben wir an, dass auch Strings mit hexadezimalem Format akzeptiert werden. Um den Schreibaufwand etwas abzukürzen, kann man den Namespace System.Globalization importieren, womit das Globalization am Anfang wegfällt.

NumberStyles ist eine Enumeration (dazu später mehr), wovon AllowHexSpecifier nur ein möglicher Wert ist. Hier eine Übersicht:

Stil	Zweck
AllowCurrencySymbol	Gibt an, dass der String ein Währungssymbol enthalten kann (z.B. €, $ oder ₤).
AllowDecimalPoint	Gibt an, dass der String ein Dezimaltrennzeichen enthalten kann (entweder „." oder „,")
AllowExponent	Gibt an, dass der String auch einen Exponenten enthalten kann.
AllowHexSpecifier	Gibt an, dass der String hexadezimale Zeichen enthalten kann.
AllowLeadingSign	Gibt an, dass der String ein Vorzeichen enthalten kann.
AllowLeadingWhite	Gibt an, dass der String Leerzeichen/Zeilenumbrüche enthalten darf.
AllowParentheses	Gibt an, dass der String Klammern enthalten kann.
AllowThousands	Gibt an, dass der String Gruppentrennzeichen (z.B. zum Trennen der Hunderter von den Tausendern) enthalten kann.
AllowTrailingSign	Gibt an, dass der String mit einem Vorzeichen enden kann.
AllowTrailingWhite	Gibt an, dass der String Leerzeichen/Zeilenumbrüche am Ende enthalten kann.

Damit ist bereits einiges möglich. Wir können auch mehrere Werte angeben, indem wir diese mit Or verknüpfen. Auch gibt es einige Zahlenstile, die mehrere der obigen Werte zusammenfassen.

Gruppe	Zweck
Any	Setzt alle Stile außer AllowHexSpecifier.
Currency	Setzt alle Stile außer AllowExponent und AllowHexSpecifier.
Float	Setzt die Stile AllowLeadingWhite, AllowTrailingWhite,AllowLeadingSign, AllowDecimalPoint und AllowExponent.
HexNumber	Setzt die Stile AllowLeadingWhite, AllowTrailingWhite und AllowHexSpecifier.
Integer	Setzt die Stile AllowLeadingWhite, AllowTrailingWhite und AllowLeadingSign.
None	Setzt keinen der Stile.
Number	Setzt die Stile AllowLeadingWhite, AllowTrailingWhite, AllowLeadingSign, AllowTrailingSign, AllowDecimalPoint und AllowThousands.

Das ist alles, was man zur Parse-Methode wissen sollte.

2.4.7. String-Funktionen

Das .NET Framework enthält viele Bearbeitungsfunktionen für Strings, die in diesem Abschnitt vorgestellt werden sollen.

2.4.7.1. Der Nachteil von Strings
Strings haben den Nachteil, dass diese nach der Erzeugung unveränderlich sind. Wenn diese bearbeitet werden sollen, dann wird ein neuer String erstellt. Das bedeutet, dass diese Funktion langsamer sind, da die Erstellung Zeit beansprucht. Allerdings fällt diese kaum ins Gewicht, außer wenn Sie viele Stringbearbeitungen durchführen wollen / müssen. Aber dafür gibt es auch Abhilfe - die StringBuilder-Klasse. Diese arbeitet wesentlich schneller, bietet aber weniger Bearbeitungsfunktionen. Ich werde diese Klasse im Anschluss vorstellen.

2.4.7.2. Die String-Klasse
Der Datentyp String ist eigentlich nur eine Klasse des .NET Frameworks und diese enthält viele Bearbeitungsfunktionen. Ich möchte in folgender Tabelle mal alle Eigenschaften und Methoden nennen, aber wir schauen uns nicht alle im Detail an, sondern nur die wichtigsten:

Eigenschaften	Methoden
Chars,  Length	Compare, CompareOrdinal, Compare, Concat, Copy, CopyTo, EndsWith, Format, IndexOf, IndexOfAny, Insert, Join, LastIndexOf, LastIndexOfAny, PadLeft, PadRight, Remove, Replace, Substring, ToCharArray, ToLower, ToUpper, Trim, TrimEnd und TrimStart

Wie Sie sehen, gibt's allerhand zu bieten. Beginnen wir mit den Eigenschaften:

Chars
Diese Eigenschaft hat zwar einen Index, ist aber kein Array. Hiermit können Sie ganz einfach ein einzelnes Zeichens an einer bestimmten Position abrufen.

Length
Mit der Length-Eigenschaft rufen Sie die Länge des Strings ab.

Und nun die Methoden:

Compare
Mit der Compare-Methode können Sie zwei Strings vergleichen. Sie bekommen, je nach Ergebnis des Vergleiches, -1, 0 oder 1 zurückgeliefert.

Beim Vergleichen werden die Einstellungen des Computers berücksichtigt, z.B. bestimmte Buchstabenkombinationen werden als ein Buchstabe betrachtet oder die Unterscheidung zwischen Groß- und Kleinschreibung wird beachtet. Die beiden Zeichenketten werden buchstabenweise verglichen.

Wenn -1 zurückgeliefert wird, dann ist der erste String "kleiner" als der zweite, das bedeutet, der erste String weicht vom zweiten ab oder die beiden Strings sind gleich, aber der zweite ist länger.

Bei 0 sind die beiden Strings identisch.

Bei 1 ist der erste String "größer" als der zweite.

Sie müssen der Funktion mindestens zwei Parameter übergeben - nämlich die beiden Strings, die verglichen werden sollen. Über einen dritten Parameter können Sie angeben, ob die Groß- und Kleinschreibung beachtet werden soll. Dazu ein Beispiel:

Sub Vergleichen(ByVal s1 As String, ByVal s2 As String, ignoreCase As Boolean)
  ' Strings vergleichen und Ergebnis zwischenspeichern
  Dim result As Integer = String.Compare(s1, s2, ignoreCase)
  ' Ergebnis auswerten und Meldung ausgeben
  Select Case result
    Case -1
      Console.WriteLine("Der erste String ist 'kleiner'.")
    Case 0
      Console.WriteLine("Die Strings sind gleich.")
    Case 1
      Console.WriteLine("Der erste String ist 'größer'.")
  End Select
End Sub
 
Sub Main()
  ' String-Variablen deklarieren und initialisieren
  Dim s1 As String = "Hallo Welt"
  Dim s2 As String = "Hallo Welt aus VB.NET"
  Dim s3 As String = "hallo welt"
 
  ' Unsere Funktion aufrufen
  Vergleichen(s1, s2, False)
  Vergleichen(s1, s3, False)
  Vergleichen(s1, s3, True)
  Console.ReadLine()
End Sub

Das Programm erzeugt folgende Ausgabe:

Der erste String ist 'kleiner'.
Der erste String ist 'größer'.
Die Strings sind gleich.

Damit hätten wir diese Methode abgeschlossen. Es gibt zwar noch weitere Überladungen, aber diese beiden sollten ausreichen, um die Funktionsweise des Vergleiches zu vermitteln. Wenn die anderen Überladungen Sie interessieren, dann schauen Sie sich die .NET Dokumentation an.

CompareOrdinal
Diese Funktion macht äußerlich dasselbe wie die Compare-Funktion, nur der Vergleichsalgorithmus ist hier anders. CompareOrdinal vergleicht die Strings nach ihren Ordnungszahlen, die sie in der jeweiligen Codierung haben. Die Rückgabewerte sind dieselben, daher ist eine Erläuterung nicht notwendig. Die Nennung dient nur zur Vollständigkeitszwecken.

CompareTo
CompareTo vergleicht eine String-Variable mit einem Object oder einer anderen String-Variable und vergleicht nach demselben Muster wie Compare. Der Unterschied zu Compare liegt darin, dass Sie nur das Objekt angeben, mit dem die String-Variable verglichen werden soll:

Dim myString As String = "Dies ist mein String."
Dim myAnotherString As String = "Mein Text."
Dim result As Integer = myString.CompareTo(MyAnotherString)  ' ergibt 1

Concat
Diese Methode macht dasselbe, wie der &-Operator - sie verkettet Strings, oder die String-Darstellung eines Objektes, miteinander. Hier ein übertriebenes „Hello World"-Beispiel:

Dim Hello As String = String.Concat('H', 'e', 'l', 'l', 'o', _
  ' ', 'W', 'o', 'r', 'l', 'd', '!')

Copy
Erstellt eine Kopie eines Strings und gibt sie zurück. Dazu ein Beispiel:

Dim Kopie As String = String.Copy("kopieren")

CopyTo
Kopiert eine beliebige Anzahl von Zeichen eines Strings in ein Char-Array an einer beliebigen Position. Für das bessere Verständnis ein Beispiel dazu:

Dim source As String = "changed"
Dim destination As Char() = {"T"c, "h"c, "e"c, " "c, "i"c, "n"c, "i"c, _
  "t"c, "i"c, "a"c, "l"c, " "c, "a"c, "r"c, _
  "r"c, "a"c, "y"c}
 
' Char-Array ausgeben
Console.WriteLine(destination)
 
' String in Char-Array einfügen
source.CopyTo(0, destination, 4, source.Length)
 
' Resultierendes Char-Array ausgeben
Console.WriteLine(destination)

EndsWith
Überprüft, ob dieser String mit einer bestimmten Zeichenfolge endet.

Dim text As String = "Komm ich hier vor?"
Dim result As Boolean = text.EndsWith("vor")  ' Nein
result = text.EndsWith("vor?")                ' Ja

Format
Formatiert ein Objekt mit einem Formatierungs-String. Es können vordefinierte Formate verwendet werden oder auch eigene Formate können angewendet werden. Ich möchte hier ein paar vordefinierte Formate vorführen. Hier empfehle ich, einen Blick in die MSDN Library zu werfen.

Im ersten Codeschnipsel wird eine Decimalvariable als ein Währungsbetrag ausgegeben:

Dim val As Decimal = 99.95
Console.WriteLine(val.ToString("C"))

Eine Ganzzahl als hexadezimale Zahl auszugeben, ist auch nicht schwieriger:

Dim val As Integer = 995
Console.WriteLine(val.ToString("X"))

Es gibt noch weitere Formate, darunter sind u.a. Datums- und Zeitformate, kombinierte Formate und benutzerdefinierte Formate. Hier kann ich nur auf die MSDN Library verweisen.

IndexOf
IndexOf gibt die erste Position eines einzelnen Zeichens (Char) oder eines Strings an. Falls das / die Zeichen nicht gefunden wurde(n), dann wird -1 zurückgegeben. Optional ist die Angabe einer Startposition und / oder wie viele Zeichen untersucht werden sollen. Hier ein einfaches Beispiel:

Dim text As String = "Das ist ein String"
Dim position As Integer = text.IndexOf("s"c)    ' 2

Und noch ein weiteres:

Dim text As String = "Das ist ein String"
Dim position As Integer = text.IndexOf("s"c, 8) ' 12

IndexOfAny
IndexOfAny macht fast das selbe wie IndexOf - nur dass diese Variante nicht mit einem Zeichen oder einem String sucht, sondern mit einem Char-Array, von dem die erste Fundstelle eines beliebigen Zeichens aus dem Array zurück gegeben wird.

Insert
Wie man vermutet, fügt diese Methode einen String an einer gegebenen Position ein. Dazu ein kleines Beispiel:

Dim myString As String = "Der Hund"
Dim result As String = myString.Insert(8, " spielt im Garten")

Join
Wenn Sie ein String-Array haben und dieses wollen Sie in einen String packen, bei dem die Elemente durch einen Seperator getrennt sind, dann verwenden Sie die Join-Methode, denn diese macht das. Hier ein Codebeispiel:

Dim TierArray() As String = {"Hund", "Katze", "Vogel"}
Dim Tiere As String = String.Join(", ", TierArray)

Dieses Codebeispiel ergibt die Codeausgabe „Hund, Katze, Vogel".

LastIndexOf und LastIndexOfAny
Diese Methoden machen dasselbe wie ihre Verwandten ohne den Zusatz "Last" zu Beginn: sie suchen das Vorkommen eines Zeichens oder von mehreren. Nur dass LastIndexOf(Any) nach dem letzten Vorkommen sucht und nicht nach dem ersten. Dies ist aber auch der einzige Unterschied, so dass ich mir ein Beispiel spare.

PadLeft und PadRight
Diese Methoden richten einen String links- bzw. rechtsbündig aus. Man gibt die Länge des Strings an, die er mit Füllzeichen belegen soll und optional das Füllzeichen. Hier ein Beispiel, wie eine Zeichenkette rechtsbündig ausgerichtet wird:

Dim MyText As String = "Rechtsbündig ausgerichteter Text"
Dim Rechtsbündig As String = MyText.PadRight(60)

Remove
Wenn Sie Zeichen entfernen wollen, dann verwenden Sie diese Methode. Sie geben an, ab welcher Stelle Zeichen gelöscht werden sollen und wie viele. Dazu ein Beispiel:

Dim Text As String = "Ich enthalte viel Text"
Dim Gelöscht As String = Text.Remove(14, 5)

Diese Codezeilen erzeugen den String „Ich enthalte Text".

Replace
Zeichenersetzung können Sie hiermit machen. Sie geben an, welche Zeichen ersetzt werden sollen und womit und schon sind Sie fertig. Auch dazu ein Codebeispiel:

Dim oldString As String = "Das ist ein Fehler"
Dim newString As String = oldString.Replace("Das", "Dies")

Und raus kommt der String „Dies ist ein Fehler".

Split
Split macht das Gegenteil von Join. Sie rufen die Split-Methode eines Strings auf, übergeben ihr die Trennzeichen (Char-Array) und bekommen ein String-Array zurück.

StartsWith
Kurz und bündig: Diese Methode macht dasselbe wie EndsWith(), nur dass der Anfang überprüft wird und nicht das Ende.

Substring
Mit Substring() können Sie eine Teilzeichenfolge extrahieren. Sie geben Startposition an und optional, wie viele Zeichen Sie extrahieren wollen, hier ein Beispiel:

Dim Text As String = "Dies ist ein Text"
Dim Extract As String = Text.SubString(14)      ' Text
Dim Extract2 As String = Text.SubString(6, 3)   ' ist

ToCharArray
Hier passiert nicht viel, nur dass der String in ein Char-Array konvertiert wird.

ToLower und ToUpper
Konvertiert einen String in Klein- bzw. Großbuchstaben. Auch diese Methoden sind nicht schwierig, daher schenke ich mir ein Codebeispiel.

TrimStart, TrimEnd und Trim
Wenn Sie bestimmte Zeichen eines Strings entfernen wollen, dann verwenden Sie diese Methoden. TrimStart() entfernt alle Vorkommen der zu löschenden Zeichen nur am Anfang, TrimEnd() nur am Ende und Trim() löscht diese am Anfang und Ende.

2.4.7.3. Die Klasse StringBuilder
Die StringBuilder-Klasse kann Stringoperationen wesentlich schneller durchführen als die „normalen" Strings. Allerdings besitzt die StringBuilder-Klasse weniger Möglichkeiten als die String-Klasse.

Eigentlich stellt die StringBuilder-Klasse eine veränderliche Zeichenfolge dar. Sie reserviert dynamisch Speicher. Wie viel Speicher reserviert wird, können Sie mit der Capacity-Eigenschaft festlegen. Den maximalen Speicherverbrauch können Sie über die Eigenschaft MaxCapacity festlegen.

Wollen Sie gezielt ein Zeichen abrufen oder ändern, können Sie dies über die Chars-Eigenschaft machen. Strings können Sie mit Append() oder formatiert mit der AppendFormat()-Methode an das Ende des internen Strings anhängen. Wenn Sie an einer bestimmten Position etwas einfügen möchten, dann gelingt dies über die Insert()-Methode. Mit Remove() können Sie Zeichen entfernen und mit Replace() können Sie Zeichen ersetzen.

Wenn Sie einen "normalen" String brauchen, dann rufen Sie die ToString()-Methode auf.

Allerdings existiert keine Clear()-Methode, durch die Sie den enthaltenden Text löschen können. Dies können Sie erreichen, indem Sie die Length-Eigenschaft auf 0 setzen.

Die Verwendung von StringBuilder ist einfach und stellt keine Probleme dar. Daher spare ich mir hier ein Beispiel zur Anwendung.

2.4.7.4. Benchmarks

Ich habe Ihnen ja am Anfang gesagt, dass die StringBuilder-Klasse performanter ist, als "normale" Strings.

Dies möchte ich Ihnen an Hand einer Windowsanwendung verdeutlichen. Hier ein paar Daten zu den Testbedingungen:

• Windows XP Professional mit SP2
• 1,25 GB RAM
• AMD Athlon XP 2100+
• Visual Basic 2005 Beta 2, da diese die StopWatch-Klasse enthält, mit der man gut Zeiten messen kann.

Der wichtigste Code ist eine Schleife, die so aussieht:

For i As Integer = 0 To MaxDurchläufe
  str1 &= i.ToString()
  ' bei StringBuilder steht hier sb1.Append(i)
Next

MaxDurchläufe ist eine Variable, welche die Schleifendurchgänge speichert, die beim Programmbeginn abgefragt wurde. Ich habe dies mit 10, 100, 1000, 10000, 50000 und 100000 Schleifendurchgängen mit je 5 Durchläufen getestet. Warum 5 Durchläufe und nicht einen? Weil der erste Durchlauf verfälscht ist, da beim ersten Durchlaufen der MSIL-Code in Maschinencode kompiliert wird, was natürlich Zeit kostet. Wen der Code interessiert, der kann hier das VB2005-Projekt downloaden.

Getestet wurde mit einem Release-Build (optimiert) und folgende Zeiten wurden gemessen:

Durchläufe	String	StringBuilder
10	00:00:00:0000120	00:00:00:0000120
	00:00:00:0000044	00:00:00:0000047
	00:00:00:0000050	00:00:00:0000044
	00:00:00:0000050	00:00:00:0000044
	00:00:00:0000044	00:00:00:0000044
100	00:00:00:0001095	00:00:00:0000611
	00:00:00:0000877	00:00:00:0000354
	00:00:00:0015951	00:00:00:0000346
	00:00:00:0000516	00:00:00:0000472
	00:00:00:0000609	00:00:00:0000354
1000	00:00:00:0070341	00:00:00:0004310
	00:00:00:0047545	00:00:00:0004039
	00:00:00:0048349	00:00:00:0004159
	00:00:00:0047472	00:00:00:0004173
	00:00:00:0047086	00:00:00:0009199
10000	00:00:00:9855344	00:00:00:0051579
	00:00:00:9645837	00:00:00:0050241
	00:00:01:0218924	00:00:00:0051769
	00:00:00:9776541	00:00:00:0051305
	00:00:00:9754591	00:00:00:0048151
50000	00:01:05:9246057	00:00:00:0288478
	00:01:05:9959427	00:00:00:0330223
	00:01:05:9446250	00:00:00:0305024
	00:01:05:9601901	00:00:00:0288760
	00:01:05:9046535	00:00:00:0269576
100000	00:04:34:0580387	00:00:00:0592164
	00:04:34:5015000	00:00:00:0535716
	00:04:34:8889939	00:00:00:0583928
	00:04:34:7581608	00:00:00:0832891
	00:04:35:0719507	00:00:00:0565904

Die schnellsten und langsamsten Durchgänge habe ich farblich hervorgehoben und man erkennt, dass ab 100 / 1000 Schleifendurchgänge die StringBuilder-Klasse ersichtlich schneller arbeitet als die Strings. Bei 100000 Durchläufen brauchen die Strings etwas über 4½ Minuten, bei StringBuilder ist selbst der langsamste Durchgang mit einer knappen zehntel Sekunde ungefähr 2700-mal schneller als die Strings!

Die Zeiten von StringBuilder könnte man noch etwas optimieren, indem man angibt, wie viel Speicher reserviert werden soll; so könnte man noch ein paar tausendstel Sekunden herausholen, aber selbst diese "Rohwerte" sind schon sehr gut.

Fazit: Wenn Sie viele Stringbearbeitungen ausführen wollen / müssen, dann lohnt sich der Einsatz der StringBuilder-Klasse, wodurch Sie in diesen Punkt eine hohe Performance erreichen. Allerdings gehört zum Punkt Performance nicht nur eine schnelle Zugriffszeit, sondern es spielen auch andere Faktoren eine Rolle, wie z.B. auch Speicherverwendung. Dies und weitere, können Sie mit Profiling-Tools testen und überprüfen und Ihren Code auf die entdeckten Schwachstellen optimieren.

2.5. Enumerationen

Nach dem recht umfangreichen Teil zu Prozeduren und Funktionen kommt jetzt erst mal etwas Leichteres zum "Verdauen". Merken Sie sich das zu Prozeduren und Funktionen aber gut, dies werden wir bei "Klassen und Objektorientierung" wieder brauchen, also gut merken.

Aber zurück zu diesem Thema. Enumerationen, manchmal findet man auch den Begriff "Auflistungen", fassen verwandte Konstanten unter einen Namen zusammen. Schauen wir uns das mal an einem Beispiel an:

Enum Days
  Montag
  Dienstag
  Mittwoch
  Donnerstag
  Freitag
  Samstag
  Sonntag
End Enum

So sieht eine Enumeration (kurz Enum) aus. Ich habe doch vorhin gesagt, Enumerationen sind verwandte Konstanten. Jetzt müssten Sie sich fragen, wo ist denn der Wert der Konstante? Falls Sie explizit keine Werte angeben, dann hat die erste Konstante den Wert 0, die nächste 1, …

Wenn man noch eine Konstante hinzufügen möchte, die einen ungültigen Wert repräsentiert, dann gibt man ihr meistens den Wert -1. Enums sind immer von einem ganzzahligen Typ, standardmäßig von Integer. Wollen Sie einen anderen Typ erzwingen, setzen Sie nach dem Bezeichner der Enum den Typ mit einer As-Klausel an:

Enum Days As Byte
  ' ...
End Enum

Mit einer Enumeration haben Sie einen neuen Typ definiert, daher ist folgendes ohne weiteres möglich:

Dim Tage As Days
Dim Montag As Days = Days.Montag

Diesen Typ können Sie überall verwenden, auch als Parameter in Prozeduren oder Funktionen, überall dort, wo eine As-Klausel steht. Enums werden Ihnen öfters begegnen als Sie denken (in Windows-Anwendungen, Dateizugriff oder beim Zeichnen / Drucken). Sie sind aber eigentlich leicht zu verstehen und anzuwenden, spätestens nach der ersten kleinen Beispielanwendung zum Thema Windows Forms dürften Sie keine Fragen mehr haben.

2.6. Der Gültigkeitsbereich von Variablen

In diesen Abschnitt soll es um den Gültigkeitsbereich von Variablen gehen. Was Sie hier lernen, gilt auch für Objekte.

2.6.1. Was ist ein Block?

In anderen Sprachen, wie z.B. C#, ist leicht zu erkennen, was ein Block ist, da er durch {} umschlossen wird. In VB.NET ist dies durch Schlüsselwort…End Schlüsselwort gelöst worden. Also Sub…End Sub, Function…End Function, Class…End Class und Enum…End Enum stellen Blöcke dar. Soviel zu den Blöcken, machen wir mal weiter.

2.6.2. Was ist ein Gültigkeitsbereich?

Der Gültigkeitsbereich einer Variable gibt an, in welchen Blöcken (jetzt wissen Sie, warum ich als erstes erklärt habe, was ein Block ist) sie verwendet werden kann. Dabei gilt der Gültigkeitsbereich ab dem Block, wo die Variable deklariert wurde und in allen enthaltenen Blöcken. Dazu ein Beispiel:

Module MainModule
  Dim a As Integer              ' überall gültig
  Sub Main()
    Dim i As Double             ' nur in Sub Main() gültig
    For j As Integer = 0 To 100
      Dim ii As Double          ' nur in der Schleife gültig
    Next i
  End Sub
End Module

Auf die Variable a können Sie im gesamten Programm zugreifen, auf die Variable i hingegen nur innerhalb der Main-Prozedur. Und ii darf nur innerhalb der For-Schleife verwendet werden. Was passiert, wenn Sie auf eine Variable außerhalb ihres Gültigkeitsbereichs zugreifen? Sie erhalten einen Fehler!

2.6.2.1. Den Gültigkeitsbereich anpassen
Sie können den Gültigkeitsbereich mit den Modifizierern Public, Protected, Friend, Protected Friend und Private anpassen. Diese steuern, wie die einzelnen Elemente (Prozeduren, Funktionen, Variablen, …) aufeinander zugreifen können.

2.6.2.2. Der Modifizierer Public
Public gibt an, dass das Element uneingeschränkten Zugriff besitzt, dass es also von überallher verwendet werden kann. Man spricht auch davon, dass Public öffentlichen Zugriff erlaubt. Dazu ein Codebeispiel:

Public Module Modul
  Public Sub Methode()
    Console.WriteLine("Public method")
  End Sub
 
  Public Variable As Integer = 10
End Module
 
Public Module MainModule
  Public Sub Main()
    Methode()
    Variable += 15
    Console.WriteLine("Public Variable = " & _
    Variable.ToString()
  End Sub
End Module

Wie Sie sehen, können Sie in der Main()-Methode auf die enthaltenden Elemente des Moduls PublicModul zugreifen.

2.6.2.3. Der Modifizierer Private
Private ist das Gegenteil von Public - es erlaubt den Zugriff nur auf den Deklarationskontext. Das klingt recht kompliziert, daher schauen wir uns das an einem Codebeispiel an:

Public Module Modul
  Private variable As Integer = 10
 
  Public Sub Methode()
    Console.WriteLine("Public method")
    Console.WriteLine("Private Variable = " & variable.ToString())
  End Sub
End Module
 
Public Module MainModule
  Public Sub Main()
    Methode()       ' funktioniert, da Public
    variable += 15  ' Fehler, da als Private in Modul deklariert->
                    ' keinen Zugriff
  End Sub
End Module

Alles klar? Dann zum nächsten Modifizierer.

2.6.2.4. Der Modifizierer Protected
Protected bedeutet geschützt. Geschützt bezieht sich darauf, dass das Element nicht außerhalb seines Deklarationskontextes manipuliert werden kann. Natürlich können Sie jetzt sagen, das macht Private auch. Stimmt, nur ermöglicht Protected den Zugriff auch für abgeleitete Klassen.

Wir gehen im Abschnitt über Vererbung noch einmal genauer auf Protected ein. Bis dahin ist für Sie Protected und Private mehr oder weniger dasselbe

2.6.2.5. Der Modifizierer Friend
"Auf Friend-Elemente kann vom Programm, das ihre Deklaration enthält, und von jeder Stelle in derselben Assembly zugegriffen werden." - so wird Friend in der Dokumentation von Microsoft definiert.

Unterschiede zwischen Public und Friend zeigen sich nur, wenn man auf Elemente einer anderen Assembly (im .NET-Jargon heißen Anwendungen Assemblys) verwenden möchte. Friend verhindert den Zugriff außerhalb der Assembly, wo hingegen Public dies erlaubt.

2.6.2.6. Der Modifizierer Protected Friend
Dieser ist schnell erklärt: Er ist die Kombination aus Protected und Friend. Zugriff haben Sie, wenn die Bedingungen eines Modifizierers erfüllt sind.

2.6.3. Die Lebensdauer von Variablen

Die Lebensdauer einer Variable gibt an, wie lange diese sich im Speicher befindet. Sie hängt oft mit dem Gültigkeitsbereich einer Variable zusammen. Schauen wir uns obiges Beispiel noch mal an:

Module MainModule
  Dim a As Integer              ' überall gültig
  Sub Main()
    Dim i As Double             ' nur in Sub Main() gültig
    For j As Integer = 0 To 100
      Dim ii As Double          ' nur in der Schleife gültig
    Next i
  End Sub
End Module

Variable ii wird nach dem Verlassen der Schleife aus dem Speicher entfernt, terminiert. Die in der Sub Main() deklarierte Variable i wird nach dem Verlassen der Sub terminiert, also beim Programmende, und a wird ebenfalls beim Programmende zerstört.

Fassen wir bis hierher mal zusammen: Sobald eine Variable ihren Gültigkeitsbereich verlässt, wird diese gnadenlos zerstört.

Falls man aber dieser "Ungerechtigkeit" entgegen wirken möchte, kann man das Schlüsselwort Static bei der Deklaration verwenden, um zu erzwingen, dass eine Variable nach dem Verlassen ihres Gültigkeitsbereichs nicht terminiert wird, sondern im Speicher verbleibt. So eine Deklaration sieht dann so aus:

Static Dim immortal As Integer

Die Verwendung von Static ist nur innerhalb von Prozeduren / Funktionen oder Eigenschaften erlaubt.

Schön, wir können jetzt die Lebensdauer von Variablen verlängern, aber gibt es auch Nachteile? Ja, die gibt es:

• Es muss geprüft werden, ob sich die Variable schon im Speicher befindet, dies kostet Zeit
• Die Variable belegt Speicher bis zum Programmende, wodurch der Speicherverbrauch des Programms steigt

Der Speicherverbrauch von ein paar Integers & Co. ist zwar nicht sonderlich gravierend, aber wenn es Strings, Arrays oder Objekte sind, dann hört der Spaß auf. Daher vermeiden Sie möglichst Static, besonders bei "großen Boliden", aber manchmal ist es sehr nützlich und auch die einzige Möglichkeit, ein bestimmtes Problem zu lösen. Aber übertreiben Sie es nicht!

2.7. Klassen und Objektorientierung

Jetzt kommen wir zum umfangreichsten, aber auch zum wichtigsten Thema, nämlich zu Klassen und Objektorientierung. Wenn Sie Klassen und Objektorientierung nicht verstehen, dann werden Sie mit .NET keine Freude haben.

Erst mal ein Überblick, was wir behandeln werden:

• Begriffe „Klasse" und „Objekt" klären
• Einfache Klassen erstellen
• Schnittstellen (Interfaces)
• Vererbung
• Überladung, Überschreibung, Überschattung

Das ist sehr viel, obwohl das Thema Ereignisse und -Behandlung fehlt (wird im Abschnitt 2.8 behandelt). Aber keine Sorge, wir werden uns langsam an die "Geheimnisse" vorantasten.

2.7.1. Klassen und Objekte - was ist das?

Als erstes müssen wir klären, was eine Klasse ist und was ein Objekt.

Eine Klasse ist die symbolische Darstellung von Objekten. Sie definieren die Elemente eines Objektes (Felder (=Variablen), Methoden (=Prozeduren und Funktionen) und Ereignisse), wie ein Bauplan die Elemente eines Gebäudes beschreibt.

Sie können mit einem Bauplan beliebig viele Gebäude errichten. Genauso können Sie mit einer Klasse beliebig viele Objekte erstellen, man spricht von instanzieren.

2.7.2. Einfache Klassen erstellen

In diesem Abschnitt soll es um das Erstellen von einfachen Klassen gehen. Wir werden uns das Erstellen einer Klasse im Ganzen zuerst anschauen, danach gehen wir detailliert auf die einzelnen Codezeilen ein.

2.7.2.1. Überblick über das Erstellen von Klassen
Ich möchte nicht rumlabern, sondern wir schauen uns gleich Code an. Folgender Code kommt in die Datei ClassTest.vb:

Option Strict On
 
Imports System
 
Public Class Cube
  Private r As Double  ' speichert den Radius
 
  ' Konstruktoren
  Public Sub New()
    r = 1
  End Sub
 
  Public Sub New(ByVal radius As Double)
    If radius > 0 Then
      r = radius
    Else
      r = 1 
    End If
  End Sub
 
  ' Eigenschaft Radius
  Public Property Radius() As Double
    Get
      Return r
    End Get
    Set(ByVal value As Double)
      If value > 0 Then
        r = value
      End If
    End Set
  End Property
 
  ' Methoden zum Berechnen des Volumens und der Oberfläche
  Public Function CalcVolumen() As Double
    Return 4 / 3 * Math.PI * r ^ 3
  End Function
 
  Public Function CalcOberfläche() As Double
    Return 4 * Math.PI * r ^ 3
  End Function
End Class

Und dieser Code kommt in die Datei MainModule.vb:

Option Strict On
 
Imports System
 
Public Module MainModule
  Public Sub Main()
    ' Klassen instanzieren
    Dim kugel1 As New Cube()
    Dim kugel2 As New Cube(2.5)
 
    ' Volumen und Oberfläche berechnen und speichern
    Dim v1, v2, o1, o2 As Double
    v1 = kugel1.CalcVolumen()
    v2 = kugel2.CalcVolumen()
    o1 = kugel1.CalcOberfläche()
    o2 = kugel2.CalcOberfläche()
 
    ' Konsole mit Text "füttern"
    Console.WriteLine("Diese Anwendung ist ein Beispiel zur Verwendung von Klassen.")
    Console.WriteLine()
    Console.WriteLine("Folgende Kugeln werden verwendet:")
    Console.WriteLine("Kugel1 hat einen Radius von {0}.", kugel1.Radius)
    Console.WriteLine("Kugel2 hat einen Radius von {0}.", kugel2.Radius)
    Console.WriteLine()
    Console.WriteLine("Es wird das Volumen berechnet:")
    Console.WriteLine("Volumen der 1.Kugel: " & v1.ToString())
    Console.WriteLine("Volumen der 2.Kugel: " & v2.ToString())
    Console.WriteLine()
    Console.WriteLine("Es wird die Oberfläche berechnet:")
    Console.WriteLine("Oberfläche der 1.Kugel: " & o1.ToString())
    Console.WriteLine("Oberfläche der 2.Kugel: " & o2.ToString())
    Console.WriteLine()
    Console.Write("Zum Beenden drücken Sie Enter...")
    Console.ReadLine()
  End Sub
End Module

Wie Sie sehen, ist dies Ihr erstes Programm, welches aus zwei Dateien besteht. Man könnte zwar auch alles in eine Datei schreiben, aber da verliert man sehr schnell den Überblick, da es bei Ihren zukünftigen Programmen nicht bei einer Klasse und einem Modul bleiben wirdJ.

Nun beginnen wir mit der Code-Erklärung:

Die Option-Anweisung und die Imports-Anweisung sind nichts Neues, daher beginnen wir mit der neuen Class-Anweisung. Public kennen Sie schon - er sorgt dafür, dass die Klasse öffentlich ist. Nach dem Zugriffsmodifizierer folgt das Class-Schlüsselwort gefolgt von den Namen der Klasse.

Sie haben den Namen der neuen Klasse festgelegt sowie deren Gültigkeitsbereich. Jetzt legen Sie die Funktionalität fest. Mit der Zeile

Private r As Double

legen Sie ein Feld (= Variable) an. Diese wird den Radius speichern. Warum ist das Feld Private und nicht Public? Ganz einfach, weil Sie bei einem öffentlichen Feld keine Möglichkeit hätten, die Wertzuweisung zu beeinflussen. Wie Sie jetzt aber dafür sorgen, dass der Radius von außen änderbar ist, lernen Sie gleich kennen.

Die Sub New()-Prozeduren sind die s.g. Konstruktoren der Klasse. Diese werden aufgerufen, wenn die Klasse erstellt wird. In den Konstruktoren können Sie (und sollten Sie auch) Initialisierungen durchführen. In dem parameterlosen Konstruktor wird der Radius auf 1 gesetzt. Sie können auch Konstruktoren erstellen, die beliebig viele Parameter enthalten. Also das Überladen ist möglich.

WICHTIG: Wenn Sie den Konstruktor überladen, dürfen Sie das Overloads-Schlüsselwort NICHT verwenden.

Der zweite Konstruktor weist dem Feld r einen beliebigen Radius zu. Zuerst aber überprüft er, ob der Radius wirklich größer als 0 ist. Nur dann wird dieser gespeichert, ansonsten wird er auf 1 festgelegt. Nach den beiden Konstruktoren wird eine Eigenschaft (im englischen Property) definiert. Und über so eine Eigenschaft ermöglichen wir es, unser Radius-Feld nach außen hin sichtbar zu machen. Schauen wir uns die Eigenschaft mal genauer an.

Public Property Radius() As Double
  Get
    Return r
  End Get
  Set(ByVal value As Double)
    If value > 0 Then
      r = value
    End If
  End Set
End Property

Als erstes legen Sie den Gültigkeitsbereich fest - hier Public. Danach kommt das Property-Schlüsselwort, gefolgt von den Namen der Eigenschaft. Brauchen Sie noch einen Parameter (z.B. einen Index für ein Array oder eine Collection)? Dann geben Sie ihn in das Klammernpaar ein. In diesem Beispiel benötigen wir so was nicht, daher ein leeres rundes Paar Klammer (aber die Klammern müssen sein). Danach geben Sie den Typ der Eigenschaft an.

Da Sie die Eigenschaft nicht näher spezialisiert haben (also ReadOnly oder nur WriteOnly, dazu später mehr), müssen jetzt die s.g. Accessoren Get und Set folgen. Diese regeln den Lesezugriff (Get) und den Schreibzugriff (Set). Bei Get geben wir den Wert unseres Feldes einfach mit Return zurück. Set besitzt immer einen Parameter, welcher den neuen Wert speichert. Wie Sie diesen nennen, ist egal, aber die Bezeichnung value ist geläufig. Auch hier wird zuerst geprüft, ob dieser größer 0 ist, wenn ja, wird er gespeichert.

Danach werden noch zwei Methoden (=Prozeduren oder Funktionen) definiert, die das Volumen und die Oberfläche berechnen. Dieser Code stellt nichts Neues dar, daher müssten Sie ihn ohne Probleme verstehen.

Herzlichen Glückwunsch, Sie haben Ihre erste Klasse erstellt!

Jetzt stellt sich die Frage: Wie verwende ich diese? Dies haben wir im Code der Main-Prozedur. Und dort sind diese Zeilen interessant:

Dim kugel1 As New Cube()
Dim kugel2 As New Cube(2.5)

Mit diesen Zeilen erstellen Sie zwei Instanzen Ihrer Klasse. Wie Sie sehen, unterscheidet sich eine Instanzierung gegenüber einer Variablendeklaration nur durch das New. Damit haben Sie zwei Instanzen mit den Namen kugel1 und kugel2. Diese besitzen auch die definierten Methoden und Eigenschaften. Um auf ein Feld, Methode oder Eigenschaft einer Instanz zuzugreifen, geben Sie die Instanz ein, gefolgt von dem Punkt-Operator. Der Rest der Main-Prozedur ist Ausgabe auf der Konsole, also nichts, was man erklären muss.

Sie haben jetzt an einem Beispiel das Definieren von Klassen und ihrer Anwendung gelernt. Jetzt wollen wir uns das Erstellen von Klassen genauer betrachten.

2.7.2.2. Klassen definieren
Eine Klassendefinition beginnt mit dem Class-Schlüsselwort und endet mit End Class. Es kann auch ein Zugriffsmodifizierer vorangestellt werden. Mehr gibt es zu der ersten Zeile noch nicht zu sagen, daher schauen wir uns jetzt die einzelnen Member genauer an.

2.7.2.3. Felder
Felder sind nichts Anderes als Variablen (oder Konstanten). Sie machen das gleiche wie Eigenschaften, aber man kann das Abrufen oder Ändern von ihnen nicht beeinflussen.

Felder werden meistens benutzt, um Informationen intern einer Klasse zu speichern. Um diese Informationen nach außen zu geben, verwendet man Eigenschaften. Daher werden Felder meistens mit den Modifizierern Private oder Protected versehen, Public hingegen selten. Das Schlüsselwort Dim entspricht Private.

Interessant sind noch die Modifizierer ReadOnly und WriteOnly, damit kann man schreibgeschützte bzw. lesegeschützte Felder erstellen. Wie die Namen einem schon verraten, kann man bei ReadOnly-Felder nur lesen, bei WriteOnly nur schreiben. Die Verwendung für ReadOnly-Felder dürfte klar sein - sie bietet sich an, wenn sich ein Wert nach der Erstellung nicht mehr ändern darf. Für WriteOnly-Felder fällt mir keine Verwendung ein, aber es wird schon seine Daseinsberechtigung haben . Zum Abschluss ein Paar öffentliche Felder, die die Möglichkeiten zeigen:

Public autoFarbe As Color
Public ReadOnly PI As Double = 3.14159265358979323846

2.7.2.4. Eigenschaften
Da ich Eigenschaften (oder im englischen Properties) oben schon angesprochen habe, möchte ich diese gleich "nachliefern".

Mit Eigenschaften haben Sie die Möglichkeit, den Zugriff (egal ob lesend oder schreibend) zu beeinflussen. Sie sind nichts Anderes als zwei Methoden - eine Get-Methode zum Lesen des Wertes und eine Set-Methode zum Setzen des Wertes. Properties werden meistens dafür eingesetzt, um private Felder nach außen "freizugeben". Hier ein Beispiel für eine Property:

Private _carColor As Color
Public Property CarColor() As Color
  Get
    Return _carColor
  End Get
  Set(ByVal Value As Color)
    _carColor = Value
  End Set
End Property

Dies ist ein einfaches Beispiel für eine Eigenschaft. Sie sorgt dafür, dass das private Feld _carColor nach außen verfügbar ist, da die Property selber ja als Public deklariert ist.

In der Get-Prozedur wird einfach der Inhalt des privaten Feldes mit Return zurückgegeben. Der Set-Teil verfügt über einen Parameter, welcher den neuen Wert enthält. Wie Sie ihn nennen, ist in VB.NET egal, aber die Bezeichnung Value hat sich bewährt. Hier wurde auf eine Überprüfung des neuen Wertes verzichtet, aber dafür möchte ich gleich ein Beispiel nachliefern:

Private _nenner As Long
Public Property Nenner() As Long
  Get
    Return _nenner
  End Get
  Set(ByVal Value As Long)
    If Value <> 0 Then _nenner = Value 
  End Set
End Property

Hier wurde eine Eigenschaft Nenner deklariert (z.B. aus einer Bruch-Klasse). Wenn der Wert nun neu gesetzt werden soll, wird zuerst geprüft, ob der Wert ungleich 0 ist. Und nur wenn dieser ungleich 0 ist, wird der neue Wert gespeichert, ansonsten passiert nichts (Merke: Der Nenner eines Bruches darf nicht 0 sein, das wäre sonst gleichbedeutend mit einer Division durch 0 und diese geht nicht).

Sie haben ReadOnly- und WriteOnly-Felder kennen gelernt, so was gibt es auch für Eigenschaften. Diese sehen dann so aus:

Public ReadOnly Property ReadOnlyProp() As Integer
  Get
    ' …
  End Get
End Property
 
Public WriteOnly Property WriteOnlyProp() As Integer
  Set(ByVal Value As Integer)
    ' …
  End Set
End Property

Die genaue Implementierung der Eigenschaft habe ich jetzt mal weggelassen, da diese unerheblich ist. Wie Sie sehen, finden Sie bei einer ReadOnly-Property nur einen Get-Block, bei einer WriteOnly-Property nur einen Set-Block (was für eine Überraschung ).

Das war's! Mehr gibt es zu Eigenschaften nicht zu sagen. Und weiter geht's in der lustigen OOP-Welt .

2.7.2.5. Methoden
Methoden sind nichts Anderes als Prozeduren / Funktionen und werden auch genauso deklariert. Es gibt keine Unterschiede zwischen denen in einem Modul oder einer Klasse. Daher wäre ich jetzt mit den Methoden auch schon wieder fertig . Gleichzeitig wissen Sie jetzt bereits schon alles, um eigene, "einfache" Klassen zu erstellen. Jetzt kommen nur noch Feinheiten hinzu.

2.7.3. Eigene Klassen verwenden

Wenn Sie Ihre eigenen Klassen auch verwenden möchten, dann müssen Sie zuerst ein Objekt von Ihrer Klasse erstellen. Dieser Vorgang wird als instanzieren bezeichnet. Es ist einfach, und so gehen Sie vor.

Zuerst erstellen Sie eine Variable, welche die Instanz der Klasse dann enthalten soll. Dabei gehen Sie so vor, wie bei ganz normalen Variablen. Sie legen den Variablennamen fest. Als Datentyp geben Sie den Namen der Klasse an:

Dim instanz As Bruch

Diese Codezeile erzeugt eine Variable mit dem Namen Instanz (Variablennamen) vom Typ Bruch (selbstdefinierte Klasse). Wenn Sie jetzt aber versuchen würden, Felder, Eigenschaften oder Methoden der Klasse zu verwenden, würden Sie eine NullReferenceException erhalten. Diese besagt, dass die Variable auf kein gültiges Objekt verweist. Sie zeigt auf Nothing (also nichts, in anderen Sprachen als Null bezeichnet). Um nun eine Instanz zu erzeugen, müssen Sie das New-Statement verwenden:

instanz = New Bruch(…)

Das New-Statement sorgt dafür, dass eine Instanz erzeugt wird. Jetzt können Sie die Member der Klasse verwenden. Die drei Pünktchen sollen die Argumente für den Konstruktor darstellen, vorausgesetzt, der Konstruktor erfordert Argumente.

Wem die zwei Codezeilen zu viel sind, der kann auch eine etwas kompaktere Schreibweise verwenden:

Dim instanz As New Bruch(…)

Ich werde standardmäßig diese kurze Schreibweise verwenden, welche Sie verwenden, ist aber Ihnen überlassen. Am Ende kommt aber immer dasselbe heraus.

2.7.4. Shared Member

Sie kennen die Math-Klasse, mit den vielen mathematischen Methoden. Diese können Sie einfach aufrufen, ohne vorher eine Instanz von ihr erstellen zu müssen. Können wir das auch? Natürlich können wir das auch, dafür gibt es das Shared-Schlüsselwort.

Was macht aber Shared? Es sorgt dafür, dass ein Member unabhängig von einer bestimmten Instanz ist. Ein Shared-Member existiert nur einmal und Änderungen an ihr gelten für alle. Shared können Sie für alle Member anwenden. Es wird einfach hinter den Zugriffsmodifizierer geschrieben und fertig ist der Shared-Member . Das ist so einfach, dass ich mir die Beispiele spare.

2.7.5. Vererbung

Das Basiswissen zu Klassen besitzen Sie nun, jetzt schauen wir uns das Thema Vererbung an. Im Gegensatz zu VB6 können Sie Klassen vererben - aber so spektakulär ist dies gar nicht. Denn immer, wenn Sie mit Windows-Anwendungen entwickeln, ist Vererbung im Spiel. Aber das nur am Rande.

2.7.5.1. Sinn von Vererbung
Der Sinn der Vererbung ist es, Code wieder zu verwenden. Der Vorteil gegenüber dem berühmten Copy&Paste-Verfahren ist der, dass Sie bei Änderungen (z.B. bei Fehlerkorrekturen oder Erweiterungen) den Code nur einmal ändern brauchen und nicht in jeder Datei, in der Sie den Code eingefügt haben.

Sie können Code erweitern oder komplett neu implementieren. Dies bezeichnet man als überschreiben (override). Und dann existiert noch das Überschatten (shadows). Aber wir werden uns gleich näher mit überschreiben und überschatten beschäftigen.

2.7.5.2. Vererbung - ein Beispiel
Am folgenden Beispiel soll das Prinzip der Vererbung erläutert werden.

Public Class Buch
  Protected _titel As String
  Protected _preis As Decimal
  Protected _autor As String
  Protected _seiten As Integer
 
  Public Sub New()
  End Sub
 
  Public Sub New(ByVal titel As String, ByVal autor As String, _
    ByVal preis As Decimal, ByVal seiten As Integer)
    _titel = titel
    _autor = autor
    _preis = preis
    _seiten = seiten
  End Sub
 
  Public Property Titel As String
    ' ...
  End Property
 
  Public Property Autor As String
    ' ...
  End Property
 
  Public Property Preis() As Decimal
    ' ...
  End Property
 
  Public Property Seiten() As Integer
    ' ...
  End Property
End Class
 
Public Class Sachbuch
  Inherits Buch
 
  Protected _thema As String
 
  Public Sub New() 
  End Sub
 
  Public Sub New(ByVal titel As String, ByVal autor As String, _
    ByVal preis As Decimal, ByVal seiten As Integer, _
    ByVal thema As String)
 
    MyBase.New(titel, autor, preis, seiten)
      _thema = thema
  End Sub
 
  Public Property Thema() As String
    ' ...
  End Property
End Class

Schauen wir uns die Klasse Buch mal genauer an. Buch ist die Basisklasse (base class) und definiert grundlegende Eigenschaften eines Buches. Die Implementierungen der einzelnen Eigenschaften habe ich aus Übersichtlichkeitsgründen mal weggelassen. Diese tun zur Vererbung nichts, daher ist es egal, was dort passiert (außerdem war ich zu faul die ganzen Getter und Setter zu schreiben ).

Sie sehen, die Felder für die Eigenschaften sind als Protected deklariert. Dadurch ermöglichen wir den Zugriff auf sie von den angeleiteten Klassen, sie können aber nicht von außen verändert werden.

Danach wird ein leerer Konstruktor definiert, welcher keinen Code enthält. In diesen werden dann automatisch alle Felder auf ihren Standardwert gesetzt. Außerdem ist ein Konstruktor mit Parametern definiert, mit dem man gleich allen Eigenschaften einen Wert zuweisen kann. Das war die Basisklasse - nicht schwer, oder?

Nun kommt die abgeleitete Klasse (derived class) Sachbuch. Jetzt kommt das Inherits-Schlüsselwort. Dieses gibt die Basisklasse an, hier Buch. Sie können nur eine Basisklasse angeben, daher spricht man von Einfachvererbung. Andere Sprachen, wie C++, unterstützen auch mehrere Basisklassen, aber diese Möglichkeit kann einem sehr viele Schwierigkeiten machen, daher wird die Mehrfachvererbung nicht unterstützt. Durch die Inherits-Anweisung erbt die Klasse Sachbuch alle Member seiner Basisklasse und diese können Sie auch verwenden, nur dass Sie dafür keinen Code schreiben brauchen .

Nachdem festgelegt wurde, von welcher Klasse abgeleitet wird, wird noch ein Feld festgelegt sowie die entsprechende Eigenschaft dafür.
Auch hier gibt es wieder einen leeren Konstruktor und einen mit Parametern. Der mit Parametern empfängt auch die Argumente der Basisklasse, damit diese auch gesetzt werden können. Man könnte jetzt natürlich alle Felder "per Hand" setzen, aber warum auch? Wir haben das doch schon im Konstruktor der Basisklasse geschrieben. Können wir das nicht verwenden? Natürlich geht das. Um Methoden der Basisklasse zu verwenden, verwenden wir das MyBase-Schlüsselwort, gefolgt von New, da wir ja den Konstruktor verwenden wollen, geben ihm die Parameter und setzen jetzt noch den Wert unseres neuen Feldes und fertig ist die Klasse Sachbuch .

Es gibt eine Regel, um feststellen zu können, ob die Vererbung sinnvoll ist: Wenn eine "Ist ein(e)"-Beziehung vorliegt, können Sie Vererbung verwenden, ansonsten werden Elemente vererbt, die für die geerbte Klasse unlogisch sind. Diese Regel an unser Beispiel angewandt, ergibt Sinn: "Ein Sachbuch ist ein Buch".

Ohne Vererbung hätte unsere Klasse Sachbuch knappe 60 Zeilen Code (ohne Leerzeilen ), mit Vererbung sind es nur 20. Also, zwei Drittel gespart . Und Sie können sich sicherlich vorstellen, wie viel Code bei wirklich großen Projekten durch Vererbung gespart wird.

2.7.5.3. Methoden überschreiben
Manchmal wird es in den abgeleiteten Klassen erforderlich, die Implementierungen von geerbten Methoden zu ändern. Ein klassisches Beispiel dafür ist die ToString()-Methode, die jede Klasse enthält (auch wenn Sie nichts angeben, alle Klassen erben von Object). Um einen gescheiten String zurück zu bekommen, müssen wir sie überschreiben. Daher fügen wir nun die Überschreibungen der ToString()-Methode für unsere beiden Bücher-Klassen ein.

Erweiterung für Klasse Buch:

Public Overloads Overrides Function ToString() As String
  Return """" & _titel & """ von " & _autor
End Function

Erweiterung für Klasse Sachbuch:

Public Overloads Overrides Function ToString() As String
  Return _thema & ": """ & _titel & """ von " & _autor
End Function

Sonderlich schwer sind die Überschreibungen nicht. Mit dem Overrides-Schlüsselwort geben wir an, dass wir die Methode überschreiben. Und was passiert? Nun, wir geben an, dass ein Anführungszeichen zurückgegeben wird (dies erreicht man, indem man zwei Anführungszeichen schreibt, ergibt also 4: eins für den Anfang des Strings, zwei für ein Anführungszeichen in den String und das letzte, um den String zu beenden) gefolgt vom Titel, danach noch ein Anführungszeichen. Zum Schluss geben wir noch an, wer das Buch geschrieben hat. Da die ToString()-Methode überladen ist, müssen wir beim Überschreiben das Overloads-Schlüsselwort mit angeben, auch wenn wir nur eine der beiden Varianten überschreiben.

Die Überschreibung für die Sachbuch-Klasse erfolgt analog.

Beim Überschreiben mit Overrides (was deute ich denn hier an… ) müssen wir auch die Parameter beachten. Wenn wir also eine Methode überschreiben wollen, die zwei Parameter hat, muss unsere Überschreibung auch zwei haben. Ansonsten bekommen wir einen Fehler.

2.7.5.4. Methoden überschreiben - die Zweite
Wie ich schon oben angedeutet habe, es gibt noch eine zweite Möglichkeit, Methoden zu überschreiben. Bei dieser müssen die Parameter nicht beachtet werden, da die „Basisimplementierung" ausgeblendet wird - auch als überschatten bezeichnet. Das Schlüsselwort dafür ist Shadows.

Mit Shadows können Sie vollständig neue Elemente definieren und die geerbten Elemente überschatten (wie Sie sehen, Sie können auch Felder oder Eigenschaften überschatten). Aus einem privaten Integer-Feld können Sie mit Überschattung ein öffentliches String-Feld machen. Sie haben mit der Überschattung mehr Möglichkeiten als mit Overrides. Mit Overrides können Sie wirklich nur den auszuführenden Code ändern, Zugriffsmodifizierer oder Parameter bleiben erhalten. Mit Shadows können Sie das alles ändern.

Wenn Sie nun Ihre abgeleitete Klasse ebenfalls vererben, wird die Überschattung (die Überschreibung ebenfalls ) gleichfalls vererbt. Wenn aber auf die Überschattung nicht zugegriffen werden kann in der weiter abgeleiteten Klasse, wird das Originalelement vererbt - also die Überschattung geht da in diesem Fall verloren.

Abgesehen von diesen Unterschieden erfolgt die Überschattung wie eine Überschreibung, daher denke ich, kann ich ein Beispiel sparen (keine Sorge, am Ende dieses Kapitels kommt ein komplettes Beispiel, wo alles aus diesem Kapitel kombiniert wird, also ich werde Sie um Ihr Beispiel nicht betrügen ).

2.7.5.5. Überschreibungen im Griff
In diesem Abschnitt lernen Sie ein paar Schlüsselwörter kennen, mit denen Sie die Überschreibung mit Overrides steuern können.

Standardmäßig sind Methoden überschreibbar. Das entspricht dem Overridable-Schlüsselwort. Um ein Überschreiben zu verhindern, verwenden Sie das NotOverridable-Schlüsselwort.

Zum Schluss gibt es noch die Variante, dass eine Methode überschrieben werden muss. Das geht mit dem MustOverride-Schlüsselwort. Solche Methoden enthalten keinen Code (auch kein End Sub/End Function) und ihre Klasse muss als MustInherit gekennzeichnet werden. MustInherit gibt an, dass diese Klasse nur vererbt, aber keine Instanz von ihr erstellt werden kann. Das Gegenteil von MustInherit ist NotInheritable. Damit wird eine Vererbung verhindert. MustInherit-Klassen werden auch als abstrakte Klassen bezeichnet.

Mehr gibt es dazu nicht zu sagen. Hier ist die VB-Syntax recht gut einprägsam, da es fast immer gegenteilige englische Wörter sind, in C# z.B. ist dies wieder etwas anders.

2.7.6. Standards setzen

Wenn Sie Klassen entwerfen, von denen Sie ausgehen, dass eine Eigenschaft oft verwendet wird, können Sie diese zur Default-Eigenschaft machen, wenn diese mindestens ein Argument akzeptieren. Diese dürfen aber nicht als Shared oder Private definiert werden. Hier ein Beispiel:

Public Class Test
  Private _defaultProp As String()
  Public Default Property DefaultProp(ByVal index As Integer) As String
    Get
      Return _defaultProp(index)
    End Get
    Set(ByVal Value As String)
      If _defaultProp Is Nothing Then
        ' Array ist Nothing
        ReDim _defaultProp(0)
      Else
        ' Array für neues Element redimensionieren
        Dim grenze As Integer = _defaultProp.GetUpperBound(0)
        ReDim Preserve _defaultProp(grenze+1)
      End if
      _defaultProp(index) = Value
    End Set
  End Property
End Class

Verwendung:

Dim t As New Test()
' Standardweg
t.DefaultProp (0) = "Wert Eins"
Console.WriteLine(t.DefaultProp(0))
 
' "Default-Style"
t(1) = "Wert zwei")
Console.WriteLine(t(1))

Wie Sie sehen, ist die Verwendung von Default kürzer. Welche Variante Sie aber benutzen, ist Ihnen überlassen. Ich tendiere eher zur "normalen".

2.7.7. Das Leben eines Objektes
Auch Objekte führen ein Leben und dieses soll jetzt genauer beleuchtet werden.

2.7.7.1. Die Geburt eines Objektes
Ein Objekt erblickt das Licht der Welt mit der Instanzierung einer Klasse, sprich mit der New-Anweisung. Dabei wird der Konstruktor aufgerufen und die neue Instanz initialisiert. Wenn dies geschehen ist, existiert ein neues Objekt im Arbeitsspeicher, das vom Garbage Collector (GC) verwaltet wird. In der Variablen wird nur ein Verweis gespeichert, wo sich das Objekt im Arbeitsspeicher befindet (diese Aussage gilt generell für alle Typen, egal ob Enum, Variable, Struktur oder Klasse). Jetzt ist das Objekt reif für seine Verwendung und es kann, je nach dem wo es erstellt wurde, sehr alt werden .

2.7.7.2. Auch Objekte sterben
Ein Objekt ist ein Sterbekandidat, wenn es seinen Gültigkeitsbereich verlässt. Aber im Gegensatz zu anderen Sprachen können Sie hier bei .NET nicht sicher sein, dass es sofort zerstört wird. Wann ein Objekt zerstört wird, darauf haben Sie keinen Einfluss. Diesen Zeitpunkt legt der GC fest. Es gibt zwar im System-Namespace die Klasse GC, mit der man den GC steuern kann, aber man sollte ein Freigeben von Objekten nicht erzwingen. Denn dies dauert und der GC arbeitet wesentlich effizienter, da er besser entscheiden kann, wann Objekte freigegeben werden müssen.

Wenn es nun aber so weit ist, wird eine ganz bestimmte Prozedur der Klasse aufgerufen - Finalize(). In dieser können Sie Aufräumarbeiten unterbringen, aber diese Aufräumarbeiten machen nur Sinn bei unmanaged Ressourcen (z.B. Datenbank-Verbindungen, Handles zu allem Möglichen, …). Auf diese gehe ich aber in den jeweiligen Kapiteln noch ein, genauso auf eine Möglichkeit, wie man solche Ressourcen sofort nach der Verwendung freigeben kann.

2.7.7.3. Werttypen vs. Referenztypen
Jeden Datentyp kann man einer Kategorie zuteilen - entweder gehört er zu den Werttypen (value types) oder zu den Referenztypen (reference types).

Werttypen speichern ihren Wert "selber" und landen auf dem s.g. Stack. Dies ist ein spezieller Bereich des Arbeitsspeichers. Die Referenzen zu den Objekten werden ebenfalls auf dem Stack gespeichert, die Objekte selber aber auf dem Heap, welcher vom GC verwaltet wird.

Zu den Werttypen gehören atomare Datentypen, wie z.B. Integer, Short, Long, Boolean oder Date. Ebenfalls gehören zu ihnen Strukturen (siehe weiter unten) und Enums.

String und Klassen gehören zu den Referenztypen. Jetzt ist auch die Bedeutung des New-Schlüsselwortes klarer: 

Dim myBook As Book    ' Anlegen einer Referenz auf dem Stack
myBook = New Book(…)  ' Anlegen des Objektes auf dem Heap

Erst bei Angabe von New wird das Objekt erzeugt. Diese Erstellung kann bei großen Klassen schon etwas dauern und durch die Verwaltung sind die Referenztypen etwas langsamer als die Werttypen. Aber man muss dazu sagen - alles ist relativ .

2.7.7.4. Boxing und Unboxing
Manchmal muss ein Werttyp als ein "richtiges" Objekt übergeben werden. Dann kommt ein Verfahren ins Spiel, was man als Boxing bezeichnet. Dabei landet der Werttyp "eingetütet" auf dem Heap und auf ihn wird ein Verweis auf dem Stack erstellt. Dies läuft impliziert ab, also ohne dass Sie dafür was machen müssen. Aber es sollte wenn möglich vermieden werden, da es Performance kosten kann, da immer ein Objekt verschoben werden muss.

Unboxing ist die umgekehrte Richtung. Jetzt wird die "Tüte" wieder ausgepackt. Dafür ist ein explizierter Cast angesagt. Und falls ich es noch nicht gesagt habe, Casts kosten Zeit. Dazu ein Beispiel:

Dim einInteger As Integer = 13
Dim box As Object = einInteger            ' Boxing
Dim andererInteger As Integer = CInt(box) ' Unboxing

Um bei den Casts herauszufinden, um welchen Typ es sich bei dieser "Box" handelt, verwendet man den Is-Operator. Dieser überprüft, ob der Typ eines Objektes dem eines gegebenen Typs entspricht. Um den Typ eines Objektes zu erhalten, verwenden Sie den TypeOf-Operator. Dazu ein Beispiel:

Dim sb1 As New Text.StringBuilder("Hallo Welt!")
Dim sb2 As Object = sb1
' Prüfen, ob beide Variablen auf das selbe Objekt zeigen
If sb2 Is sb1 Then Console.WriteLine(sb2.ToString)
If TypeOf (sb2) Is String Then
  ' Ist der Typ von sb2 String?
  Console.WriteLine("Unser StringBuilder ist ein String :)")
End If
If TypeOf (sb2) Is Text.StringBuilder Then
  ' Ist der Typ von sb2 StringBuilder?
  Console.WriteLine("Unser StringBuilder ist ein StringBuilder.")
End if

2.7.8. Schnittstellen

Und weiter geht es in der bunten OOP-Welt. Aber bald haben Sie es geschafft, Sie halten sich tapfer, jetzt bloß nicht aufgeben!

Schnittstellen (Interfaces), legen Eigenschaften, Ereignisse oder Methoden fest, die eine Klasse (oder auch Struktur, wobei Strukturen keine Ereignisse implementieren können) implementieren muss.

Stellen Sie sich Schnittstellen wie eine Art Vertrag vor, sie legen die Elemente fest, damit eine Klasse konform zu ihr ist. Sie können mit ihnen zusammenhängende Elemente definieren und unabhängig von einer Implementierung machen.

2.7.8.1. Schnittstellen definieren
Sie kennen ja schon das Spielchen, erst kommt der Code, dann die Erklärung . Also ran an den Code:

Public Interface IAtom
  ReadOnly Property Symbol() As String
  ReadOnly Property Name() As String
  ReadOnly Property Ordnungszahl() As Byte
  Property Zustand() As Zustand
End Interface

Zustand ist eine Enumeration, welche die möglichen Zustände speichert (fest, flüssig oder gasförmig). Wie Sie sehen, wurden vier Eigenschaften festgelegt, wovon drei ReadOnly sind. Festgelegt wurden mit Eigenschaften der Name des Atoms, das entsprechende Zeichen, die Ordnungszahl und der Zustand (bezogen bei Zimmertemperatur). Interessanter ist aber die Verwendung.

2.7.8.2. Schnittstellen verwenden

Public Class Wasserstoff
  Implements IAtom
 
  Private _zustand As Zustand = Zustand.Gasfoermig
 
  Public ReadOnly Property Symbol() As String Implements IAtom.Symbol
    Get
      Return "H"
    End Get
  End Property
 
  Public ReadOnly Property Name() As String Implements IAtom.Name
    Get
      Return "Wasserstoff"
    End Get
  End Property
 
  Public ReadOnly Property Ordnungszahl() As Byte _
    Implements IAtom.Ordnungszahl
    Get
      Return 1
    End Get
  End Property
 
  Public Property Zustand() As Zustand Implements IAtom.Zustand
    Get
      Return _zustand
    End Get
    Set(ByVal Value As Zustand)
      _zustand = Value
    End Set
  End Property
End Class
 
Public Class Sauerstoff
  Implements IAtom
 
  Private _zustand As Zustand = Zustand.Gasfoermig
 
  Public ReadOnly Property Symbol() As String Implements IAtom.Symbol
    Get
      Return "O"
    End Get
  End Property
 
  Public ReadOnly Property Name() As String Implements IAtom.Name
    Get
      Return "Sauerstoff"
    End Get
  End Property
 
  Public ReadOnly Property Ordnungszahl() As Byte _
    Implements IAtom.Ordnungszahl
    Get
      Return 8
    End Get
  End Property
 
  Public Property Zustand() As Zustand Implements IAtom.Zustand
    Get
      Return _zustand
    End Get
    Set(ByVal Value As Zustand)
      _zustand = Value
    End Set
  End Property
End Class

Schnittstellen werden implementiert (oder vererbt) durch Implements. Außerdem muss hinter jedem Schnittstellenelement ein Implements stehen mit Schnittstellennamen und Schnittstellenelement, wie Implements IAtom.Zustand.

Mit der Implementierung legen Sie auch die Modifizierer fest, wie Public, Overloads, Overrides oder was wir alles kennen. Mehr gibt es zur Implementierung nicht zu sagen.

2.7.8.3. Schnittstellen vererben
Wie Klassen können Sie auch Schnittstellen vererben, dazu ein Beispiel:

Public Interface IIon
  Implements IAtom
 
  Function Ladung() As Short
End Interface

Wenn dieses Interface implementiert wird, müssen alle Elemente der Schnittstelle (also auch der geerbten) implementiert werden.

Im Gegensatz zu Klassen können Sie beliebig viele Schnittstellen vererben und implementieren, also kann eine Mehrfachvererbung mit Schnittstellen erreicht werden.

2.7.8.4. Der Unterschied zwischen abstrakten Klassen und Interfaces
Auch wenn beide fast demselben Zweck dienen, gibt es zwischen ihnen einen Unterschied.

Mit abstrakten Klassen legt man die Basisfunktionen von Klassen fest, durch Schnittstellen werden neue Funktionen hinzugefügt.

Ein gutes Beispiel dafür sind die Collections - diese sind alle von CollectionBase abgeleitet. Zusatzfunktionen wie Sortierung werden durch Schnittstellen hinzugefügt.

Das war's! Die Schnittstellen haben Sie geschafft, jetzt noch die Strukturen (dieser Abschnitt ist aber kurz) und Sie haben die OOP-Welt gemeistert.

2.7.9. Strukturen
Strukturen sind Klassen in einigen Punkten ähnlich, daher hier erst mal die Gemeinsamkeiten:

• beide können Methoden, Eigenschaften oder Felder besitzen
• beide können Schnittstellen implementieren

Und nun die Unterschiede:

• Strukturen zählen zu den Werttypen, Klassen zu den Referenztypen
• Strukturen können nicht vererbt werden noch von einer Klasse erben
• Strukturen können keine parameterlosen Konstruktoren haben.

Strukturen sollten Sie verwenden, um zusammengehörige Informationen zu speichern, z.B. Informationen zu einem PC-System. Ein Beispiel und schon lasse ich Sie mit den Strukturen in Ruhe :

Public Struct CPUInfo
  Public Taktrate As Integer
  Public Modell As String
  Public Preis As Decimal
 
  Public Sub New(ByVal modell As String, ByVal taktrate As Integer, _
    ByVal preis As Decimal)
      Me.Modell = modell
      Me.Taktrate = taktrate
      Me.Preis = preis
  End Sub
End Struct

2.8. Ereignisbehandlung

Jetzt stelle ich Ihnen noch die Ereignisbehandlung vor, danach wissen Sie alles zu Klassen. Zuerst klären wir, was Ereignisse sind.

2.8.1. Was sind Ereignisse?

Ereignisse (Events) sind Nachrichten, die ein Objekt auslösen kann. Ereignisse sind weit verbreitet. Jede Aktivität, wie Mausbewegungen, Klicks, das Drücken von Tasten, das Ändern der Größe von Fenstern, … löst ein Ereignis aus. Wenn etwas angeklickt wird, wird das Click-Ereignis ausgelöst.

Diese Nachrichten können von Prozeduren behandelt werden, wodurch auf diese Events reagiert werden kann. So kann z.B. auf das Klicken eines Buttons ein Fester angezeigt oder eine Berechnung durchgeführt werden. Das ist erst mal der Sinn von Ereignissen.

2.8.2. Ereignisse erstellen und auslösen

Public Class Tank
  Private _max As Integer
  Public Fuellhoehe As Integer
  Public Event Ueberlauf(ByVal zuviel As Integer)
 
  Public ReadOnly Property Maximum() As Integer
    Get
      Return _max
    End Get 
  End Property
 
  Public Sub Fuellen(ByVal liter As Integer)
    Fuellhoehe += liter
    If Fuellhoehe > _max Then
      RaiseEvent Ueberlauf (Fuellhoehe - _max)
    End If
  End Sub
 
  Public Sub New(ByVal maximum As Integer)
    _max = maximum
  End Sub
End Class

Neu ist die Definition des Ereignisses, welches mit der Event-Anweisung geschieht. Event wird gefolgt von dem Namen des Events und in Klammern evtl. Parameter, die übergeben werden sollen.

Ausgelöst wird das Event mit RaiseEvent, wobei dann auch Argumente übergeben werden müssen, wenn das Event Parameter besitzt.

Mehr ist es nicht. Das Erstellen und Auslösen von Ereignissen ist einfach, das Behandeln von ihnen ist etwas umfangreicher.

2.8.3. Das Behandeln von Ereignissen mit WithEvents

Dies ist die erste Variante um Ereignisse zu behandeln.

Public Module Main
  ' Instanz mit WithEvents erstellen
  Private WithEvents TestTank As New Tank(50)
  Public Sub Main()
    ' Tank zum Überlaufen bringen
    Console.WriteLine("Der Tank fasst 50 Liter.")
    Console.WriteLine("Es werden 30 Liter aufgefüllt...")
    TestTank.Füllen(30)
    Console.WriteLine("Es werden 25 Liter aufgefüllt...")
    TestTank.Füllen(25) ' Jetzt passiert der Überlauf
    Console.WriteLine()
    Console.Write("Zum Beenden 'Enter' drücken...")
    Console.ReadLine()
  End Sub
 
  ' Diese Prozedur wird aufgerufen, wenn der Tank überläuft
  Private Sub TestTank_Ueberlauf(ByVal zuviel As Integer)  Handles TestTank.Ueberlauf
    Console.WriteLine("Der Tank ist um {0} Liter übergelaufen.", zu viel)
  End Sub
End Module

Im Modul wird zuerst eine Instanz unserer Tank-Klasse erstellt. Wichtig ist hier das WithEvents-Schlüsselwort. Diese Instanz darf nicht in einer Methode erstellt werden (Wie soll sonst eine andere Methode auf sie zugreifen?).

In der Main-Prozedur wird dann der Tank zum Überlaufen gebracht. Wenn die 25 Liter eingefüllt werden, wird das Event dann ausgelöst. Es wird dann die Prozedur ausgeführt, welche das Event behandelt. Diese Prozedur, die auch als Eventhandler bezeichnet wird, geben wir an, indem wir hinter den Parameter Handles Instanz.Event schreiben, im Beispiel handles TestTank.Ueberlauf. Dabei müssen die Parameter der Prozedur mit den Parametern des Events übereinstimmen.

Nachdem der Code des Eventhandlers ausgeführt wurde, wird der Rest der Main-Prozedur ausgeführt.

So können Sie Events behandeln. Mit WithEvents ist die Behandlung recht einfach und komfortabel.

2.8.4. Ereignisbehandlung mit AddHandler

Der Vorteil bei WithEvents in Verbindung mit Handles ist die Einfachheit. Allerdings hat man nicht so viele Freiheiten. Wenn Sie die Ereignishandler dynamisch festlegen möchten, funktioniert Handles nicht mehr, da muss dann AddHandler ran. Wie die Verwendung aussieht, zeigt das folgende Beispiel:

Public Module Main
  Public Sub Main()
    ' Instanz von unserer Klasse erstellen
    Dim TestTank As New Tank(50)
    ' Eventhandler festlegen
    AddHandler TestTank.Ueberlauf, AddressOf Ueberlauf
    ' Tank zum Überlaufen bringen
    Console.WriteLine("Der Tank fasst 50 Liter.")
    Console.WriteLine("Es werden 30 Liter aufgefüllt...")
    TestTank.Fuellen(30)
    Console.WriteLine("Es werden 25 Liter aufgefüllt...")
    TestTank.Fuellen(25) 	' Jetzt passiert der Überlauf
    Console.WriteLine()
    Console.Write("Zum Beenden 'Enter' drücken...")
    Console.ReadLine()
  End Sub
 
  ' Diese Prozedur wird aufgerufen, wenn der Tank überläuft
  Private Sub Ueberlauf(ByVal zuviel As Integer)
    Console.WriteLine("Der Tank ist um {0} Liter übergelaufen.", zu viel)
  End Sub
End Module

Wie Sie sehen, ist die Verwendung von AddHandler auch nicht sonderlich schwer. Sie können Ihre Klasseninstanz auch lokal erstellen. Die Syntax von AddHandler ist einfach:

AddHandler Objekt.Event, AddressOf EventHandler

Wie Sie sehen, ist diese auch einfach.

Ich habe Ihnen ja gesagt, dass Sie mit AddHandler die Ereignishandler dynamisch festlegen können. Aber was machen Sie, wenn Sie einen Ereignishandler wieder loswerden wollen? Dafür gibt es auch ein Mittel:

RemoveHandler Objekt.Event, AddressOf EventHandler

Funktioniert wie AddHandler, löst nur die Bindung zwischen Ereignis und Handler wieder auf.

Ausblick: AddressOf liefert einen s.g. Delegat (vergleichbar mit typsicheren Funktionszeiger) zurück. Delegaten spielen in der Ereignisbehandlung eine wichtige Rolle, aber VB.NET übernimmt für uns die ganze Arbeit der Erstellung, im Gegensatz zu anderen Sprachen. In C# müssen Sie dies alles selber schreiben, daher finde ich die Ereignisbehandlung recht umständlich. Man kann Delegaten auch außerhalb der Ereignisbehandlung verwenden, aber ich habe sie noch nie außerhalb von Ereignissen gebraucht. Daher lasse ich eine Erklärung hier weg und verweise nur auf die .NET Framework SDK-Dokumentation, für alle, die Interesse daran haben.

2.9. Ausnahmebehandlung

Eine Ausnahme (Exception), auch als Fehler bekannt , tritt in fast jeder Anwendung auf. Manchmal liegt die Fehlerquelle an die Schlampigkeit des Programmierers, aber es gibt auch viele andere Ursachen. Z.B. wenn eine Anwendung eine Datei erstellen möchte, sie aber keine Schreibrechte für das Verzeichnis besitzt? Der Benutzer bekommt eine Fehlermeldung angezeigt und die Anwendung wird beendet. Das und vieles mehr, passiert zur Laufzeit, daher werden solche Fehler als Laufzeitfehler bezeichnet. Aber diese können abgefangen werden, d.h. Sie können auf diese reagieren.

Hier ein Beispiel, wo absichtlich ein Fehler produziert wird:

Public Module MainModule
  Public Sub New()
    Dim v1 As Integer = 13
    Dim zero As Integer = 0
    ' Hier wird eine DivideByZeroException ausgelöst.
    Dim ergebnis As Integer = v1 / zero
    Console.WriteLine("Das Ergebnis ist {0}.", zero)
  End Sub
End Module

Wie schon im Kommentar angedeutet wird, wird eine Exception ausgelöst. Hier eine spezielle, nämlich eine DivideByZeroException. Der Name verrät schon, was die Ursache ist . Gegen so was kann man sich schützen und dann sieht der Code so aus:

Public Module MainModule
  Public Sub New()
    Dim v1 As Integer = 13
    Dim zero As Integer = 0
    Try
      Dim ergebnis As Integer = v1 / zero
      Console.WriteLine("Das Ergebnis ist {0}.", zero)
    Catch ex As Exception
      Console.WriteLine("Es ist ein Fehler aufgetreten:")
      Console.WriteLine(ex.Message)
    End Try
  End Sub
End Module

Try leitet die Fehlerbehandlung ein. In diesem Block kommt der Code, der eine Ausnahme auslösen könnte. Wenn in diesem Block eine Ausnahme ausgegeben wird, dann wird nach einem passenden Catch-Block gesucht. Wenn dieser gefunden wird, wird der dort stehende Code ausgeführt. Mit End Try wird die Fehlerbehandlung beendet. Wenn ein Catch-Block gefunden wird, wird die Anwendung nicht beendet.

Fehler sind nichts anderes als Instanzen von bestimmten Klassen. In dem Catch-Block legen Sie einen Namen für diese Instanz fest (hier ex) und danach den Typ. Wenn Sie als Typ Exception angeben, haben Sie einen Catch-Block der jeden Fehler abfängt. Und warum jeden? Weil jede Ausnahme direkt oder indirekt von Exception erbt und eine abgeleitete Klasse kann immer in ihre Basisklasse konvertiert werden. Daher sollten Sie zuerst die Ausnahmenklassen angeben, welche speziell sind und danach immer allgemeiner werden. Das hat den Vorteil, dass Sie sehr detailliert auf einen Fehler eingehen können. In unserem Beispiel würde das dann so aussehen:

Try
  Dim ergebnis As Integer = v1 / zero
  Console.WriteLine("Das Ergebnis ist {0}.", zero)
 
Catch ex As DivideByZeroException
  Console.WriteLine("Es wurde versucht durch 0 zu dividieren.")
Catch ex As Exception
  Console.WriteLine("Es ist ein Fehler aufgetreten:")
  Console.WriteLine(ex.Message)
End Try

Und jede Klasse hat verschiedene Eigenschaften, z.B. die Fehlerbeschreibung (Message-Eigenschaft) oder die Anwendung / das Objekt, welches die Ausnahme erzeugt hat (Source-Eigenschaft).

In den weiteren Kapiteln werden uns immer wieder Fehlerquellen begegnen, die wir natürlich ordnungsgemäß behandeln werden. Zum Schluss möchte ich noch erwähnen, dass auch eigene Exceptions erstellt werden können; dies brauchen wir aber erst mal nicht. Falls wir es in diesem Tutorial noch brauchen sollten (weiß ich doch noch nicht , dies ergibt die Situation), werde ich es Ihnen an der jeweiligen Stelle zeigen, ansonsten verweise ich auf die Dokumentation.

2.10. Codekonventionen

Beim Schreiben von Code hat jeder seinen persönlichen Stil, aber es gibt einige Richtlinien, an die man sich halten sollte, wie das Kommentieren seines Codes, um ihn auch später nachvollziehen zu können.

Die meisten Richtlinien beziehen sich aber auf Namenskonventionen, also wie Sie Ihre Variablen und Objekte benennen sollen.

Es gibt zwei Möglichkeiten, wie Bezeichner bezeichnet werden können:

• Pascal Parsing: Dabei wird der Anfangsbuchstabe jedes Wortes Großgeschrieben, z.B. AutoFarbe
• Camel Parsing: Dabei wird der Anfangsbuchstabe des ersten Wortes kleingeschrieben, die Anfangsbuchstaben jedes anderen Wortes groß, z.B. autoFarbe

Folgende Richtlinien gibt es:

• Lokale Variablen von Methoden und nicht öffentliche Felder Camel Parsing
• Parameter Camel Parsing
• Methoden, Klassennamen, Strukturnamen und öffentliche Felder Pascal Parsing
• Interfaces Pascal Parsing, beginnen mit vorangestelltem "I"
• Exception sollen auf Exception enden

Es gibt noch einige mehr, aber diese sind die wichtigsten und diese reichen erst mal aus . Herzlichen Glückwunsch, Sie haben die Grundlagen von VB.NET gelernt und jetzt werden diese "nur" noch angewandt.