Die ersten Schritte in Visual Basic .NET

Geschrieben von: Christian Holm
Kategorie: VB.NET

This printed page brought to you by AlphaSierraPapa

Programmiersprachen gibt es ja viele - alle mit unterschiedlichen Anwendungsbereichen und Erfordernissen. Je komplexer aber die Aufgabenstellung wird, desto größer wird aber auch die Anforderung an den Programmierer. Eine Sprache sticht jedoch hervor - Visual Basic. Die Lernkurve ist relativ niedrig und man kann auch aufwendigere Projekte damit realisieren. Visual Basic .NET geht nun noch um einiges weiter. Diese Artikelserie soll Ihnen einen Einstieg in diese .NET Sprache geben.

Visual Basic wird oft in der Programmierergemeinde belächelt. Dies beginnt beim Arrayindex (Datenfeldindex) und bei der umfangreicheren Syntax bis zur eingeschränkten Objektorientiertheit. Mit Visual Basic .NET (VB .NET) muß der Programmierer im Vergleich zu anderen Programmiersprachen jedoch keine Kompromisse mehr eingehen. Im Bereich der meist verwendeten objektorientierten Programmiersprachen steht VB .NET den anderen um nichts nach. Sie können mit nahezu selbsterklärendem Syntax professionelle und performante Anwendungen erstellen wie in C# (sprich C Sharp) oder Managed C++.

Mit dem .NET Framework als Grundlage haben Sie uneingeschränkten Zugriff auf die .NET Base Class Library (BCL), die Ihnen das Erstellen von Windows-Applikationen wesentlich erleichtert und da alle .NET Sprachen auf die gleiche Codebasis (MSIL, Microsoft Intermediate Language) kompilieren, haben Sie auch keine Geschwindigkeitseinbußen bei der Ausführung des Programmes. Ein weiterer Vorteil von .NET allgemein ist auch, daß Sie nun ohne Wrapper auf andere .NET Assemblies (z.B. Programmbibliotheken, DLLs) zugreifen bzw. diese verwenden können. So können Sie etwa die Funktionalität einer in C# oder Managed C++ geschriebenen DLL nutzen oder dieser auch Features zur Verfügung stellen. Da selbst das aktuelle Windows Client-Betriebssystem im Moment nicht viel mit VB .NET Syntax anfangen kann, sind einige Anforderungen zu erfüllen.

Damit wir den geschrieben Sourcecode kompilieren können und die Funktionen der BCL nutzen können benötigen wir das .NET Framework. Da Sie ja nun in Zukunft vernünftig Arbeiten und Freude dabei haben wollen, benötigen Sie das .NET Framework Software Development Kit (SDK) , welches Sie kostenlos downloaden können. Das SDK enthält den notwendigen Visual Basic .NET Kompiler (vbc.exe) und eine vernünftige und umfangreiche Dokumentation (auch in Deutsch erhältlich), die Ihnen alles von Kompilerfehlermeldungen bis zu den Features der BCL leicht verständlich erklärt. Ergänzt wird die Dokumentation mit vielen Anwendungsbeispielen die Ihnen die einzelnen Funktionen veranschaulichen.

Für diese Artikelserie nicht erforderlich, aber für die spätere Arbeit empfohlen, ist die Verwendung einer Integrierten Entwicklungs Umgebung (IDE). Im Vergleich zu "trivialen" Editoren, die lediglich Syntaxhighlighting und die Einbindung des Kompilers bieten, haben IDEs Features wie Code-Completion (automatische Ergänzung von Syntax), Projektmanagement (wettbewerbsfähige Anwendungen bestehen aus mehr als einer Quelldatei!) oder eine integrierte Anbindung für Versionskontroll-Applikationen (CVS, Concurrent Versions System) um nur einige wenige zu nennen. Je nach Projektumfang und Budget kann man sich kostenlosen IDEs (z.B. SharpDevelop) oder käuflichen IDEs (z.B. Visual Studio .NET Editionen) bedienen. Nach dem Installieren dieser Voraussetzungen kann das Programmieren beginnen! Sehen wir uns also das erste einfache Beispiel an.

Das erste VB .NET Programm

Wie gesagt, der einzige Unterschied bleibt im etwas längeren Syntax. Und diesen wollen wir uns in weiterer Folge ansehen. Beginnen wir mit einem einfachen Beispiel. Dies ist für gewöhnlich die Ausgabe von "Hello World" an die Konsole. Nicht besonders aufregend, aber ein einfacher Einstieg in eine neue Welt. Bevor wir mit dem Schreiben des Sourcecodes beginnen, ist es ratsam sich vorher zu überlegen was man alles benötigt, quasi eine "Einkaufsliste" zu erstellen, um eine Lösung zu kreieren.

Wir wollen zudem auch objektorientiert programmieren, da diese Programmierweise viele Vorteile bietet und den Sourcecode modularer und strukturierter gestaltet. Ohne jetzt in staubiger Theorie zu versinken, seien hier nur die hier benötigten Begriffe "Klasse - Objekt" kurz erklärt. Diese beiden Begriffe stehen in einem engen Zusammenhang. Einfach ausgedrückt geht es in objektorientierter Programmierung darum, daß Objekte mit miteinander kommunizieren bzw. Daten austauschen. Objekte existieren während der Laufzeit eines Programmes im flüchtigen Speicher (RAM). Diese Objekte haben Eigenschaften die im weiteren Sinne die Funktionalität Ihres Programmes darstellen.

Diese Eigenschaften werden vom Programmierer definiert. Diese Definitionen werden von den Klassen repräsentiert. Sie sind also die "Blaupausen" der Objekte. So könnte man sich zum Beispiel eine Klasse als DNS für ein Säugetier vorstellen und ein Objekt als die nach den definierten Eigenschaften in der DNS kreierte Lebensform. Je nach Definition der Eigenschaften wird ein Tier, Mensch, etc. erstellt. Diese Lebewesen können nach gewissen Richtlinien miteinander "kommunizieren" - so auch die Objekte des Programmierers.

In unserem einfachen Konsolen-Beispiel wollen wir aber nur ein Objekt erstellen. Dieses Objekt hat die Eigenschaft bzw. Funktion Text ("Hello World") auf der Kommandozeile anzuzeigen. Das hört sich einfach an, benötigt aber einiges Voraussetzungen um es zu realisieren, da VB .NET selbst ja nur die "Grammatik" zur Verfügung stellt, aber keine direkten Werkzeuge.

Da uns in den meisten Fällen egal ist, wie tatsächlich der Text in der Konsole aufscheint, nehmen wir die BCL zur Hilfe, die uns diese Funktionalität zur Verfügung stellt. Unsere "Einkaufsliste" ist nun hiermit vollständig: Wir brauchen eine Klasse und die Funktionalität Text in der Konsole anzuzeigen. Schreiten wir ans Werk!

Da der VB Syntax relativ selbsterkärend ist, ist es auch nicht anders bei der Klassendefinition, unserer Blaupause (einer Klasse namens "MainApp") für das zukünftige Objekt:

Class MainApp 
...
End Class

Wie erwähnt erfordern objektorientierte Programme eine Struktur, sprich eine Ordnung in den (vielen) Codezeilen. Um eine klar definierte Struktur zu erhalten, muß man dem Kompiler signalisieren, wo ein Anweisungsblock beginnt und wo er endet. Da es in Visual Basic keine geschwungenen Klammern als Begrenzer wie in C# oder C++ gibt, schreibt man z.B. für eine Klasse als Anfang Class und als Ende End Class. Was jetzt für unser Programm noch fehlt ist seine Funktionalität, also etwas zu "tun". Dieses "tun" wird in Form von Methoden abgebildet. Hier, im einfachsten Falle, verwenden wir eine "Sub Prozedur" die die Aufgabe erledigen wird. Diese "Sub Prozedur" ist hier zusätzlich noch etwas besonderes! Sie ist der Einsprungpunkt unseres Programms, d.h. wenn unser Programm läuft, soll diese Methode als erstes ausgeführt werden. Der Einsprungpunkt regelt somit den Ablauf eines Programms.

Daher müssen wir ihr auch den Namen "Main" geben, weil diese spezielle Methode eine vordefinierte Signatur haben muß um als Einsprungspunkt vom Kompiler erkannt zu werden. Eine Funktionalität erhalten wir dadurch noch nicht. Diese ist aber nun an der Reihe. Die Funktionalität des Anzeigens von Text in der Kommandozeile ist in der Console-Klasse der BCL enthalten: Die WriteLine-Methode. Methoden können Parameter übernehmen. Daher haben die Methodendefinitionen runde Klammern, die diese Parameter umgrenzen. In unserem Fall hat die Main Methode keine Parameter (wir wollen ihr nichts übergeben) und die WriteLine Methode aber sehr wohl - den Text der ausgegeben werden soll. Daher können wir schreiben:

Class MainApp
    Public Shared Sub Main()
        System.Console.WriteLine("Hello World")
    End Sub
End Class

Da unsere Sub-Prozedur als Einsprungpunkt dienen soll, muß sie allgemein zugänglich sein (Public) und die Instanz soll für alle gleich sein. Daher müssen wir zusätzlich das Shared Schlüsselwort anführen. Damit der Kompiler weiß, welche WriteLine-Methode wir verwenden wollen, müssen wir angeben wo diese zu finden ist. Die WriteLine-Methode aus der BCL befindet sich im System-Namespace, der die Console Klasse enthält. Die einzelnen Referenzorte werden mit dem Punktoperator verbunden. Diese Strukturierung der BCL hat vor allem den Sinn, daß man unter den vielen Klassen und Methoden auch etwas findet und auch die einzelnen Funktionen logisch trennt und Doppeldeutigkeiten vermeidet.

Einen Namespace kann man sich als eine Art Gruppe vorstellen, die zugehörige (Unter)Namespaces und Klassen enthält. Durch diese Strukturierung kann man sich vorstellen, daß die Verwendung bzw. Referenzierung von Mitgliedern eines Namespaces langwierig werden kann. Deshalb kann man vorab Namespacereferenzen angeben um sich voll-qualifizierte Pfade (fully qualified paths) jedes mal bei der Anwendung eines Mitgliedes zu ersparen. In VB .NET verwendet man die Imports Anweisung die logischerweise außerhalb der Deklarationen stehen muß. Der obige Sourcecode mit der zugehörigen Namespace-Referenz:

Imports System

Class MainApp
    Public Shared Sub Main()
        Console.WriteLine("Hello World")
    End Sub
End Class

Unser einfaches Programm wäre damit fertig und wir können es unter HelloWorld.vb speichern. Was noch vor der Ausführung des Programmes fehlt, ist die Kompilierung des Sourcecodes. In einer IDE bzw. einem Editor brauchen Sie meist nur einen Button zu klicken und schon erfolgt der Kompiliervorgang. Sollten Sie so ein Werkzeug nicht zur Hand haben und nur das SDK installiert haben, muß die Datei manuell kompiliert werden. Öffnen Sie das Kommandoprompt und wechseln Sie dazu in das Verzeichnis wo sich HelloWorld.vb befindet. Nun geben Sie folgende Anweisung an der Eingabeaufforderung ein:

vbc helloworld.vb /m:MainApp /out:HelloWorld.exe /t:exe

Nach der Bestätigung mit der Enter-Taste wird die Datei kompiliert. Manuelles Kompilieren erfordert immer mehr "Arbeit" und auch hier müssen neben der Angabe der Quelldatei einige Angaben in Form von Switches gemacht werden:

Der Target-Switch bietet folgende Möglichkeiten an:

• exe: Konsolenanwendung
• winexe: Windows-Applikation
• library: Klassenbibliothek (DLL)
• module: Modul, das zu einer Assembly hinzugefügt werden kann

Wenn man jetzt die erzeugte Executable HelloWorld an der Konsole ausführt, so erhält man die Zeichenkette "Hello World". Es fällt auf, daß nach der Ausgabe der Zeichenkette eine neue Zeile eingefügt wurde. Daher auch der Methodenname "WriteLine", d.h. nach der Zeichenkette wird immer der Caret in eine neue Zeile gesetzt. Will man dies nicht, so bedient man sich der Write-Methode der Console-Klasse.

Natürlich kann man auch an der Konsole etwas eingeben. Dazu wäre es nützlich wenn man Daten (temporär) speichern könnte.

Deklaration und Verwendung von Variablen

Variablen sind die einfachsten Datenspeicher. Da Daten unterschiedlicher Natur sein können (Zahl, Zeichenkette, etc.), muß man neben der Angabe der Bezeichners einer Variable ihr auch einen Typ vergeben, der darauf hinweist um welche Art von Daten es sich handelt. So wie die Typen untereinander unterschiedlich sind, so unterschiedlich ist auch der Gültigkeitsbereich eines Typs und damit auch sein Speicherbedarf.

Die Datentypen im .NET Framework sind zur Common Language Specification (CLS) kompatibel, d.h. sie können in allen Sprachen die sich and die Regeln der CLS halten verwendet werden und haben auch sprachübergreifend die gleichen Eigenschaften (z.B. Wertebereich, signifikante Stellen). Das einzige was sich in den Sprachen ändert ist der Bezeichner für den Datentyp (z.B. VB .NET - "Integer", C# - "int"). Die verfügbaren Datentypen des .NET Framework findet man im System-Namespace, welche dort in Strukturen (Structures) nach ihrer Art eingeteilt sind (z.B. Int16 Structure für 16 bit Integer).

Nachfolgend eine Auflistung der möglichen Datentypen:

Die "signifikanten Stellen" (Präzision) geben die Mächtigkeit eines Datentyps an, d.h. desto genauer sind die Nachkommastellen. Etwas später in diesem Artikel, bei der "Datentypumwandlung", werden wir sehen, daß dieser Faktor sehr wohl zu berücksichtigen ist.

Wenn man nun weiß welche Art von Daten vorliegen, möchte man diesen Speicherort auch verwenden. Auf Variablen greift man mittles Bezeichnern zu. Bezeichnern können Sie alle möglichen Namen geben. Jedoch sollten einige Regeln eingehalten werden:

• Keine Zahlen am Anfang oder nur Zahlen verwenden
• Keine Sonderzeichen (!, ö, &, etc.) verwenden
• Keine Leerzeichen inzwischen

Um die Lesbarkeit und die Sinnhaftigkeit von Variablen zu erhöhen, kann man das Pascal-Casing und zusammengesetzte Worte verwenden, z.B.

SummeDerAddition
FlaecheDesRechtecks

Variablen deklariert man prinzipiell mit Hilfe der Dim Anweisung, der Angabe des Bezeichners und des Datentyps:

Dim Text As String 'Eine Zeichenkette
Dim Wert As Integer 'Eine Ganzzahl
Dim ErgebnisDerWurzel As Double 'Eine Gleitkommazahl

Wie man hier zusätzlich sehen kann, werden Kommantare mit dem einfachen Anführungszeichen ' angegeben. Leider gibt es in Visual Basic keine Delimiter für mehrzeilige Kommentare, d.h. jeder Kommentarzeile muß ein ' vorangesetzt werden.

Variablen werden mit dem "="-Operator Werte zugewiesen. Dabei ist zu beachten, daß das Komma dem Punkt entspricht und Zeichenketten innerhalb von doppelten Anführungszeichen einzugrenzen sind:

Text = "Das ist eine Zeichenkette"
Wert = 3
ErgebnisDerWurzel = 1.14

Weiters haben Variablen unterschiedliche Gültigkeitsbereiche (Scopes) innerhalb einer Klasse und die Speicherung der Werte erfolgt nur solange der Laufzeit (Zeit in der das Programm ausgeführt und aktiv im Speicher ist) des Programms. Beginnen wir mit dem Gültigkeitsbereich. Variablen, die von allen Methoden innerhalb einer Klasse verwendbar sein sollen heißen Membervariablen. Variablen die nur innerhalb einer Methode gültig sein sollen heißen Lokale Variablen.

Am einfachsten wäre es natürlich alle Variablen als Membervariablen zu definieren damit man sie quasi immer "parat" hat, wenn man sie braucht. Dies ist aber weder sinnvoll noch performant. Daher sollte man sich beim Erstellen der "Einkaufsliste" überlegen, welche Variablen man wo benötigt. Membervariablen werden außerhalb aller Methodendeklarationen, also zu Beginn einer Klasse deklariert:

Class MyApp

    Dim MyText As String
    Shared Wert As Integer
    
    Public Shared Sub Main()
        ...
    End Sub
End Class

Die Variablen MyText und Wert sind zwar beide "Klassen-global", aber dennoch unterschiedlich in Ihrer Verwendung. Wenn Sie die oben beschriebene Dim-Anweisung verwenden, erstellen Sie eine Instanzvariable. D.h. Sie müssen bevor Sie die Variable im Sourcecode verwenden können eine Instanz für ein Objekt erstellen. Um von einem Objekt eine neue Instanz zu erstellen verwenden wir den New-Operator:

Class MyApp

    Dim MyText As String

    Shared Sub Main()
        Dim MyObj As New MyApp

        MyObj.MyText = "Hello!"
        Console.WriteLine("'MyText' has a value of: " + MyObj.MyText)

    End Sub
End Class

Das bedeutet, jedesmal wenn von dem Objekt eine neue Instanz erzeugt wird, wird eine neue Kopie von der Variable erstellt. In manchen Fällen ist dies aber unerwünscht, d.h. es soll unabhängig von der Instanz immer nur eine Kopie von der Variable im RAM vorhanden sein. Man verwendet dann den Shared-Modifikator statt der Dim-Anweisung:

Class MyApp

    Shared Wert As Integer
    Shared Sub Main()
        Wert = 5
    End Sub
End Class

Lokale Variablen, deren Gültigkeit nur innerhalb einer Methode zutrifft, werden innerhalb einer Methode deklariert:

Class MyApp
    
    Public Shared Sub Main()
        Dim MyLocal1 As String
        Dim MeinFlag As Boolean
    End Sub
End Class

Da wir nun die unterschiedlichen Scopes kennen, können wir uns dem nächsten Thema zuwenden:

Datentypumwandlungen

Um die Wichtigkeit der Datentypumwandlung zu erkennen sehen wir uns den folgenden Code an. Wir wollen eine Ganzzahl an der Kommandozeile ausgeben:

Class MyApp

    Shared Wert As Integer
    Shared Sub Main()
        Wert = 5
        Console.WriteLine("'Wert' has the value of: " + Wert.ToString())
    End Sub
End Class

Das "Problem" ist hier, daß die Variable Wert vom Datentyp Integer, also eine Ganzzahl, ist. Wenn wir versuchen würden in der WriteLine-Methode einfach nur "Wert" (ohne der Methode ToString) anzugeben, gibt es ein Problem - wie soll eine Zahl implizit einem String angefügt werden? Der Kompiler weiß es jedenfalls nicht, wir müssen ihm dabei helfen.

Ohne der ToString-Methode würden wir hier versuchen eine implizite Datentypumwandlung (Implicit Cast) von Integer auf String durchzuführen. In C++ zum Beispiel hätte das fatale Folgen. Daher verwenden die ToString-Methode der Int32-Struktur um das Problem zu beheben.

Mit einer impliziten Datentypumwandlung meint man, daß keine zusätzlichen Vorkehrungen getroffen werden, also kein zusätzlicher Syntax geschrieben wird. Diese ist dann sicher wenn der Ursprungsdatentyp von der Mächtigkeit geringer (weniger signifikante Stellen) ist als der Zieldatentyp (Integer auf Double, kein Präzisionsverlust). In umgekehrter Reihenfolge, also einer Umwandlung von einem mächtigeren Datentyp in einen Typ geringerer Mächtigkeit muß man beachten, daß ein Genauigkeitsverlust durch die geringere Anzahl von Nachkommastellen (Rundung!) auftritt und bei Überschreitung des Gültigkeitsbereiches des Datentyps ein Ausnahmefehler auftritt.

Bei expliziten Datentypumwandlungen kann man sich der Convert-Klasse des System-Namespaces bedienen. Die Convert-Klasse enthält alle wichtigen Konvertierungsmethoden. Explizite Typumwandlung verwenden wir zum Beispiel, wenn wir einen String der als Zahl vorliegt (23) in einen Integer umwandeln wollen:

...
    Dim Input As String
    Dim Value As Integer
    Input = "23"
    Value = Convert.ToInt32(Input)
...

Wo dies seine Anwendung finden kann ist bei der Eingabe von Daten an der Kommandozeile:

Die Eingabe von Daten an der Kommandozeile

Als einfaches Beispiel wollen wir "Hello World" erweitern. Der Benutzer soll nun aufgefordert werden, seinen Namen einzugeben. Er erhält als Ausgabe seinen Namen und wann er das Programm ausgeführt hat. Was brauchen wir hierfür? Abgesehen von der Namespace-Deklaration, dem Klassenblock und einer Main-Prozedur eine Methode die die Benutzereingabe von der Kommandozeile einliest. In der SDK-Dokumentation finden wir in der Console-Klasse die ReadLine-Methode, die Zeichen von der Komandozeile einliest und somit die Aufgabe erfüllt. Weiters wollen wir noch wissen wann das "Programm" aufgerufen wurde. Diese Funktionalität (Datum und Uhrzeit des Aufrufs) finden wir in der DateTime-Struktur des System-Namespaces: die Eigenschaft (Property) Now. Der benötigte Sourcecode könnte so aussehen:

Imports System

Class MyApp

    Shared CurrentUsrName As String

    Public Shared Sub Main()
        Console.Write("Please enter your name: ")
        CurrentUsrName = Console.ReadLine()
        Console.WriteLine("Hello " + CurrentUsrName + _
		     "! You accessed the program at " + System.DateTime.Now + ".")
    End Sub

End Class

Die Variable für den aktuellen Benutzernamen (CurrentUsrName) habe ich hier global und instanzlos definiert, damit man sie eventuell weiter verwenden kann und es nur eine Kopie von dieser Variable gibt. Das Programm ist fertig und wir speichern es unter dem Namen hello.vb. Zum manuellen Kompilieren ist wieder folgendes an der Kommandozeile einzugeben:

vbc hello.vb /m:MyApp /out:Hello.exe /t:exe

Wenn wir nun Hello an der Kommandozeile ausführen und einen Namen eingeben, erhalten wir folgendes Resultat:

Wie vorher bei der expliziten Datentypumwandlung erwähnt, kann es nötig sein Zeichenketten die in Form einer Zahl vorliegen in numerische Datentypen umzuwandeln. Nehmen wir als einfaches Beispiel die Addition von zwei Zahlen. Der Benutzer soll zwei Zahlen eingeben, die dann addiert werden und das Ergebnis soll ausgegeben werden.

Des weiteren wollen wir die beiden Zahlen gleich direkt beim Aufruf des Programms übergeben. Der Main-Methode übergeben wir die Werte as Parameter. Die Werte werden dabei in ein String Array (Datenfeld) abgelegt. Die genaue Erklärung und Verwendung von Arrays folgt in einem der weiteren Artikel. Daher schreiben wir kurz:

Class AddSamp

    Shared Sub Main(ByVal args() As String)
        Dim A As Double

        A = Convert.ToDouble(args(0)) + Convert.ToDouble(args(1))
        Console.WriteLine("Add-Result: " + A.ToString())
    End Sub
End Class

Dieses Bespiel Speichern wir unter AddSample.vb und kompilieren es. An der Kommandozeile geben wir ein:

vbc AddSample.vb /m:AddSamp /out:AddSample.exe /t:exe

Nach der Kompilierung können wir das Programm gleich ausprobieren. Wichtig dabei ist, daß wir nicht vergessen zwei Zahlen, die addiert werden sollen, anzugeben. Wenn wir sie vergessen würden, würden wir einen Ausnahmefehler erhalten, der besagt, daß ein Index außerhalb des Bereichs liegt (IndexOutOfRangeException). Dies liegt darin begründet, daß das Datenfeld, welches unsere Parameter enthält, in diesem Fall leer ist. Rufen wir das Programm mit

AddSample 5.2 3.14

auf, erhalten wir an der Kommandozeile die Ausgabe:

Add-Result is: 8.34

Sie werden sich vielleicht fragen, warum nicht gleich ein Array vom Typ Double in der Parameterliste der Main-Methode verwendet wurde. Da die Main-Methode der Einsprungpunkt des Programmes ist darf diese nur eine spezielle Signatur haben. Die Angabe eines Double-Arrays würde dem widersprechen. Da Kommandozeilen-Programme Parameter übernehmen können sollen, ist die Übergabe eines String-Arrays erlaubt. Die Verwendung eines Feldes begründet sich darin, daß mehrere Parameter übergeben werden können. Denken Sie z.B. an den Format-Befehl zum formatieren eines Laufwerks.

Die Verwendung der ToDouble Methode ist hier deshalb notwendig damit die Zahlen laut der Aufgabenstellung algebraisch addiert werden. Würden Sie die übergebenen Zahlen als Strings belassen, würde bei Übergabe von 2 und 3 das Resultat "23" und nicht richtigerweise "5" sein.

Diese Beispiele sind ja einfachst. Leider gibt es Situationen wo das Programm nicht beim ersten Mal kompiliert. Je nach Art des Fehlers wird man mit mehr oder weniger verständlichen Fehlermeldungen des Kompilers konfrontiert.

Wenn einmal Fehler passieren

Wenn ein solcher Fall auftritt ist es zwar fürs erste frustrierend, aber nicht hoffungslos. Denn man findet sämtliche Kompilerfehlermeldungen in der SDK-Dokumentation, die dort genauer erklärt werden. Nehmen wir hierzu unser "HelloWorld" Beispiel her. Was passiert wenn wir z.B. den Shared-Modifikator in der Deklaration der Main-Prozedur "vergessen" würden? Beim Kompilieren erhalten wir folgenden Fehler:

vbc : error BC30737: No accessible 'Main' method with an appropriate signature was found in 'MainApp'.

Das geübte Auge erkennt, daß hier der Kompiler die Signatur des Einsprungpunktes (die Main-Prozedur) in der MainApp-Klasse nicht finden konnte. Als Anfänger tut man sich mit der Interpretation dieser Fehlermeldung etwas schwer. In einem solchen Fall kopieren wir den Fehlercode (BC30737) des Kompilers in die Zwischenablage und öffen die SDK-Dokumentation. Im Suchen-Reiter fügen wir in das Eingabefeld den Fehlercode von der Zwischenablage ein. Um die Suche zu beschleunigen begrenzen wir im Filterfeld die Suche auf "Visual Basic":

Wir erhalten einen exakten Treffer und eine detailierte Anweisung was zu ändern ist:

Obwohl der Fehler einfach war soll diese Demonstration zeigen, daß die SDK-Dokumentation auch bei der Fehlersuche ein mächtiges Hilfsmittel ist.

Schlußbemerkung

Dieser erste Einstiegsartikel sollte Ihnen einen leichten Zugang zu der Vielfalt von VB .NET geben. Die Demo-Beispiele finden Sie in der Downloadsektion, damit Sie nach der Installation der Voraussetzungen für VB .NET gleich selbständig Ihre ersten Schritte wagen können. In den folgenden Artikeln zu dieser Serie werden Sie Schritt für Schritt in die Programmierung mit VB.NET eingeführt werden. Im nächsten Artikel befassen wir uns mit den Operatoren, Kontrollstrukturen und Schleifen.

This printed page brought to you by AlphaSierraPapa

Download des Codes

Klicken Sie hier, um den Download zu starten.
http://www.aspheute.com/code/20031128.zip

Verwandte Artikel

Datenbankzugriff mittels ADO.NET
http:/www.aspheute.com/artikel/20001102.htm
Einführung in ASP.NET Web Forms
http:/www.aspheute.com/artikel/20000808.htm
Sprachenintegration in .NET
http:/www.aspheute.com/artikel/20011010.htm

Links zu anderen Sites

.NET Framework Software Development Kit (SDK)
http://www.dotnetgerman.com/links/dl_dotnetsdk.asp
SharpDevelop
http://www.icsharpcode.net/OpenSource/SD/
Visual Studio .NET
http://msdn.microsoft.com/vstudio/