3.1 Das erste Visual Basic-Beispiel - · PDF fileKapitel 3 · Werkzeugtest, Debuggen,...

47

3 Werkzeugtest, Debuggen, VS.NETIn den ersten beiden Kapiteln haben Sie eine Übersicht über .NET Frame-work, das .NET Framework SDK sowie die EntwicklungsumgebungVisual Studio .NET (VS.NET) erhalten. Zudem sollte die Infrastrukturzum Erstellen von .NET-Anwendungen unter Visual Basic eingerichtetsein. In diesem Kapitel geht es um die grundlegenden Schritte zum Erstel-len einer .exe-Datei aus dem Visual Basic-Quellcode. Dafür habe icheinige Beispiele vorbereitet. An Hand dieser Beispiele lernen Sie die Op-tionen des Visual Basic-Compilers kennen und können zudem verifizieren,ob Ihr Rechner zur Entwicklung von .NET-Anwendungen vorbereitet ist.Neben den rudimentären Schritten, mit denen ein Beispiel manuell auf derKonsolenebene in eine lauffähige Anwendung übersetzt wird, ist dasWissen um Alternativen ganz nützlich. In einem eigenen Abschnitt zeigeich Ihnen deshalb, wie Sie das Übersetzen mit .bat-Dateien vereinfachenkönnen. Besitzer des .NET Framework SDK bzw. der .NET Redistribu-table können zudem auf die von mir entwickelte DotNet-IDE zurückgrei-fen. Diese erlaubt das Editieren der Quellcodes sowie das Übersetzen undAusführen zentral aus einem Formular unter Windows vorzunehmen.Wer über Visual Studio .NET verfügt, findet in diesem Kapitel neben einerKurzeinführung in das Programm auch Hinweise, um die Buchbeispielemit VS.NET zu bearbeiten. Weitere Abschnitte befassen sich mit dem Tes-ten von .NET-Anwendungen im Microsoft CLR-Debugger oder in dem inVisual Studio .NET integrierten Debugger. Zudem gibt es am Kapitelendeeinige Hinweise, wie Sie die Online-Hilfe der betreffenden Produkte nut-zen und Informationen über die .NET Framework-Klassenbibliothek ab-rufen.

3.1 Das erste Visual Basic-BeispielAls Erstes sollten Sie überpfüen, ob Ihr Rechner korrekt für das Überset-zen von Visual Basic-Beispielen in lauffähige .NET-Anwendungen einge-richtet ist. Dieser Test erfolgt an Hand eines sehr einfachen Visual Basic-Programms, welches direkt mit dem Visual Basic-Compiler übersetztwird. Dieses Testbeispiel möchte ich mit Ihnen Schritt für Schritt durch-gehen, um Ihnen die grundsätzliche Vorgehensweise beim Erstellen von.NET-Anwendungen zu zeigen.

Das Beispiel erfordert nur den korrekt eingerichteten Visual Basic-Compiler und eine Quellcodedatei, die sich mit dem Windows-Editorerstellen lässt. Daher ist es unerheblich, ob Sie Visual Studio .NET, das.NET Framework SDK oder lediglich .NET Framework auf dem Rech-ner installiert haben. Der gleiche Ansatz wird auch in den Folgekapi-teln, die zur Einführung in Visual Basic dienen, benutzt. Erst zu einemspäteren Zeitpunkt steige ich auf Visual Studio .NET um, umbestimmte Entwicklungsschritte in dieser Umgebung auszuführen.

Kap03.fm Seite 47 Freitag, 20. September 2002 3:18 15

Das erste Visual Basic-Beispiel

48

0

magnum

'************************************************' File: Test.vb ' Autor: G. Born www.borncity.de' Erzeugt ein einfaches Meldungsfeld unter Windows.'************************************************Module Test Sub Main() Microsoft.VisualBasic.MsgBox ("Es hat geklappt!") End SubEnd Module

Listing 3.1: Erstes Testprogramm Test.vb

Bild 3.1: Speichern des Visual Basic-Programms im Editor

1. Starten Sie den Windows-Editor (oder einen anderen Editor) undgeben Sie den Quellcode aus 51

2. Die Zeilen, die mit einem Anführungszeichen ' beginnen, leiten einenKommentar ein und können beim Eintippen weggelassen werden.Beginnen Sie ggf. mit der Zeile Module Test.

3. Sobald alles eingetippt wurde, speichern Sie den Quellcode. WählenSie im Windows-Editor im Menü DATEI den Befehl SPEICHERNUNTER. Wichtig: Setzen Sie im Dialogfeld DATEI SPEICHERN UNTERden Dateityp auf Alle Dateien (*.*). Als Dateiname geben Sie Test.vbein (Abbildung 3.1). Klicken Sie dann auf die Schaltfläche SPEI-CHERN.


Kapitel 3 · Werkzeugtest, Debuggen, VS.NET

49

4. Sobald das Quellprogramm als Test.vb auf der Festplatte vorliegt,können Sie den Editor beenden. Öffnen Sie das Fenster der Eingabe-aufforderung, wechseln Sie zum Ordner mit der Quellcodedatei undübersetzen Sie das Visual Basic-Programm gemäß den nachfolgendenAusführungen.

Zum Übersetzen (Kompilieren) einer Visual Basic-Quellcodedatei benöti-gen Sie den Visual Basic-Compiler vbc.exe. Dieser Compiler wird mit.NET Framework sowie dem .NET Framework SDK (also auch mitVisual Studio) installiert und befindet sich im Windows-VerzeichnisMicrosoft.NET\Framework\v1.0.3705. Es handelt sich bei vbc.exe umeine Konsolenanwendung, die nur im Fenster der Eingabeaufforderungsinnvoll aufgerufen werden kann.

Bild 3.2: Erweitertes Kontextmenü zum Aufruf der Konsole

Öffnen Sie das Fenster der Eingabeaufforderung über das Windows-Startmenü und wechseln Sie in das Verzeichnis mit dem Beispielpro-gramm Test.vb. Geben Sie nun im Fenster der Eingabeaufforderung denfolgenden Befehl ein:

vbc test.vb(Enter)

Sofern Sie den Pfad gemäß den Ausführungen im vorhergehenden Kapi-tel korrekt gesetzt haben, wird der Compiler starten und das Programmübersetzen. Bei einem fehlerfreien Ablauf erhalten Sie die in Abbildung3.3 aufgeführten Meldungen des Visual Basic-Compilers. Alles in allemist das nichts sonderlich Spektakuläres. Hinter den Kulissen wird aberdas VB-Programm in eine lauffähige .exe-Datei übersetzt. Wenn allesgeklappt hat, sollen Sie im Ordnerfenster auf der Windows-Ebene dieneue Datei Test.exe vorfinden (Abbildung 3.4).

Um das Fenster der Eingabeaufforderung per Kontextmenü eines Ord-ners aufrufen und dabei automatisch zu diesem Ordner wechseln zukönnen (Abbildung 3.2), benötigen Sie eine Windows-Shell-Erweite-rung. Sie finden diese jeweils an Windows 9x bzw. Windows NT/2000/XP angepasste Datei DOS.inf im Ordner \Tools in den UnterordnernWin9x und WinNT. Klicken Sie mit der rechten Maustaste auf diebetreffende .inf-Datei und wählen Sie im Kontextmenü den BefehlINSTALLIEREN. Die Erweiterung lässt sich in der Systemsteuerung überdas Symbol SOFTWARE (Dialogfeld oder Registerkarte zum Deinstallie-ren von Software) wieder entfernen. Hinweise zur Funktion und zu denInterna der .inf-Datei finden Sie in dem bei Microsoft Press publizier-ten Titel »Arbeiten mit der Registrierung von Windows 2000/XP«.


Das erste Visual Basic-Beispiel

50

0

magnum

Bild 3.3: Übersetzen des Beispiels in der Eingabeaufforderung

Bild 3.4: Visual Basic-Beispieldatei und lauffähige .exe-Datei

Sobald Sie die .exe-Datei Test.exe im Ordnerfenster mit einem Dop-pelklick anwählen, sollte das in Abbildung 3.5 gezeigte Dialogfeld TESTmit der Meldung Es hat geklappt! erscheinen. Dies bedeutet, dass dasBeispielprogramm korrekt übersetzt und in eine lauffähige .NET-Anwen-dung transformiert wurde.

Lässt sich der Visual Basic-Compiler nicht starten, prüfen Sie bitte diePfadangaben (siehe auch Kapitel 2). Treten Fehlermeldungen beim Über-setzen auf, haben Sie vermutlich beim Abtippen des Listings einen Fehlergemacht. Zur Not können Sie die Datei Test.vb aus dem Ordner\Beisp\Kap03 der Begleit-CD in einen lokalen Ordner der Festplattekopieren und das Programm zum Testen verwenden.

Weigert sich Windows, das Programm Test.exe auszuführen, bedeutetdies, dass .NET Framework nicht korrekt auf dem Rechner installiertist. Dies sollte eigentlich bei der Entwicklungsmaschine nicht der Fallsein, da ja der Visual Basic-Compiler ebenfalls eine .NET-Anwendungdarstellt und erfolgreich ausgeführt wurde.

Kopieren Sie die Datei Test.exe dagegen auf einen anderen Rechnerund erscheint eine Fehlermeldung beim Ausführen, bedeutet dies, dassdort .NET Framework fehlt. Dann sollten Sie gemäß den Ausführun-gen in Kapitel 2 vorgehen und die .NET Framework Redistributableeinmalig auf diesem Rechner installieren.



51

Windows-Konsolenanwendungen, Programme mit SchönheitsfehlernIst Ihnen bei der Ausführung des obigen Beispiels noch etwas aufgefal-len? Die Anzeige des Dialogfelds ist ja ganz nett, aber irgendwie stört esschon, dass beim Aufruf der .exe-Datei gleichzeitig das Fenster der Ein-gabeaufforderung geöffnet wird (Abbildung 3.5). Offenbar hat derVisual Basic-Compiler beim Übersetzen eine so genannte Konsolenan-wendung für Windows erzeugt. Konsolenanwendungen öffnen beimAufruf jedes Mal das Fenster der Eingabeaufforderung. Windows-Anwender sind es aber gewohnt, dass Programme mit einem Fenster undohne Öffnen der Eingabeaufforderung starten.

Bild 3.5: Eingabeaufforderung und Meldung des Visual Basic-Beispiels

Der Grund: Die Standardvorgabe des Visual Basic-Compilers sieht dieÜbersetzung einer Quelldatei in eine Konsolenanwendung vor. Dies istim Kontext von .NET verständlich, da .NET-Anwendungen nichtzwangsweise unter Windows laufen müssen. Sie haben aber die Möglich-keit, echte Windows-Programme in Visual Basic .NET über spezielleCompilereinstellungen zu erzeugen. Wie dies geht, wird in den folgendenAbschnitten behandelt.

3.2 Die Visual Basic-CompilereinstellungenDer im ersten Beispiel benutzte Befehl vbc Test.vb ist gleichzeitig die ein-fachste Form des Compileraufrufs. Der Visual Basic-Compiler kennt eineganze Reihe an Schaltern und Optionen, mit denen sich das Ergebnis derAusgabe beziehungsweise der Übersetzungsvorgang steuern lässt. Diefolgende Tabelle enthält eine Übersicht über einige hilfreiche Schalter.

Eine Übersicht erhalten Sie, indem Sie auf Konsolenebene den Befehlvbc /? eintippen und diesen mit (Enter) abschließen. Die .NET Frame-work SDK-Hilfe enthält zudem weitere Informationen zu den Optionendes Compilers.


Die Visual Basic-Compilereinstellungen

52

0

magnum

Schalter Bedeutung

/target:xxx oder /t:xxx Legt das Zielformat fest, wobei /t: als Kurzform verwendet werden kann. Fehlt der Schalter, ver-wendet der Compiler automatisch /t:exe und erstellt eine Windows-Konsolenanwendung. Verwenden Sie die Option /t:winexe, um eine lauffähige Windows-Anwendung zu erstellen. Mit /t:library erzeugt der Compiler keine .exe- sondern eine .dll-Bibliotheksdatei. Die Vorgabe /t:module generiert eine Moduldatei, die einer Assembly hinzugefügt werden kann.

/out:name Gibt den Namen der Ausgabedatei vor. Fehlt der Schalter, verwendet der Compiler den Namen der Eingabedatei auch für die Ausgabe, fügt aber die entsprechenden Dateinamenerwei-terungen hinzu.

/addmodule:module,module1 Dieser optionale Schalter gibt eine Liste von Moduldateien an, die beim Übersetzen mitein-bezogen werden. Die Moduldateien müssen mit /t:module generiert worden sein. Die Module müssen sich im gleichen Ordner wie die Quell-datei befinden.

/imports:namespace,... Dieser optionale Schalter gibt eine Liste an Namensräumen an, die beim Übersetzen zu importieren sind. Alternativ lassen sich die Imports-Anweisungen auch im Quelltext ange-ben.

/reference:name

oder /r:name

Dieser optionale Schalter legt Referenzen auf Bibliotheksdateien (.dll-Dateien) fest, die beim Übersetzen zu berücksichtigen sind. Der Compi-ler importiert dann Metadaten aus den betref-fenden Assemblies.

/debug Generiert eine Symboldatei, die vom Debugger zum Testen der Anwendung benötigt wird

/win32icon:name Weist der .exe-Datei die angegebene Symbol-datei zu

Tabelle 3.1: Einige Optionen des Visual Basic-Compilers

Sie können die Compileroptionen samt Name der zu übersetzendenDatei auch in einer Textdatei (z.B. Form.txt) hinterlegen. Beim Über-setzen ist die Datei in der Form @name als Compileroption anzugeben.Die Anweisung vbc @form.txt veranlasst den Visual Basic-Compiler,alle Optionen aus der Datei Form.txt einzulesen. Auf der Begleit-CDfinden Sie die Datei Form.txt, die solche Optionen enthält.



53

3.2.1 Verwenden der /imports-OptionBei den Compileroptionen ist auch der Schalter /imports:name dabei. Washat es mit diesem Schalter auf sich? Microsofts Ansatz war ja, alle Funk-tionen in den diversen .NET-Programmiersprachen bereitzustellen. Daherbesitzt die Sprache Visual Basic selbst nur noch die rudimentären Opera-toren. Die meisten Funktionen wie mathematische Operationen, Ein-/Ausgabeanweisungen etc. werden aus der .NET Framework-Klassen-bibliothek übernommen. In den vorhergehenden Kapiteln wurde aberbereits erwähnt, dass sich die Framework-Klassenbibliothek durch einehierarchische Struktur auszeichnet. Für den Zugriff auf eine bestimmte»Funktion« innerhalb der Klassenbibliothek wird der so genannteNamensraum (englisch Namespace) angegeben. Dies ist essentiell undwird Sie in allen Visual Basic-Programmen auf Schritt und Tritt begleiten.

Bild 3.6: Meldungen im Konsolenfenster beim Erstellen von Hallo.exe

In unserem ersten Testprogramm Test.vb wurde bereits unter der Handein solcher Namensraum benutzt. Das Programm verwendet dieMethode MsgBox, die aber in der Klassenbibliothek im NamensraumMicrosoft.VisualBasic enthalten ist. Im Programmcode habe ich daherden kompletten Namensraum angegeben:

Microsoft.VisualBasic.MsgBox ("Es hat geklappt")

Bei umfangreicheren Programmen ist es aber sehr umständlich, jedes Malden kompletten Namensraum vor die Namen von Methoden oder Eigen-schaften zu setzen (was Methoden und Eigenschaften sind, wird späternochmals genauer erläutert). Die .NET-Compiler erlauben die Vorgabeder Namensräume über zwei Varianten:

� Sie können die Namensräume im Programmkopf des Quellcodes auf-führen (wird in den Beispielen der folgenden Kapitel genutzt und istwegen der damit verbundenen Transparenz bei der Entwicklung mitdem SDK zu empfehlen).


Die Visual Basic-Compilereinstellungen

54

0

magnum

� Sie können beim Übersetzen angeben, welche Namensräume zu ver-wenden sind (dieser Ansatz wird von VS.NET verfolgt, da das Pro-gramm Verweise intern in Konfigurationsdateien speichert).

Dies soll jetzt einmal an einem weiteren Beispielprogramm demonstriertwerden. Ohne jetzt auf die Details des Codes einzugehen, möchte icheine Konsolenanwendung benutzen. Das Programm öffnet beim Dop-pelklick auf die .exe-Datei das Fenster der Eingabeaufforderung undzeigt eine Meldung an (Abbildung 3.6, untere Zeilen). Damit Windowsdas Fenster der Konsole nicht sofort schließt, wartet die Anwendungnoch auf eine Benutzereingabe. Um das Programm zu erstellen, startenSie den Editor und geben den folgenden Programmcode ein.

'************************************************' File: Hallo.vb ' Autor: G. Born www.borncity.de' Gibt unter Windows Meldungen auf der Konsole aus' und wartet auf das Drücken einer Taste.' Übersetzen mit vbc.exe hallo.vb /imports:system'************************************************Module Hallo Sub Main Dim test As String Console.WriteLine("Hallo, bitte die Eingabetaste drücken!") test = Console.ReadLine End SubEnd Module

Listing 3.2: Konsolenanwendung Hallo.vb

Anschließend speichern Sie das Programm in die Datei Hallo.vb undübersetzen es. Sofern Sie die Anweisung vbc Hallo.vb verwenden, erhal-ten Sie die im oberen Teil von Abbildung 3.6 gezeigten Fehlermeldungen»... Der Name Console wurde nicht entdeckt ...«. Der Compiler hat beimÜbersetzen die Anweisungen mit den Methodenaufrufen WriteLine undReadLine des Objekts Console gefunden, weiß nun aber nicht, wo er diebetreffenden Methoden der zu Grunde liegenden Klasse »her bekommt«.In der Hilfe gibt es den Hinweis, dass sich die betreffende Klasse Consoleim Namensraum System der .NET Framework-Klassenbibliothek befin-det. Folglich müssen wir dem Visual Basic-Compiler beim Erstellen der.exe-Datei den Namensraum mitteilen. Gemäß den obigen Anweisungenist dies durch Angabe des Schalters /imports möglich. Der Befehl zumÜbersetzen des Beispiels muss daher in der Form

vbc hallo.vbs /imports:system

angegeben werden. Sobald Sie diese Anweisung im Fenster der Eingabe-aufforderung eintippen, sollte das Beispiel fehlerfrei übersetzt werden.Starten Sie anschließend die .exe-Datei hallo.exe, erscheint die in Abbil-dung 3.6 in den untersten Zeilen aufgeführte Ausgabe.



55

Nicht jeder möchte die /imports-Option beim Übersetzen einer Quellda-tei angeben. Dies ist bei jedem manuellen Aufruf des Compilers mitTipparbeit verbunden. Zudem ist bei der Weitergabe von Quelldateienmeist unbekannt, welche Namensräume in einem Programm benutztwerden. Um dies zu vereinfachen, besteht die Möglichkeit, die benutztenNamensräume direkt im Quellcode des Programms anzugeben. Dies istbei der manuellen Entwicklung von .NET-Anwendungen zu empfehlen(in VB.NET können Sie darauf verzichten, da dort die Verweise interngespeichert und beim Übersetzen berücksichtigt werden). Das folgendeListing demonstriert diesen Ansatz (die Zeilennummern wurden lediglichzur Verdeutlichung im abgedruckten Listing eingefügt).

01 '************************************************02 ' File: Hallo1.vb 03 ' Autor: G. Born www.borncity.de04 ' Gibt unter Windows Meldungen auf der Konsole aus05 ' und wartet auf das Drücken einer Taste.06 ' Übersetzen mit vbc.exe Hallo1.vb07 '************************************************08 Imports System09 Module Hallo10 Sub Main11 Dim test As String12 Console.WriteLine("Hallo, bitte die Eingabetaste drücken!")13 test = Console.ReadLine14 End Sub15 End Module

Listing 3.3: Beispielprogramm mit integrierter Imports-Anweisung

In Zeile 8 findet sich die Angabe Imports System, die dem Compiler mit-teilt, dass er die Klassenbibliothek System nach entsprechenden Namendurchsuchen soll. Dieses Beispiel lässt sich wieder mit der einfachenAnweisung vbc hallo1.vbs übersetzen.

In den Beispielen dieses Buches werde ich den zuletzt benutzten Ansatzverwenden und die Importe generell im Programmkopf mit demImports-Befehl angeben.

Sie finden die beiden Beispieldateien Hallo.vb und Hallo1.vb im Ord-ner \Beisp\Kap03 der Begleit-CD. Kopieren Sie ggf. diese Quelldateienin ein Verzeichnis der Festplatte, bevor Sie die Dateien übersetzen.


Erstellen einer Windows-Anwendung

56

0

magnum

3.3 Erstellen einer Windows-AnwendungDas in Abbildung 3.5 gezeigte Beispiel Text.exe öffnet beim Start ausWindows zunächst das Fenster der Eingabeaufforderung und anschlie-ßend erscheint erst das Dialogfeld mit der Meldung. Das Fenster der Ein-gabeaufforderung ist bei Konsolenprogrammen ja ganz nützlich. BeiWindows-Anwendungen erwartet der Benutzer aber zu Recht, dass die-ses nicht erst das Fenster der Konsole öffnet, um dann ggf. ein Formularanzuzeigen.

3.3.1 So kompilieren Sie Windows-Anwendungen richtig

Aus Tabelle 3.1 können Sie den Hinweis entnehmen, dass die Option/t:winexe den Compiler veranlasst, Windows-Anwendungen zu erstellen.Fehlt diese Option in der Befehlszeile, generiert der Compiler beimanschließenden Erstellen der .exe-Datei automatisch Code für eine Kon-solenanwendung. Geben Sie daher auf der Kommandozeile einmal denfolgenden Befehl ein:

vbc Test.vb /t:winexe /out:Test1.exe

Die Option /out:Test2.exe bewirkt übrigens, dass die Ausgabe in dieDatei Test1.exe umgeleitet wird. Wenn Sie anschließend die Ergebnisda-tei Test1.exe per Doppelklick starten, wird das Dialogfeld mit der Mel-dung direkt unter Windows geöffnet (das Fenster der Eingabeaufforde-rung erscheint nicht mehr).

Wie lässt sich der Windows-Programmdatei ein Symbol zuweisenWenn Sie eine .exe-Datei mittels der Option /t:winexe erstellen, lässtsich diese zwar ohne Umweg über das Fenster der Eingabeaufforderungaufrufen. Allerdings erhalten die so erzeugten Programmdateien nochdas Symbol für eine MS-DOS-Anwendung (Abbildung 3.7, links).

Möchten Sie der Windows-Anwendung, wie in Abbildung 3.7 rechtsgezeigt, ein eigenes Symbol zuweisen? Dies erfordert einmal, dass Sieüber geeignete Symboldateien verfügen, die im ICO-Format mit Dateina-

Bei der in Kapitel 2 erwähnten Entwicklungsumgebung SharpDevelopwerden standardmäßig Konsolenanwendungen erzeugt. Ich habe es inder mir vorliegenden Fassung (vielleicht wegen fehlender Dokumenta-tion) nicht geschafft, direkt eine Windows-Anwendung zu kompilieren.Zum Erstellen von Windows-.exe-Dateien musste ich mir bei erstenTests den Befehl COMPILE zum Übersetzen der Quelldatei mittels derOption /t:winexe definieren. Die weiter unten vorgestellte Entwick-lungsumgebung DotNet-IDE bietet hier mehr Komfort. Sofern SieVisual Studio .NET verwenden, müssen Sie sich über diese Feinheitenauch keine Gedanken machen. Die Entwicklungsumgebung generiertautomatisch Windows-Anwendungen, falls Sie die entsprechendenProjektvorlagen verwenden (siehe folgende Abschnitte).



57

menerweiterung .ico vorliegen. Diese Symboldateien lassen sich über denSchalter /Win32Icon:Name beim Übersetzen in die .exe-Datei einbinden.Um die Beispieldatei Test.vb in eine lauffähige Windows-Anwendungmit eigenem Symbol zu übersetzen, geben Sie auf der Konsolenebene fol-genden Befehl ein.

vbc test.vb /t:winexe /Win32Icon:Test.ico /out:test2.exe

Es wird hier vorausgesetzt, dass im Ordner mit der Quelldatei Test.vbauch eine Symboldatei Test.ico vorliegt. Die Ausgabe erfolgt in der Dateitest2.exe. Wenn alles geklappt hat, sollte die .exe-Datei das in Abbildung3.7 rechts gezeigte Symbol aufweisen.

Bild 3.7: Symbole für Programme

Wie kommt man an Symboldateien?Wer Visual Studio .NET besitzt, verfügt auch über einen integrierten Edi-tor für Symboldateien. Sie können über die Schaltfläche NEU der Anwen-dung eine Symboldatei als Typ wählen. Wer nur den .NET FrameworkSDK besitzt, muss auf Sammlungen von Symboldateien ausweichen. ImInternet finden sich neben diesen Symboldateien auch so genannte Icon-Editoren als Shareware, mit denen sich Symbole aus bestehendenAnwendungen extrahieren oder selbst erstellen lassen. Windows-Sym-boldateien erlauben dabei die Icons mit verschiedenen Auflösungen undFarbtiefen zu speichern. Das Icon-Format kann ab Windows 95 sogarmehrere Bilder pro Datei hinterlegen. Zudem unterstützt das Formattransparente Farben.

Falls Sie auf die Schnelle selbst einige Symboldateien erstellen möchten,gibt es eine alternative Lösung. Starten Sie das Windows-ProgrammPaint und entwerfen Sie eine Symboldatei mit 32x32 Pixel Auflösung.Die Auflösung lässt sich über den Befehl ATTRIBUTE im Menü BILD ein-stellen. Anschließend speichern Sie diese Datei im BMP-Format, wobeiallerdings nur 16 Farben benutzt werden dürfen. Eine entsprechendeOption zur Reduzierung der Farben findet sich im Dialogfeld zumSpeichern im Feld DATEITYP. Die so erzeugte .bmp-Datei lässt sich lei-der noch nicht zum Einbinden in .exe-Anwendungen nutzen. Sie müs-sen das BMP-Format in das ICO-Format umsetzen. Auf der Buch-CDfinden Sie im Ordner \Tools\IconEdit das Programm IconEdit.exe. Eshandelt sich um einen von mir vor vielen Jahren in Turbo Pascal imRahmen einer Programmierübung erstellten Icon-Editor. Da das Pro-gramm noch aus Windows 3.1-Zeiten stammt und kein Quellcodemehr vorliegt, ist die Unterstützung auf 16 Farben begrenzt. Der Icon-Editor besitzt aber eine Funktion zum Importieren von Bildern imBMP-Format. Das eingelesene Bild lässt sich dann als .ico-Datei spei-chern und diese .ico-Datei kann direkt vom Visual Basic-Compiler ein-gebunden werden.


Erstellen einer Windows-Anwendung

58

0

magnum

3.3.2 Referenzen auf BibliotheksdateienAbschließend möchte ich noch auf ein weiteres Problem eingehen. Diebisherigen Beispiele ließen sich ohne großen Aufwand übersetzen, soferndie benutzten Namensräume im Programm identifiziert werden können(z.B. durch Angabe der Imports-Anweisung im Quellcode oder beimÜbersetzen). Aber dies reicht nicht immer aus. Schauen wir uns einmalein Visual-Programm an, welches beim Aufruf ein leeres Formulargemäß Abbildung 3.8 erzeugt.

Bild 3.8: Einfaches leeres Formular

'************************************************' File: Form.vb ' Autor: G. Born www.borncity.de' Erzeugt ein leeres Formular unter Windows.'************************************************Imports System.DrawingImports System.Windows.Forms

Module Formular

Sub Main() Dim oF As New frmHaupt() ' Formular anlegen Application.Run (oF) ' .. und anzeigen End Sub

Public Class frmHaupt' Hier ist der Class-Code zum Erstellen des Formulars Inherits System.Windows.Forms.Form Sub New() ' New-Construktor zum Anlegen MyBase.New() Me.Text = "Borns Primitiv-Formular" Me.Width = 300 Me.Height = 100 Me.Left = 100 Me.Top = 200 End Sub End ClassEnd Module

Listing 3.4: Code zum Erzeugen eines Formulars



59

Im Quellcode werden die Namensräume System.Drawing und ImportsSystem.Windows.Forms aufgeführt. Die weiteren Details des in Listing3.4 gezeigten Quellcodes müssen Sie jetzt nicht interessieren – daraufgehe ich zu einem späteren Zeitpunkt noch ein.

Wenn Sie das betreffende Programm im Fenster der Eingabeaufforde-rung mit der Anweisung

vbc Form.vb

übersetzen, liefert der Compiler Ihnen einige Fehlermeldungen, die dasObjekt Me bemängeln. Irgendwie kann der Visual Basic-Compiler nichtsmit den Befehlen zum Anzeigen des Formulars anfangen – obwohl derImports-Befehl die zu verwendenden Namensräume festlegt. An dieserStelle kommen Verweise auf Bibliotheken ins Spiel. Um Klassen, die sichin Namensräumen (Namespaces) befinden, zu verwenden, ist ein Ver-weis auf die Assembly erforderlich. Konkret bedeutet dies, der Compilermuss wissen, in welcher Datei er die betreffenden Informationen findet.Bei den bisherigen Beispielen wurden nur die Standard-Bibliotheken (diesich in der Datei Mscorlib.dll befinden) benutzt. Daher musste nichtsangegeben werden.

In obigem Beispiel werden jedoch weitere Namensräume zur Anzeige desFormulars genutzt, die sich in getrennten Bibliotheksdateien (Assem-blies) befinden. Sie müssen daher beim Übersetzen die Namen aller ver-wendeten Assemblydateien über den Schalter /r:name mit angeben. DerSchalter /r bzw. /reference definiert Referenzen auf Assemblydateien. DieAnweisung zur Übersetzung des Formularbeispiels muss daher folgen-dermaßen geschrieben werden:

vbc Form.vb /r:system.dll /r:system.windows.forms.dll /r:system.drawing.dll

Bei den obigen zwei Zeilen handelt es sich um eine Anweisung, die aufder Konsolenebene einzugeben ist. Die /r:name-Anweisungen definierenReferenzen auf die benötigten Bibliotheksdateien (ein Pfad ist nichterforderlich).

Sie finden die Beispieldatei Form.vb im Ordner \Beisp\Kap03 auf derBegleit-CD.

Auf der Begleit-CD finden Sie die Datei Form.txt im Ordner \Beisp\Kap03. Mit dem Befehl vbc @Form.txt erreichen Sie, dass der VisualBasic-Compiler die Befehle aus der angegebenen Datei @Datei einliest.Die Datei Form.txt enthält die Schalter, um die benötigten Bibliotheks-dateien einzubinden. Zudem ist dort noch die Option /t:winexe enthal-ten, um eine Windows-Anwendung zu erzeugen.


Mehr Komfort beim Entwickeln

60

0

magnum

3.4 Mehr Komfort beim EntwickelnDas manuelle Übersetzen von Visual Basic-Programmen auf Konsolen-ebene wird auf Dauer recht aufwändig. Besitzer von Visual Studio .NETtangiert dies weniger, da diese Entwicklungsumgebung die betreffendenBefehle automatisch ausführt. Wer jedoch mit dem .NET FrameworkSDK unter Windows NT bzw. Windows 2000/XP arbeitet oder die .NETRedistributable unter Windows 9x zum Entwickeln einsetzt, sollte sichnach Alternativen umsehen. Vor allem, um die Übersetzung der Buchbei-spiele zu erleichtern, möchte ich Ihnen nachfolgend verschiedene Ansätzevorstellen.

3.4.1 Vereinfachung der Übersetzung mit .bat-Dateien

Der einfachste Ansatz besteht darin, Stapelverarbeitungsdateien zumÜbersetzen der Anwendungen anzulegen. Die folgenden Anweisungenübersetzen eine Quelldatei, die Code zur Anzeige eines Formulars ent-hält, in eine Windows-Anwendung und weisen darüber hinaus der .exe-Datei ein Symbol zu.REM Erstellt eine Windows-Anwendung mit einem FormularREM Pfad muss in "a" angepasst werden@Set a=F:\Beisp\Kap03\vbc %1 /t:winexe /win32icon:%a%Test.ico /r:system.dll /r:system.windows.forms.dll /r:system.drawing.dll /out:%1_.exePause "Bitte eine Taste drücken"

Listing 3.5: Datei _MakeForm.bat

Sie können per Maus eine beliebige Visual Basic-Quelldatei zum Symboldieses Stapelverarbeitungsprogramms ziehen. Sobald Sie die linke Maus-taste über dem Symbol der .bat-Datei loslassen, wird die betreffendeAnwendung übersetzt. Das Stapelverarbeitungsprogramm verwendetdabei einige Tricks. Die Set-Anweisung vereinbart eine Umgebungsvari-able a mit dem Pfad zum Ordner der Symboldatei. Sie müssen diesenPfad daher für Ihr System entsprechend anpassen. Weiterhin wird einefeste Symboldatei Test.ico eingebunden. Aber diese Symboldatei lässtsich ebenfalls ändern.

Bild 3.9: Meldungen beim Übersetzen per .bat-Datei



61

Bei Verwendung eines Stapelverarbeitungsprogramms schreibt derVisual Basic-Compiler die .exe-Datei automatisch auf das Windows-Laufwerk. Um dies zu verhindern, habe ich die Option /out:%1_.exe ver-wendet. Dabei wird dem Namen der Eingabedatei einfach der Text _.exeangehängt. Ziehen Sie also die Datei Form1.vb zur .bat-Datei, erzeugtder Compiler die Ausgabedatei Form1.vb_.exe im gleichen Verzeichnis.Dies ist zwar etwas ungewohnt, funktioniert aber zuverlässig. Bei Bedarfkönnen Sie ja die Ausgabedatei später umbenennen. Mit diesem Ansatzlassen sich sehr schnell universell verwendbare Stapelverarbeitungsda-teien erzeugen, die sich zur Übersetzung mehrerer Quellprogramme ver-wenden lassen. Solche .bat-Dateien habe ich daher in verschiedenenBeispielordnern hinterlegt, um Ihnen das Übersetzen der Beispiele zuerleichtern.

3.4.2 Entwicklung mit der DotNet-IDEIch habe einen großen Teil der Beispiele ohne Visual Studio .NET unterVerwendung des Windows-Editors entwickelt. Dabei schaute ich michsehr schnell nach einer komfortableren Lösung zum Entwickeln, Über-setzen und Testen um. Die .bat-Dateien erwiesen sich als etwas zu unfle-xibel, speziell wenn ich verschiedene Symbole oder den Schalter /debugbenötigte, um die .exe-Datei später debuggen zu können. Auch die Über-gabe von Argumenten an das zu testende Programm stand auf meinerWunschliste. Die mir beim Schreiben des Buches vorliegende SharpDeve-lop-Fassung wies mir zu viele Fehler und Einschränkungen auf. Letztlichpasste ich dann eine kleine, von mir für die Entwicklung von Scriptpro-grammen geschriebene, Entwicklungsumgebung (IDE) an Visual Basic.NET an. Das Programm DotNet-IDE.hta ist eine so genannte HTA-Anwendung (das Kürzel HTA steht für HTML-Application), die sich abdem Internet Explorer 5.0 aufrufen lässt. Es handelt sich dabei imGrunde um eine Webseite, die ein Formular mit Textfeldern, Optionsfel-dern, Kontrollkästchen und Schaltflächen bereitstellt (Abbildung 3.10,Mitte). Durch Verwendung der Dateinamenerweiterung .hta erkennt derInternet Explorer, dass es sich um eine lokal laufende Anwendung han-delt und deaktiviert die üblichen Sicherheitseinstellungen für ActiveX-Komponenten. Die Anwendung benötigt zur Ausführung den InternetExplorer 5.01 (oder höhere Versionen) sowie den Windows Script Host(ab Version 1.0).

Die Bedienung der Anwendung ist recht einfach. Über die SchaltflächenDURCHSUCHEN lässt sich jeweils ein Dialogfeld zur Auswahl der betref-fenden Datei (.vb-Datei oder .ico-Datei) öffnen (Abbildung 3.10, links

Sie finden die Stapelverarbeitungsdatei _MakeForm.bat im Ordner\Beisp\Kap03 auf der Begleit-CD. Die Abbildung 3.9 zeigt die Meldun-gen im Fenster der Eingabeaufforderung, die beim Übersetzen einerQuelldatei mit dieser .bat-Datei erscheinen. Das Fenster bleibt solangegeöffnet, bis Sie eine Taste drücken. Dies ermöglicht Ihnen, Fehlermel-dungen des Compilers zu verfolgen. Bitte beachten Sie, dass die Pfad-angabe in der Zeile @Set a= entsprechend Ihrer Umgebung angepasstwerden muss.



62

0

magnum

oben). Die ausgewählten Dateien werden samt Pfad in Textfeldern ange-zeigt, d.h. die Auswahl lässt sich auch manuell korrigieren oder dieInhalte der Textfelder können über die Zwischenablage gefüllt werden.

Die Art der Zieldatei lässt sich komfortabel über die Optionsfelder derGruppe Target wählen. Wird die Option WinExe gewählt, bindet dieUmgebung automatisch eine angegebene Symboldatei in die .exe-Anwen-dung ein. Soll die Anwendung später im Debugger getestet werden, mar-kieren Sie das Kontrollkästchen DEBUG. Dann fügt die IDE beim Aufrufdes Compilers die Option /debug zum Befehl hinzu. Der Compilererzeugt dann die vom Debugger benötigte Symboldatei.

Bild 3.10: Fenster der DotNet-IDE

Müssen Sie Bibliotheksdateien (Assemblies) einbinden oder benötigen Sieweitere Optionen, lassen sich diese direkt im Textfeld COMPILE OPTIONSeintippen. Die Übersetzung starten Sie über die Schaltfläche COMPILE.Die IDE öffnet dann das Fenster der Eingabeaufforderung und startetden Visual Basic-Compiler. Der Befehl zum Aufruf des Compilers wirddabei aus den gewählten Dateien und Optionen automatisch zusammen-gebaut. Das Fenster der Eingabeaufforderung bleibt nach dem Überset-



63

zen geöffnet, damit die Fehlermeldungen des Übersetzers zu sehen sind.Sie sollten das Fenster nach der Übersetzung manuell schließen. Auf dieseWeise lässt sich eine Anwendung mit oder ohne Debug-Modus, mit oderohne spezielles .exe-Symbol, als Konsolen- oder Windows-Anwendungoder als .dll-Datei erzeugen.

Bei der Übersetzung in eine Konsolen- oder Windows-Anwendung über-trägt die Entwicklungsumgebung den Pfad sowie den Namen der .exe-Datei in das Feld EXECUTE FILE. Klickt der Benutzer auf die SchaltflächeRUN, wird die angegebene Anwendung samt den im Textfeld PROGRAMPARAMETERS enthaltenen Argumenten ausgeführt. Das Textfeld erlaubtIhnen also auf sehr komfortable Weise, Parameter an die zu testendeAnwendung zu übergeben. Die beim Anklicken der Schaltfläche COM-PILE und RUN ausgeführten Befehle werden im Textblock COMMANDMONITOR angezeigt.

Zur Bearbeitung des Quellcodes der ausgewählten Datei klicken Sie aufdie Schaltfläche EDIT. Die Entwicklungsumgebung ist so angelegt, dassder Windows-Editor zur Bearbeitung des Quellcodes benutzt wird.

Meldet der Compiler beim Übersetzen Fehler, enthält der betreffendeText auch die Nummer der fehlerhaften Zeile. Um die Identifikation die-ser Zeilen zu erleichtern, lässt sich die Schaltfläche VIEW verwenden.Diese erzeugt dann ein Listing mit einer Zeilennummerierung und öffnetdiese temporäre Datei in einem zweiten Editorfenster.

Die Schaltfläche NEW öffnet die im gleichen Ordner wie die .hta-Dateibefindliche Vorlage VBNew.vb im Editor. Sie können die Vorlage untereinem neuen Namen speichern und dann mit Programmcode ergänzen.Die Schaltflächen ABOUT und HELP liefern Informationen zur Bedienung,mit QUIT beenden Sie die Anwendung. Da der Quellcode der .hta-Anwendung vorliegt, können Sie diese sehr schnell erweitern und anpas-sen. Es besteht sogar die Möglichkeit, das Ganze als Visual Basic .NET-Anwendung zu portieren.

Sie können den zu verwendenden Editor sehr einfach anpassen. StartenSie die Entwicklungsumgebung, klicken mit der rechten Maustaste aufdas Formular und wählen im Kontextmenü den Befehl QUELLTEXTANZEIGEN. Anschließend setzen Sie die Konstante editor im Programm-kopf auf den Namen des gewünschten Editors um. Die Konstante vbaenthält übrigens den Namen des Compilers. Sie können diesen Namenebenfalls ändern, um die Entwicklungsumgebung an C# oder andereSprachen anzupassen.

Sie finden die Datei \DotNET-IDE.hta im Ordner \Tools\NET_IDEder Begleit-CD. Nach Projektabschluss habe ich die .hta-Anwendungnach .NET portiert und mit kleineren Funktionsänderungen versehen.Diese Fassung liegt als DotNET-IDE.exe im gleichen Ordner vor – dieQuellcodes sind im Unterordner DotNET-IDE-Source hinterlegt.Details zum Umgang mit dem Programm finden Sie in der Datei Dot-NET-IDE.chm.



64

0

magnum

Die folgenden Kapitel setzen aus didaktischen Gründen auf dem .NETFramework SDK auf. Zudem eröffnet dies auch Lesern, die keinenZugriff auf Visual Studio .NET besitzen, die Möglichkeit zum Einstieg indie Programmierung mit Visual Basic .NET. Verfügen Sie über VisualStudio .NET und bevorzugen Sie das Arbeiten mit dieser Umgebung?Leider gibt es ein kleines Problem: Öffnen Sie die Beispieldateien der fol-genden Kapitel in VS.NET, können Sie zwar den Programmcode einse-hen und im Editor bearbeiten. Allerdings verweigert die Entwicklungs-umgebung das Übersetzen der betreffenden Dateien (die entsprechendenBefehle stehen nicht zur Verfügung). Um nicht für jedes Beispiel zweiVarianten (eine für den SDK und eine für VS.NET) entwickeln zu müs-sen, andererseits aber Ihnen als Leser den größtmöglichen Komfort zubieten, habe ich nach einer anderen Lösung gesucht. Falls Sie die Bei-spieldateien, die nicht für Visual Studio .NET entwickelt wurden, in die-ser Umgebung übersetzen und testen möchten, gehen Sie in folgendenSchritten vor.

Bild 3.11: Neues leeres Projekt anlegen

1. Starten Sie Visual Studio .NET und legen Sie ein neues leeres Projektan. Hierzu wählen Sie im Menü DATEI die Befehle NEU/PROJEKT. ImDialogfeld NEUES PROJEKT markieren Sie den Typ VISUAL BASIC-PROJEKTE und die Vorlage LEERES PROJEKT. Passen Sie im Dialogfeldden Projektnamen und den Zielordner zum Speichern der Projektda-teien an und bestätigen Sie dies über die OK-Schaltfläche (Abbildung3.11). Achten Sie darauf, dass der Zielordner auf einem Laufwerkder Festplatte liegt (keine CD).



65

2. Anschließend wählen Sie im Menü PROJEKT des VS.NET-Fenstersden Befehl VORHANDENES ELEMENT HINZUFÜGEN. Im dann geöffne-ten Dialogfeld suchen Sie den Ordner mit der Beispieldatei, markie-ren die .vb-Datei und klicken auf die Schaltfläche ÖFFNEN.

3. Blenden Sie den Projektmappen-Explorer über die entsprechendeSchaltfläche der VS.NET-Symbolleiste ein und markieren Sie in derProjekthierarchie das Symbol der eingebundenen .vb-Datei. In Abbil-dung 3.12 ist dies der Eintrag Test.vb. Wenn Sie dann auf die imFenster des Projektmappen-Explorers gezeigte Schaltfläche CODEANZEIGEN (links oben) klicken, sollte der Beispielcode in einemCodefenster eingeblendet werden. Alternativ lässt sich das Codefens-ter auch öffnen, indem Sie die .vb-Datei im Projektmappen-Explorerper Doppelklick anwählen.

Bild 3.12: Fenster des Projektmappen-Explorers

4. Nun gilt es noch, die Einstellungen zum Übersetzen des Projektsanzupassen. Klicken Sie im Projektmappen-Explorer mit der rechtenMaustaste auf das Symbol der .vb-Projektdatei. In Abbildung 3.12ist dies der Eintrag LeerProject. Wählen Sie im Kontextmenü denBefehl EIGENSCHAFTEN. Dies öffnet das Dialogfeld <PROJEKTNAME>-EIGENSCHAFTENSEITEN, in dem Sie die Vorgaben zum Übersetzenanpassen müssen.

5. Wählen Sie im Dialogfeld die Kategorie ALLGEMEINE EIGENSCHAF-TEN/ALLGEMEIN und setzen Sie das Listenfeld AUSGABETYP auf dengewünschten Eintrag (Windows-Anwendung oder Konsolenanwen-dung). Im Listenfeld STARTOBJEKT sollte allgemein der Eintrag »SubMain« für die Hauptroutine auftauchen (Abbildung 3.13).

6. Wechseln Sie zur Kategorie ALLGEMEINE EIGENSCHAFTEN/ERSTELLENund setzen Sie die Optionen der Gruppe COMPILERSTANDARDEIN-STELLUNGEN gemäß Abbildung 3.14 (Option Strict ist standardmäßigauf »Off« gestellt, sollte aber »On« sein). Bei Windows-Anwendun-gen sollten Sie zudem das Symbol im Feld ANWENDUNGSSYMBOLfestlegen.



66

0

magnum

Bild 3.13: Allgemeine Projekteigenschaften

Bild 3.14: Projekteigenschaften zum Erstellen der Anwendung

7. Passen Sie ggf. die Einstellungen der restlichen Gruppen an (meistnicht erforderlich) und schließen Sie das Dialogfeld über die OK-Schaltfläche.

8. Wenn alles geklappt hat, sollte anschließend die VS.NET-Menüleisteden Eintrag ERSTELLEN aufweisen. Wählen Sie in diesem MenüERSTELLEN den Befehl <PROJEKTNAME> NEU ERSTELLEN. Dabei steht<PROJEKTNAME> hier für den von Ihnen beim Anlegen des neuen



67

Projekts gewählten Projektnamen (z.B. LeerProjekt). Visual Studio.NET beginnt mit dem Übersetzen der Anwendung. Die Meldungendes Compilers können Sie im Fenster AUSGABE verfolgen. Fehler imQuellcode werden zudem in einer Aufgabenliste sowie im Fenster desCode-Editors angezeigt (siehe auch Abbildung 3.43 am Kapitelende).

9. Wurde das Projekt erfolgreich übersetzt, lässt sich die Anwendungim Menü DEBUGGEN über die Befehle STARTEN OHNE DEBUGGENoder STARTEN ausführen.

Über diesen Ansatz können Sie die Beispiele komfortabel in VS.NET ein-binden, weiter entwickeln und debuggen. Eine detailliertere Einführungin Visual Studio .NET finden Sie am Kapitelende.

3.5 Debuggen von .NET-AnwendungenEin wichtiger Aspekt bei der Entwicklung von Anwendungen stellt dasDebuggen dar. Hierbei gilt es die Programmfunktionen auf die Überein-stimmung mit den Anforderungen zu überprüfen. .NET erlaubt dabeieine sehr komfortable Vorgehensweise, bei der Quellcode schrittweise imDebugger getestet werden kann.

� Der Debug-Vorgang wird automatisch eingeleitet, sobald die .NET-Laufzeitumgebung (CLR) auf einen Fehler stößt.

� Zudem lässt sich der Debugger durch eine im VB-Quellcode einge-fügte Stop-Anweisung aktivieren. Die Aktivierung erfolgt, sobald derCode mit dieser Anweisung ausgeführt wird.

� In Visual Studio kann die schrittweise Ausführung des Codes überdie Befehle des Menüs DEBUGGEN gestartet werden.

Das folgende Listing zeigt, wie Sie den Quellcode eines Visual Basic-Programms durch Einfügen einer Stop-Anweisung zum Debuggen vorbe-reiten können.

'************************************************' File: Test-Debug.vb ' Autor: G. Born www.borncity.de' Erzeugt ein einfaches Meldungsfeld unter Windows.'************************************************

Module Test Sub Main() Stop ' Debugger starten Microsoft.VisualBasic.MsgBox ("Es hat geklappt!") End SubEnd Module

Listing 3.6: Datei Test-Debug.vb, vorbereitet zum Debuggen


Debuggen von .NET-Anwendungen

68

0

magnum

Bild 3.15: Meldung vor Aufruf des Debuggers

Wenn Sie dieses Listing mit dem Visual Basic-Compiler übersetzen, fügtdieser einen Aufruf des Debuggers in der ausführbaren Datei ein. Umjedoch beim Ablauf im Debugger den zugehörigen Quellcode anzeigen zukönnen, muss die Anwendung mit der Option /debug übersetzt werden.Der Visual Basic-Compiler generiert dann eine pdb-Datei, die zusätzlicheInformationen (u.a. über die Lage der Quelldatei) enthält. Bei deranschließenden Ausführung der .NET-Anwendung hängt die Reaktionvon der verfügbaren Umgebung auf dem jeweiligen Rechner ab.

3.5.1 Debuggen im Laufzeit-Debugger (coredb.exe)

Ist auf dem Rechner nur die Laufzeitumgebung (.NET Framework) oderder .NET Framework SDK installiert, meldet sich das Programm miteinem Dialogfeld ähnlich Abbildung 3.15. Über die Schaltfläche WIE-DERHOLEN lässt sich die Anwendung im Laufzeit-Debugger (coredb.exe)aufrufen.

Sobald der Debugger sich meldet (Abbildung 3.16), können Sie an derEingabeaufforderung DEBUG-Befehle eintippen und mit der Taste(Enter) ausführen.

Die mit der Option /debug erzeugte .pdb-Symboldatei enthält absolutePfadangaben bei Verweisen auf Quelldateien. Wenn Sie die entspre-chend vorbereiteten .exe-Dateien aus den Debug-Verzeichnissen aus-führen, werden die nachfolgend beschriebenen Debugger eine fehlendeQuellcodedatei bemängeln. Das Gleiche gilt, falls Sie eine mit /debugerzeugte .exe-Datei mitsamt der .pdb-Symboldatei in einen anderenOrdner oder auf eine neue Zielmaschine kopieren. Beheben lässt sichdas Problem, indem Sie die Quelldatei in einen lokalen Ordner derZielmaschine kopieren und die Anwendung erneut mit der Option/debug übersetzen. Dann generiert der Compiler eine neue Symbol-datei, die die betreffenden Pfadangaben für die neue Umgebung ent-hält.



69

Bild 3.16: Ablauf im Common Language Runtime-Debugger (coredeb.exe)

� Der Befehl s veranlasst den Debugger einen Schritt weiter zu gehen.Dabei beziehen sich diese Schritte auf die MSIL-Anweisungen desübersetzten Programms. Steht die Quelldatei der Anwendung imVerzeichnis, aus dem die .exe-Datei aufgerufen wurde, zur Verfü-gung, gibt der Debugger auch die zugehörigen Anweisungen imQuellcode mit aus.

� Beim Befehl go führt der Debugger das Programm ohne Unterbre-chung aus.

� Mit dem Befehl exit lässt sich der Debugger beenden.

Die im Debugger verfügbaren Befehle können Sie durch Eingabe desBefehls help auflisten lassen.



70

0

magnum

3.5.2 Debuggen mit dem Microsoft CLR-Debugger

Falls der .NET Framework SDK oder Visual Studio .NET installiert ist,befindet sich ein zweiter Debugger mit einer grafischen Oberfläche aufdem System. Starten Sie eine .NET-Anwendung, die einen Stop-Befehlenthält oder bei der ein Laufzeitfehler auftritt, wird ggf. das in Abbil-dung 3.17 gezeigte Dialogfeld eingeblendet (falls VS.NET installiert oderder Debugger entsprechend eingerichtet ist). Sie müssen dann dengewünschten Debugger (entweder den Microsoft CLR-Debugger oderden Debugger von Visual Studio .NET) wählen und über die JA-Schalt-fläche bestätigen.

Ist kein Visual Studio .NET installiert, müssen Sie den Microsoft CLR-Debugger manuell starten und das Programm unter dessen Kontrolleausführen. Der Debugger findet sich im Ordner Programme\Micro-soft.NET\FrameworkSDK\GuiDebug. Gehen Sie in folgenden Schrittenvor.

1. Starten Sie die Datei DbgCLR.exe im Ordner Programme\Micro-soft.NET\FrameworkSDK\GuiDebug. Falls Sie häufiger debuggen,empfiehlt es sich, eine Verknüpfung auf dem Desktop anzulegen.

2. Warten Sie, bis der Microsoft CLR-Debugger gestartet ist. WählenSie in dessen Fenster das Menü DEBUGGEN und dann den Befehl ZUDEBUGGENDES PROGRAMM.

3. Der Debugger öffnet das Dialogfeld aus Abbildung 3.18. Wählen Siedort die zu testende .exe-Datei und tragen Sie ggf. die beim Pro-grammstart zu übergebenden Argumente ein. Schließen Sie das Dia-logfeld über die OK-Schaltfläche. Mit diesem Schritt wird das MenüDEBUGGEN um weitere Befehle ergänzt.

Die Verwendung des Debuggers coredb.exe setzt aber voraus, dass die-ser Debugger auf dem System installiert ist und korrekt eingerichtetwurde. Der Debugger wird nur mit dem .NET Framework SDK instal-liert und konfiguriert (das SDK ist auch Bestandteil von VS.NET).Installieren Sie dagegen das .NET Framework über die .NET Redistri-butable, fehlt der Debugger (was insbesondere unter Windows 9x einProblem bereitet). Sie können aber den .NET Framework SDK aufeiner NT-Maschine installieren und dann die Dateien coredb.exe,coredb.exe.config und msdis130.dll aus dem Verzeichnis Pro-gramme\Microsoft.NET\FrameworkSDK\Bin in das Verzeichnis mitder zu testenden Anwendung kopieren. Dann lässt sich der Debuggeraufrufen bzw. automatisch vom Programm bei der Ausführung aktivie-ren.



71

Bild 3.17: Auswahl des Just In Time-Debuggers

Bild 3.18: Auswahl des zu debuggenden Programms

4. Öffnen Sie das Menü DEBUGGEN und wählen Sie den Befehl STARTEN(Abbildung 3.19). Der Debugger führt den Code aus, bis die Stop-Anweisung gefunden wird. Dann terminiert der Ablauf und derDebugger erhält die Kontrolle zurück.



72

0

magnum

Bild 3.19: Fenster des Microsoft CLR-Debuggers mit Codeanzeige und Projekt-Explorer

Zur Kontrolle des Ablaufs stehen Ihnen über das Menü DEBUGGEN bzw.über die gleichnamige Symbolleiste die folgenden Funktionen zur Verfü-gung.

� Der Befehl WEITER bzw. die gleichnamige Schaltfläche und die Taste(F5) bewirken, dass das Programm direkt ohne Unterbrechung aus-geführt wird. Der Ablauf endet, sobald der Programmcode komplettabgearbeitet wurde. Zudem wird der Ablauf bei Laufzeitfehlern,beim Auftreten einer weiteren Stop-Anweisung oder beim Erreicheneines im Debugger gesetzten Haltepunkts unterbrochen.

Die Bedienung des Debuggers kann über die Befehle der Menüleisteerfolgen. Die wichtigsten Befehle zur Ablaufsteuerung finden Sie imMenü DEBUGGEN. In diesem Menü sind auch die Abkürzungstastenzum Abrufen der Funktionen angegeben. Zudem zeigt das Debugfens-ter noch die Symbolleiste DEBUGGEN mit den Schaltflächen zur Ablauf-steuerung. Über diese Schaltflächen können Sie das Programm ablau-fen lassen (Schaltfläche WEITER, EINZELSCHRITT etc.), den Ablaufbeenden (Schaltfläche DEBUGGEN BEENDEN), das Programm neu star-ten, die Hexadezimalanzeige von Werten abrufen oder ein Menü mitBefehlen zum Einblenden von Zusatzfenstern öffnen (Abbildung 3.22).Die Funktion der Schaltflächen in der Symbolleiste DEBUGGEN lassensich als QuickInfo abrufen, indem Sie mit der Maus auf die Schalt-flächen zeigen.



73

� Über den Befehl EINZELSCHRITT oder durch Anklicken der gleichna-migen Schaltfläche in der Symbolleiste DEBUGGEN oder durch Drü-cken der Funktionstaste (F11) wird die nächste Anweisung als Ein-zelschritt ausgeführt. Dies erlaubt es, das Programm Schritt fürSchritt zu debuggen.

� Verwenden Sie bereits ausgetestete Prozeduren, ist es im Einzel-schrittmodus recht umständlich, wenn jede Anweisung der Prozedurim Debugger angezeigt wird. Mit dem Befehl PROZEDURSCHRITTbzw. der gleichnamigen Schaltfläche oder durch Drücken der Funkti-onstaste (F10) wird die jeweils nächste Anweisung ausgeführt. Han-delt es sich um einen Prozeduraufruf, wird die aufgerufene Prozedurkomplett durchlaufen. Der Debugger stoppt den Ablauf erst, sobalddie Prozedur abgearbeitet ist und die nächste Anweisung im rufendenProgramm zur Abarbeitung ansteht. Bei anderen Anweisungen wirktder Befehl wie die Schaltfläche EINZELSCHRITT.

� Wurde der Ablauf des Programms in einer Prozedur unterbrochen,wählen Sie den Befehl AUSFÜHREN BIS RÜCKSPRUNG bzw. die gleich-namige Schaltfläche oder drücken Sie einfach die Funktionstasten(ª)+(F11). Dann wird die bereits teilweise abgearbeitete Prozedurkomplett durchlaufen. Der Debugger stoppt, sobald die Prozedurbeendet ist und zum rufenden Programm zurückgesprungen wird.

� Mit dem Befehl DEBUGGEN BEENDEN bzw. mit der gleichnamigenSchaltfläche oder durch Drücken der Funktionstasten (ª)+(F5)wird der Debugger gestoppt.

Die jeweils nächste im Debugger auszuführende Anweisung wird dabeiim Codefenster gelb hinterlegt (Abbildung 3.20).

Um die Ausführung des Programms in einer bestimmten Anweisungszeilezu unterbrechen, können Sie diese gezielt mit einem so genannten Halte-punkt versehen. Hierzu klicken Sie im Codefenster auf den grauen linkenRand (Kennzeichenleiste) vor der Zeile. Zudem finden Sie im MenüDEBUGGEN Befehle zum Setzen oder Löschen von Haltepunkten in deraktuellen Zeile. Eine mit einem Haltepunkt versehene Zeile wird braunhinterlegt und am linken Rand erscheint ein brauner Punkt (Abbildung3.20). Sie können mehrere Haltepunkte pro Modul bzw. Klasse setzen.Der Debugger unterbricht den Programmablauf, sobald ein Haltepunkterreicht wird. Zum Löschen von Haltepunkten verwenden Sie das MenüDEBUGGEN oder Sie klicken einfach auf den braunen Punkt in der Kenn-zeichenleiste.

Beachten Sie beim Testen, dass Haltepunkte in Ereignisprozeduren nurdann einen Abbruch bewirken, wenn das Ereignis auch auftritt (z.B.Anklicken einer Schaltfläche).



74

0

magnum

Bild 3.20: Codefenster mit Folgezeile und Haltepunkt

Bild 3.21: Debugversionen der Beispiele

Die Quelldatei FormDbg.vb wurde gegenüber dem obigen Formularbei-spiel etwas erweitert. Ich habe einmal eine Stop-Anweisung in den Pro-grammkopf eingebaut (Abbildung 3.22), um beim Programmstart auto-matisch den Debugger zu aktivieren. Zudem enthält der Quellcode einige

Die Begleit-CD enthält im Ordner \Beisp\Kap03\Debug entsprechendvorbereitete Quelldateien, die mit einer Stop-Anweisung versehen wur-den. Die auf der CD vorliegenden .exe-Dateien lassen sich jedoch nichtdirekt im Debugger ausführen, da die Verweise auf die Quelldateienmit hoher Wahrscheinlichkeit nicht mehr stimmen (der Debuggerbemängelt dann eine fehlende Quelldatei). Um die Anwendung imDebugger zu testen, kopieren Sie die Quelldatei Form1dbg.vb von derBegleit-CD in einen lokalen Ordner der Festplatte. Übersetzen Sie dasBeispiel anschließend erneut mit der Option /debug (z.B. vbcForm1dbg.vb /debug /r:system.dll /r:system.windows.forms.dll /r:sys-tem.drawing.dll /t:winexe /win32icon:xDbgForm.ico). Dann sollten imlokalen Ordner neben der Quelldatei auch eine .exe- und eine .pbd-Datei vorhanden sein (Abbildung 3.21). Starten Sie anschließend dieDatei Form1dbg.exe per Doppelklick. Ist Visual Studio .NET instal-liert, wird der Debugger automatisch bei der Ausführung aufgerufen(siehe Abbildung 3.17). Andernfalls gehen Sie wie auf den vorherge-henden Seiten beschrieben vor, um das Programm unter der Kontrolledes Microsoft CLR-Debuggers zu laden und zu testen.



75

Schleifen und Variablen. Beim Ablauf zeigt das Programm das Primitiv-formular viermal an und gibt in der Titelleiste einen fortlaufenden Wertaus. Zudem erscheint vor dem Beenden des Programms noch ein Dialog-feld mit einer entsprechenden Meldung. Einsteiger brauchen sich an die-ser Stelle noch keine Gedanken um die Funktion der einzelnen Anwei-sungen zu machen – dies lernen sie in den folgenden Kapiteln. Zweck istes, ein Übungsbeispiel zu haben, an dem sich die Funktionen des Debug-gers demonstrieren lassen.

Anzeige der Werte im laufenden ProgrammProgramme speichern intern Werte in so genannten Variablen. DieseWerte werden in der Regel beim Ablauf der Anwendung verändert. AlsEntwickler ist es daher hilfreich, wenn man während des Ablaufs denWert bestimmter Variablen kennt. Sie könnten diese Werte im VB-Pro-gramm über Dialogfelder anzeigen lassen. Einfacher ist es jedoch, dieWerte im Microsoft CLR-Debugger (oder im Debugger von Visual Stu-dio) abzurufen (nur bei unterbrochenem Programmablauf möglich). Fürden Test gehen Sie in folgenden Schritten vor.

Bild 3.22: Debugfenster mit Befehlen zur Anzeige verschiedener Fenster

1. Starten Sie das Programm Form1dbg.exe unter Kontrolle des Debug-gers. Dieser wird den Programmablauf an der Stop-Anweisungunterbrechen (Abbildung 3.22).

2. Setzen Sie gemäß Abbildung 3.23 zwei Haltepunkte in Zeile 25 und28 (einfach auf die Kennzeichenleiste vor der Zeile klicken), um dieProgrammausführung später an diesen Stellen zu unterbrechen. Zei-



76

0

magnum

gen Sie auf einen Haltepunkt, blendet der Debugger eine QuickInfomit der Zeilennummer und weiteren Informationen ein (Abbildung3.23).

3. Drücken Sie die Funktionstaste (F10), um die Programmanweisun-gen im Prozedurschritt-Modus auszuführen (die Schritte zum Erzeu-gen des Formulars in der Dim-Anweisung möchte ich übergehen).Wiederholen Sie diesen Schritt, bis die Anweisungszeile 20 Titel = ...erreicht ist. Die Statusleiste des Debuggers zeigt übrigens die Zeilen-nummer der gerade ausgeführten oder angeklickten Anweisung als»Z xx« an (siehe Abbildung 3.22, unten rechts).

Bild 3.23: Anzeige von Variablenwerten im Codefenster

4. Drücken Sie die Funktionstaste (F11), um die Programmanweisun-gen im Einzelschritt-Modus auszuführen. Wiederholen Sie das Drü-cken der Funktionstaste (F11), bis die Anweisungszeile 22 For i = ...erreicht ist. Zeigen Sie auf die Variable i und dann auf die VariableTitel. Bei jedem Zeigen auf eine Variable wird deren Name samtWert in einem QuickInfo-Fenster im Debugger eingeblendet (siehez.B. Abbildung 3.23). Wurde die Anweisung noch nicht ausgeführt,ist die betreffende Variable noch mit einem Initialisierungswert (z.B.»Nothing« oder »»«« oder »0« etc.) belegt. Die Anzeige numerischerWerte kann wahlweise in Dezimal- oder Hexadezimalschreibweiseerfolgen. Zum Umschalten der Anzeige klicken Sie auf die Schaltflä-che HEXADEZIMALE ANZEIGE der DEBUGGEN-Symbolleiste (Abbil-dung 3.23, oberer Rand).

5. Drücken Sie die Funktionstaste (F5), um die Funktion WEITER aus-zuführen. Jetzt führt der Debugger die Programmanweisung ohneweitere Unterbrechung aus, bis der erste Haltpunkt in Zeile 25erreicht ist. Zeigen Sie dann auf die Variable j, wird diese den Wert5001 aufweisen. Die Schleife wurde 5.000-mal durchlaufen.



77

6. Rufen Sie die Funktion WEITER erneut durch Drücken der Funk-tionstaste (F5) (oder über das Menü DEBUGGEN bzw. über dieSchaltfläche der Symbolleiste auf). Der Debugger führt die ShowDia-log-Anweisung aus und zeigt das Formular an. Solange das Formularals Dialogfeld sichtbar ist, wartet das Programm, d.h. Sie könnenauch keine Variablenwerte abrufen. Zu diesem Zeitpunkt lässt sichlediglich die Schaltfläche DEBUGGER ABBRECHEN in der Symbolleistedes Debugger-Fensters anwählen, um den Debugger vom Programmzu trennen.

7. Schließen Sie das Dialogfeld des Formulars, um das Programm fort-zusetzen. Der Debugger führt die Programmanweisung ohne weitereUnterbrechung bis zum nächsten Haltepunkt in Zeile 25 aus. Wie-derholen Sie den vorhergehenden Schritt so oft, bis das Formulardreimal angezeigt wurde. Immer wenn ein Haltepunkt erreichtwurde, können Sie sich die Inhalte der Variablen anzeigen lassen.Klicken Sie auf die Markierung des Haltepunkts in der Kennzeichen-leiste, lässt sich dieser auch wieder löschen.

8. Lassen Sie das Programm mit der Funktion WEITER bis zur Zeile 28laufen, schließen Sie die angezeigten Dialoge und führen Sie dann dasProgramm mit WEITER bis zum Ende durch.

Wird ein Programm im Ablauf vom Debugger unterbrochen, lassen sichdie Werte einer Variablen (oder einer Eigenschaft) durch Zeigen mit derMaus auf den betreffenden Namen direkt als QuickInfo abrufen. Halte-punkte erlauben Ihnen, den Programmablauf an vordefinierten Anwei-sungszeilen zu unterbrechen. An dieser Stelle möchte ich Ihnen noch denUnterschied der beiden Funktionstasten (F10) des Prozedurschritt-Modus und (F11) des Einzelschritt-Modus zeigen.

1. Nachdem Sie die letzte Debugsitzung beendet haben, starten Sie denProgrammablauf im Debugger erneut (z.B. über die SchaltflächeSTARTEN).

2. Drücken Sie jetzt einmal die Funktionstaste (F11), um den Einzel-schritt-Modus einzuleiten. Beim ersten Betätigen der Funktionstastewir die Anweisung Dim oF ... gelb hervorgehoben. Diese Anweisungsorgt dafür, dass eine Instanz des Formulars erzeugt wird.

3. Drücken Sie erneut die Funktionstaste (F11). Der Debugger führtjetzt einen Aufruf des so genannten New-Konstruktors aus (dortwird das Formular quasi zusammengebaut). Bei der vorherigen Sit-zung hatten wir den Prozedurschritt-Modus über die Funktionstaste(F10) benutzt, die den kompletten Prozeduraufruf in einem Schrittabarbeitet. Mit dem Einzelschritt-Modus gelangen Sie in die betref-fende Prozedur des New-Konstruktors und sehen die dort hinterleg-ten Anweisungen (Abbildung 3.24).

4. Durch weiteres Drücken der Funktionstaste (F11) können Sie dieAnweisungen dieser Prozedur studieren. Um alle Anweisungen derProzedur bis zum Ende in einem Rutsch auszuführen, wählen Sie dieFunktion AUSFÜHREN BIS RÜCKSPRUNG (Schaltfläche oder Menü-befehl).



78

0

magnum

Bild 3.24: Anzeige des Codes in der Prozedur New()

Dann gelangen Sie zurück zu Zeile 16 der Hauptprozedur und könnendas Programm weiter ausführen.

Bedingungen für Haltepunkte vereinbarenDie Debugger von Microsoft sind in der Lage, Unterbrechungsbedingun-gen für Haltepunkte zu vereinbaren. Wird der Haltepunkt erreicht, prüftder Debugger, ob die Bedingung erfüllt ist. Nur dann wird der Ablaufunterbrochen. Dies möchte ich jetzt am Beispiel des ersten Haltepunktsdemonstrieren. Dieser soll nur dann wirksam werden, wenn der Schlei-fenindex i größer 2 ist. In Abbildung 3.25 sehen Sie die Dialoge zum Set-zen eines solchen bedingten Haltepunkts (es handelt sich hier um eineMontage mehrerer Schritte).

Wurde eine Anweisung im Debugger bereits ausgeführt und möchtenSie den Programmablauf an einer bestimmten Zeile erneut aufsetzen?Dann klicken Sie im Codefenster des Debuggers mit der rechten Maus-taste auf die gewünschte Anweisungszeile. Wählen Sie im Kontextmenüden Befehl NÄCHSTE ANWEISUNG FESTLEGEN. Soll der Programm-ablauf bis zu einer bestimmten Anweisung ausgeführt werden? KlickenSie im Codefenster des Debuggers mit der rechten Maustaste auf diegewünschte Anweisungszeile und wählen Sie im Kontextmenü denBefehl AUSFÜHREN BIS CURSOR. Der Debugger führt dann alle Anwei-sungen bis zur Cursorposition aus, sofern dazwischen keine Halte-punkte liegen.



79

Bild 3.25: Bedingungen für einen Haltepunkt setzen

1. Setzen Sie den gewünschten Haltepunkt (z.B. durch Anklicken derKennzeichenleiste am linken Rand der Anweisungszeile).

2. Öffnen Sie das Menü mit den Optionen zum Einblenden der Zusatz-fenster (über die Schaltfläche der DEBUGGEN-Symbolleiste, sieheAbbildung 3.25, oder über das Menü DEBUGGEN/FENSTER) und wäh-len Sie den Befehl HALTEPUNKTE.

3. Der Debugger zeigt jetzt ein Fenster HALTEPUNKTE mit einer Listeder definierten Haltepunkte. Markieren Sie in diesem Fenster dengewünschten Haltepunkt und klicken Sie im Fenster auf die Schalt-fläche EIGENSCHAFTEN (siehe Abbildung 3.25).

4. Dann erscheint das Dialogfeld HALTEPUNKTEIGENSCHAFTEN, in demSie verschiedene Registerkarten wählen können (Abbildung 3.25,Vordergrund, unten rechts). Wählen Sie die Registerkarte DATEI.Dort werden die benutzte Quelldatei sowie die Zeilennummer derAnweisung mit dem Haltepunkt angezeigt.

5. Klicken Sie auf die Schaltfläche BEDINGUNG, um das DialogfeldBEDINGUNG FÜR HALTEPUNKT zu öffnen (Abbildung 3.25, Vorder-grund, unten links).

6. Setzen Sie die gewünschte Unterbrechungsbedingung im Dialogfeldund schließen Sie die Dialogfelder und Registerkarten über die OK-Schaltfläche.



80

0

magnum

Anschließend können Sie die Ausführung des Programms im Debuggermit der Funktion WEITER starten. Im Fenster HALTEPUNKTE zeigt derDebugger Ihnen an, wie oft die Bedingung bereits eingetreten ist. Wirddas Abbruchkriterium erreicht, stoppt der Debugger den Programmab-lauf und Sie können den Inhalt von Variablen ansehen oder die Ausfüh-rung in anderen Modi fortsetzen.

Werte für Variablen setzen und überwachenUm den Wert einer Variablen gezielt zu setzen, öffnen Sie das Direktfens-ter (über die Schaltfläche mit dem Menü der Zusatzfenster in der Sym-bolleiste DEBUGGEN den Befehl DIREKT anklicken oder die Tastenkombi-nation (Strg)+(Alt)+(I) drücken, siehe Abbildung 3.22, oder über dasMenü DEBUGGEN/FENSTER vorgehen). Dann geben Sie die Anweisungmit der Wertzuweisung an die Variable ein (Abbildung 3.26).

Bild 3.26: Befehlsfenster (Direktfenster)

Zur Anzeige eines Werts im Befehlsfenster geben Sie ein Fragezeichenein, gefolgt vom Namen der Variablen. Der Wert wird dann in einerzweiten Zeile angezeigt.

Beim umfangreicheren Programmen ist es hilfreich, wenn Sie die Wertebestimmter Ausdrücke oder Variablen übersichtlich in einem Fensterzusammenstellen und dann überwachen können. Auch dies lässt sich mitdem Debugger sehr leicht bewerkstelligen.

1. Um eine Variable zu überwachen, wählen Sie im Menü DEBUGGENden Befehl SCHNELLÜBERWACHUNG (Abbildung 3.27).

2. Geben Sie im Dialogfeld SCHNELLÜBERWACHUNG den Ausdruck oderden Variablennamen im Feld AUSDRUCK ein (Abbildung 3.27).

3. Klicken Sie auf die Schaltfläche ÜBERWACHUNG HINZUFÜGEN, wirdder Ausdruck im Überwachungsfenster eingetragen. Die SchaltflächeNEU BERECHNEN zeigt den aktuellen Wert des Ausdrucks im Dialog-feld an (Abbildung 3.27). Sie können diesen Wert im Dialogfeldmanuell anpassen. Schließen Sie danach das Dialogfeld.

4. Öffnen Sie über das Menü DEBUGGEN/FENSTER (bzw. über dieSchaltfläche der Symbolleiste DEBUGGEN) das Menü mit den Namender Zusatzfenster. Wählen Sie den Befehl ÜBERWACHEN und imUntermenü das gewünschte Überwachungsfenster. Dieses wird dannim Debugger als Teilfenster mit den definierten Ausdrücken ange-zeigt (Abbildung 3.27, unten).



81

Bild 3.27: Schnellüberwachung definieren

Beim Ablauf des Programms im Debugger zeigt dieser die Werte derüberwachten Variablen im Überwachungsfenster an. Dieses Fenster gibtdabei auch den Typ der Variablen an. Geänderte Werte werden mit roterSchrift hervorgehoben. Über die Schaltfläche zur Anzeige des Menüs mitden Zusatzfenstern (oder über das Menü DEBUGGEN/FENSTER) könnenSie bis zu vier Überwachungsfenster definieren.

Die einzelnen Fenster lassen sich über die Titelleiste per Maus verschie-ben und am linken, rechten oder unteren Rand des Debuggerfenstersverankern. Dies ist zwar gelegentlich etwas diffizil, da der Debuggerdie Größe automatisch anpasst (Sie erkennen dies an einem grauenRahmen beim Ziehen). Doppelklicken Sie auf die blau hervorgehobeneTitelleiste eines verankerten Zusatzfensters, wird dieses frei schwebendeingeblendet. Ein zweiter Doppelklick auf die Titelleiste verankert dasFenster erneut an der alten Position. Sie können mehrere Fenster aneiner Position andocken. Dann werden diese als Registerkartengeführt, d.h. über die Registerreiter am unteren Rand lässt sich derInhalt des gewünschten Fensters in den Vordergrund holen. MeinTipp: Ziehen Sie die Titelleiste eines schwebenden Fensters auf dieRegisterreiter einer Gruppe. Beim Loslassen fügt der Debugger dasFenster in die Gruppe ein und blendet einen Registerreiter mit demFenstertitel ein. Dies funktioniert übrigens auch bei VS.NET.



82

0

magnum

Sie können markierte Ausdrücke vom Codefenster auch direkt in dasÜberwachungsfenster ziehen, um ihre Werte anzuzeigen. Es muss sichaber um vollständige Ausdrücke handeln. Ein überwachter Ausdrucklässt sich direkt ändern, indem Sie die Zelle in der Spalte Name im Über-wachungsfenster anklicken und den Eintrag korrigieren. Auf die gleicheWeise lässt sich der Wert einer Variablen im Überwachungsfensteranpassen. Um den Ausdruck zu entfernen, klicken Sie diesen mit derrechten Maustaste im Überwachungsfenster an und wählen im Kontext-menü den Befehl ÜBERWACHUNG LÖSCHEN.

Aufrufliste ansehenEnthält ein Programm Funktionen oder Prozeduren, lassen sich diese imProgrammcode aufrufen. Der Debugger führt intern eine Liste der aufge-rufenen Prozeduren, die Sie sich ansehen können (Abbildung 3.28).

Bild 3.28: Fenster mit der Aufrufliste

Sie müssen nur das Fenster AUFRUFLISTE über den gleichnamigen Menü-befehl wählen. Das Menü öffnen Sie z.B. über die Schaltfläche zum Ein-blenden der Zusatzfenster (siehe Abbildung 3.22, Symbolleiste DEBUG-GEN) oder über das Menü DEBUGGEN/FENSTER. In dieser Liste spiegeltsich die Projekthierarchie: Jeder Eintrag besteht aus dem Namen der Pro-grammdatei, gefolgt vom Namen der Komponente und der aufgerufenenProzedur.

Der Microsoft CLR-Debugger enthält weitere Funktionen zum Öffnender Quelldatei (Menü ANSICHT), zum Verwalten der Prozesse (MenüEXTRAS bzw. DEBUGGEN) und zur Verwaltung von Ausnahen (MenüDEBUGGEN), deren Behandlung den Umfang dieses Buches sprengenwürde. Dies gilt auch für Befehle zur Ausgabe von Meldungen mittels derKlasse Debug im Namensraum System.Diagnostics. Details zu diesenFragen finden Sie in der .NET Framework SDK-Hilfe.

3.5.3 Debuggen mit Visual Studio .NETDas Testen von Anwendungen ist unter Visual Studio .NET sehr einfach.Wird die ausführbare .exe-Datei unter Windows gestartet und ist VisualStudio installiert, erscheint das Dialogfeld aus Abbildung 3.17 zur Aus-wahl des Debuggers. Wählen Sie dann den Eintrag »Neue Instanz vonMicrosoft Development Environment«, um den Debug-Modus in VisualStudio .NET zu starten. Der Quellcode wird dabei automatisch geladenund Sie finden die bereits im vorhergehenden Abschnitt beschriebeneUmgebung des Debuggers vor.



83

Entwickeln Sie Visual Basic-Programme in Visual Studio, lässt sich derDebugger direkt aus dem Fenster der Entwicklungsumgebung starten.Öffnen Sie das Menü DEBUGGEN (Abbildung 3.29) und wählen Sie einender verfügbaren Befehle (z.B. STARTEN, EINZELSCHRITT etc.). Sobald derDebugger aktiv ist, blendet Visual Studio .NET die DEBUGGEN-Symbol-leiste im Fenster ein. Dann können Sie, wie auf den vorhergehenden Sei-ten beschrieben, das Programm testen.

Bild 3.29: Aufruf der Debug-Funktionen in Visual Studio .NET

3.6 Visual Studio .NET-KurzeinführungVisual Studio .NET ist die von Microsoft angebotene Entwicklungsum-gebung, unter der sich .NET-Anwendungen auf Windows-Plattformenentwickeln und testen lassen. Bei der Installation des Produkts könnenSie wählen, welche Sprachversionen unterstützt werden (siehe auch vor-hergehende Kapitel). Weiter oben können Sie nachlesen, wie sich die Bei-spiele dieses Buches von der Begleit-CD in Visual Studio .NET-Projekteeinbinden und ggf. debuggen lassen. Der folgende Abschnitt stellt dieEntwicklungsumgebung vor.

Visual Studio .NET enthält eine umfangreiche Hilfe mit mehreren Ein-trägen zum Thema Debuggen, die auf viele Aspekte eingehen. RufenSie bei Bedarf diese Hilfe über das gleichnamige Menü des VS.NET-Fensters ab.


Visual Studio .NET-Kurzeinführung

84

0

magnum

3.6.1 Visual Studio .NET im ÜberblickVS.NET lässt sich nach der Installation im Startmenü über den ZweigPROGRAMME (bzw. ALLE PROGRAMME) in der Gruppe MICROSOFTVISUAL STUDIO .NET aufrufen. Das Programm meldet sich nach demStart mit dem in Abbildung 3.30 gezeigten Fenster.

Bild 3.30: Visual Studio .NET-Fenster

Dieses Fenster umfasst Menü- und Symbolleisten und ist seinerseits inunterschiedliche Teilfenster unterteilt. Beim Start wird in der Mitte eineWebseite mit der Bezeichnung Start eingeblendet. Über diese Seite kön-nen Sie bereits bearbeitete Projekte als Hyperlinks abrufen, Beispielesuchen oder über die Hyperlinks am linken Rand in Internetseiten zumThema recherchieren. Alle Teilfenster lassen sich über die rechts in derTitelleiste des Fensters positionierte Schaltfläche SCHLIESSEN (das Kreuz)ausblenden (Abbildung 3.31).

Bild 3.31: Schaltflächen im Kopf eines Fensters

� Die Schaltfläche AUTOMATISCH IM HINTERGRUND mit dem Symboleines stilisierten Pins (in der Titelleiste neben der SchaltflächeSCHLIESSEN) erlaubt ein Fenster an der betreffenden Position zu fixie-ren oder zum automatischen Ausblenden freizugeben. In der inAbbildung 3.31 gezeigten Stellung der Nadelspitze wird das Teilfens-ter automatisch am Fensterrand minimiert, sobald sich der Mauszei-ger über einem anderen Fenster befindet. Ein Klick auf die Schaltflä-che fixiert das Fenster und bewirkt, dass es sichtbar bleibt.

� Doppelklicken Sie auf die Titelleiste eines am Rand angedocktenTeilfensters, wird dieses schwebend angeordnet. Ein zweiter Dop-pelklick auf das schwebende Fenster verankert dieses erneut an deralten Position.

Toolbox

Startseite

Projektmappen-

Eigenschaften-

Befehlsfenster

Toolbox

fenster

Schließen

ausgeblendetesTeilfenster

Explorer

Automatisch imHintergrund

Registerreiter zur Fensterauswahl

Kategorie



85

� Ziehen Sie ein schwebendes Fenster über die Titelleiste zum Rand desHauptfensters, zeigt eine schraffierte Linie die Verankerungsposi-tion. Lassen Sie die Maustaste los, wird das Fenster an der betreffen-den Position am Fensterrand des Hauptfensters verankert.

� Ziehen Sie das Fenster auf die Leiste mit den Registerreitern am unte-ren Rand einer Fenstergruppe, ordnet VS.NET dieses in der Gruppeein.

Teilfenster einer Gruppe lassen sich über die Registerreiter am unterenFensterrand in den Vordergrund holen (Abbildung 3.30).

3.6.2 Wie Visual Basic .NET Anwendungen verwaltet

Visual Studio .NET verwaltet die Dateien einer Anwendung als sogenannte Projekte in Projektmappen. Eine Projektmappe wird dabei aufOrdnern des Dateisystems abgebildet. Die zum Projekt gehörendenDateien (Quellcode, .exe-Datei, Hilfsdateien) werden dabei im Projekt-ordner sowie in Unterordnern hinterlegt. In einem Projektordner findenSie daher Dateien (Dateinamenerweiterung .sln), die Visual Studio .NETzur Verwaltung des Projekts benötigt. In diesen Dateien sind die Projekt-einstellungen hinterlegt (u.a. welche Dateien im Projekt enthalten sind,welche Bibliotheken benötigt werden etc.).

Bild 3.32: Fenster des Projektmappen-Explorers

Die Dateien mit dem Visual Basic-Programmcode werden dabei mit derDateinamenerweiterung .vb hinterlegt. Dateien mit der Erweiterung.resx dienen zur Aufnahme so genannter Ressourcen (Bilder, Texte,Menüs), die im Programm benutzt werden. Beim Übersetzen werden



86

0

magnum

diese Ressourcen mit in die Assembly eingebunden. Die zu einem Projektgehörenden Elemente lassen sich im Fenster des Projektmappen-Explo-rers anzeigen (Abbildung 3.32). Dort erkennen Sie auch, dass ein Projekthierarchisch organisiert ist. Die Projektmappe enthält ein VS-Projekt,welches aus Verweisen, Modulen, Formularen, Referenzen etc. bestehenkann. Visual Studio .NET sorgt automatisch dafür, dass alle zum Projektgehörenden Dateien geladen bzw. gespeichert und übersetzt werden.

3.6.3 Ein Projekt in Visual Basic .NET anlegenUm in Visual Studio .NET arbeiten zu können, müssen Sie entweder einbereits vorhandenes Projekt laden (Menü DATEI/ÖFFNEN) oder ein neuesProjekt anlegen und mit der Entwicklung der Anwendung beginnen. Umden Start mit neuen Projekten zu vereinfachen, bietet Visual Studio .NETentsprechende Vorlagen an, die einerseits die benötigten Grunddateienenthalten und andererseits die zum Übersetzen der Anwendung erforder-lichen Einstellungen vorgeben. Um ein neues Projekt anzulegen, gehenSie in folgenden Schritten vor.

1. Starten Sie Visual Studio .NET und wählen Sie im Menü DATEI dieBefehle NEU/PROJEKT. Alternativ können Sie ein Menü über dieSchaltfläche NEUES PROJEKT der Symbolleiste öffnen und dort denBefehl NEUES PROJEKT wählen (siehe Abbildung 3.30).

2. Visual Studio .NET öffnet das Dialogfeld NEUES PROJEKT, in dem Sieeine Projektvorlage wählen, den Projektnamen sowie den Zielordnerzum Speichern anpassen und dann die OK-Schaltfläche anklicken(Abbildung 3.33).

Bild 3.33: Dialogfeld zur Auswahl der Projektoptionen

Beim Schließen des Dialogfelds erzeugt Visual Studio .NET aus dem ein-gestellten Projektnamen einen Projektordner im angegebenen Speicher-ort. Zusätzlich legt Visual Studio in der Standardeinstellung noch zweiUnterordner für die ausführbare Programmdatei (Ordner bin) sowie dieDebug-Informationen (Ordner obj) an. Anschließend erstellt VS.NET die



87

benötigten Projektdateien aus der gewählten Vorlage und nimmt die fürdas Projekt gültigen Einstellungen vor. Haben Sie als Vorlage eine Win-dows-Anwendung gewählt, erscheint automatisch ein Formular im Fens-ter des Designers (Abbildung 3.34). Gleichzeitig wird eine Werk-zeugleiste (Toolbox) zum Bearbeiten des Formulars am linken Randeingeblendet.

Bild 3.34: Neues Projekt einer Windows-Anwendung in VS.NET

Hinweise zu den ProjektkategorienDie Vorlagen für neue Projekte werden nach Projekttypen kategorisiert.Je nach Installationsumfang finden Sie im Dialogfeld NEUES PROJEKTdaher Zweige für Projekte verschiedener Sprachen etc. (Abbildung 3.33).Bei der Entwicklung in Visual Basic ist der Projekttyp Visual Basic-Projekte relevant. Sobald Sie diesen Zweig anwählen, zeigt das Dialog-feld die für diesen Projekttyp verfügbaren Vorlagen. Sie können dort dieVorlage für eine Konsolenanwendung (läuft im Fenster der Eingabeauf-forderung ab), für eine Windows-Anwendung (erzeugt Code für eineWindows-Anwendung, die in Fenstern läuft), ein leeres Projekt (ohneweitere Module) oder spezielle Vorlagen für Klassenbibliotheken (dieseerlauben wiederverwendbare Softwarebausteine zu erstellen), Windows-Steuerelemente (lassen sich in Formulare einbinden oder von Windows-Anwendungen als Objekte nutzen), ASP.NET-Webanwendungen bzw.-Webdienste (für Active Server Pages-Seiten), Windows-Dienste (Win-dows-Anwendungen, die im Hintergrund ohne Benutzerinteraktion lau-fen), Webanwendungen (für Webseiten) etc. wählen.



88

0

magnum

Die Einstellungen des Projekts anpassenUm ein Projekt zu übersetzen, verwendet Visual Studio .NET projektspe-zifische Einstellungen. In diesen Einstellungen ist beispielsweise hinter-legt, ob eine Konsolenanwendung oder ein Windows-Programm zu kom-pilieren ist. Bei Windows-Anwendungen lässt sich das der .exe-Dateizuzuweisende Symbol vorgeben. Zudem können Sie angeben, ob Debug-Informationen beim Übersetzen generiert werden sollen.

Wenn Sie eine Projektvorlage für das neue Projekt übernehmen, besitztdiese bereits die für den Projekttyp passenden Einstellungen. Sie müssenim ersten Schritt also nichts ändern. Allerdings verwendet VS.NET einigeVoreinstellungen, die nicht optimal sind. Zudem werden Windows-Anwendungen keine Symbole zugewiesen. Um die Projekteinstellungenanzupassen, gehen Sie in folgenden Schritten vor.

1. Wechseln Sie zum Fenster des Projektmappen-Explorers. Das Fensterlässt sich ggf. über die gleichnamige Schaltfläche in der Symbolleistedes VS.NET-Fensters einblenden. Im Projektmappen-Explorer sinddie im Projekt vorhandenen Module aufgeführt.

2. Klicken Sie mit der rechten Maustaste auf das Symbol der VB-Pro-jektdatei. In Abbildung 3.34 ist dies der Eintrag WindowsAnwen-dung. Wählen Sie im Kontextmenü den Befehl EIGENSCHAFTEN.

3. Dies öffnet das Dialogfeld <PROJEKTNAME>-EIGENSCHAFTENSEITEN,in dem Sie die Vorgaben für das Projekt anpassen. Anschließend kli-cken Sie auf die OK-Schaltfläche, um das Dialogfeld zu schließen.

Der Ausgabetyp (Windows-Anwendung oder Konsolenanwendung) lässtsich über die Kategorie ALLGEMEINE EIGENSCHAFTEN/ALLGEMEIN imListenfeld AUSGABETYP setzen. Die Gruppe COMPILERSTANDARDEINSTEL-LUNGEN der Kategorie ALLGEMEINE EIGENSCHAFTEN/ERSTELLEN erlaubt,die Vorgabe der Prüfungen auf nicht deklarierte Variable oder impliziteTypumwandlungen anzupassen (siehe Abbildung 3.14 weiter oben imAbschnitt zum Anpassen eines Beispiels an VS.NET). Setzen Sie dieOption Option Strict auf »On«. Dies verhindert Programmfehler, diesich durch implizite Typkonvertierungen einschleichen können. In denBeispielprogrammen der folgenden Kapitel wird ebenfalls die OptionOption Strict im Programmkopf vereinbart, um diese Einstellung zu nut-zen. Bei Windows-Anwendungen sollten Sie zudem das Symbol im FeldANWENDUNGSSYMBOL festlegen. Passen Sie bei Bedarf die Einstellungender restlichen Gruppen an. Das Verzeichnis für die Binärdateien lässtsich im Zweig KONFIGURATIONSEIGENSCHAFTEN/ERSTELLEN setzen. Dortfinden Sie auch ein Kontrollkästchen, über welches sich die Ausgabe derDebuginformationen abschalten lässt. In dieser Kategorie lassen sichauch Konstante für die bedingte Kompilierung eintragen. Die Behand-lung dieser Optionen würde aber den Umfang dieses Buches sprengen.Details zu den Einstellungen des Dialogfelds liefert die Visual Studio.NET-Hilfe, die Sie durch Anklicken der Schaltfläche HILFE im Dialog-feld abrufen können. Beachten Sie, dass die Hilfe-Informationen im



89

Visual Studio .NET-Fenster erscheinen. Dieses wird aber durch das imVordergrund befindliche Dialogfeld verdeckt. Sie müssen daher das Dia-logfeld beiseite schieben.

3.6.4 Projektkomponenten hinzufügenDas Visual Studio .NET-Projekt besteht aus verschiedenen Komponen-ten. Beim Anlegen eines Projekts aus einer Vorlage generiert VS.NETautomatisch die benötigten Projektkomponenten. In der Regel müssenSie aber zusätzliche Komponenten wie Steuerelemente, Klassen, Formu-lare etc. hinzufügen.

Bild 3.35: Neues Projektelement bei VS.NET hinzufügen

1. Öffnen Sie das Menü PROJEKT und wählen Sie einen der eingeblende-ten Befehle, um Formulare, Benutzersteuerelemente, Komponenten,Klassen, Verweise oder geerbte Komponenten einzubinden (Abbil-dung 3.35).

2. Wählen Sie dann im angezeigten Dialogfeld die Art der einzufügen-den Komponente aus. Die Dialogfelder hängen von der jeweiligenAuswahl ab. Meist wird eine Vorlage für die betreffende Kompo-nente angeboten.

Sobald das betreffende Element im Projekt eingefügt wurde, erscheintdieses als Eintrag im Projektmappen-Explorer. Durch Anklicken derKategorie werden deren Elemente in der Struktur ein- oder ausgeblendet.Ein Doppelklick auf ein Element öffnet dessen Ansicht im VS.NET-Fens-ter. Auf den vorhergehenden Seiten haben Sie ein Beispiel zum Einbindeneiner bestehenden Komponente in ein Projekt (Einfügen einer Beispiel-datei in ein leeres Projekt) kennen gelernt.



90

0

magnum

Elemente entfernen und Code übertragenÜber das Kontextmenü der Einträge im Projektmappen-Explorer könnenSie jederzeit einen Eintrag löschen. Klicken Sie den Eintrag mit der rech-ten Maustaste an und wählen Sie den Befehl LÖSCHEN im Kontextmenü.

Dateien mit existierendem Code lassen sich direkt über den Befehl VOR-HANDENES ELEMENT HINZUFÜGEN im Menü PROJEKT einbinden. Weiter-hin können Sie Code aus anderen Projekten markieren und über dieWindows-Zwischenablage in das Codefenster des aktuell gewählten Ele-ments einfügen.

Zum Sichern eines Projektelements (Form, Modul, Klasse etc.) klickenSie dieses im Projektmappen-Explorer an. Dann wählen Sie im MenüDATEI den Befehl SPEICHERN VON <NAME> UNTER, wobei <Name> fürden Namen des Elements steht. Dieser Name ist mit dem Dateinamenidentisch, der im Projekt zur Speicherung der Komponente verwendetwird. Sie können den Dateinamen über die Eigenschaften des Elementsanpassen sowie beim Speichern im Dialogfeld einen neuen Namen wäh-len. Die Dateinamenserweiterung wird abhängig vom gewählten Elementvergeben.

3.6.5 Die wichtigsten Fenster in VS.NETVS.NET besitzt vier Schaltflächen in der Symbolleiste, mit denen sichverschiedene Fenster ein- und ausblenden lassen (Abbildung 3.36).

Bild 3.36: Schaltflächen zum Einblenden von Fenstern

Die Schaltflächen sind mit PROJEKTMAPPEN-EXPLORER, EIGENSCHAFTEN-FENSTER, TOOLBOX und BEFEHLSFENSTER etc. benannt (je nachdem, waszuletzt ausgewählt wurde). Klicken Sie auf die Schaltfläche TOOLBOX,wird die in Abbildung 3.35 am linken Rand gezeigte Toolbox eingeblen-det. Diese Toolbox enthält Schaltflächen, mit denen sich Steuerelementefür Formulare abrufen oder weitere Komponenten in ein Projekt aufneh-men lassen. Die restlichen Schaltflächen blenden die zugehörigen Fensterim Vordergrund ein.

Module sind ein Relikt aus früheren Visual Basic-Versionen und neh-men den ausführbaren Programmcode (Prozedur Main) auf. Standard-mäßig verwendet VS.NET Klassen, um die Prozeduren der Anwen-dung, Formulare und weitere Softwarebausteine abzulegen. In Teil 2dieses Buchs finden Sie eine Einführung in diese Thematik.



91

Der Projektmappen-ExplorerDas Fenster des Projektmappen-Explorers (siehe Abbildung 3.32) dientzur Verwaltung der Projektkomponenten. Sie können die Zweige der ein-zelnen Kategorien ähnlich wie die Ordneranzeige im Windows-Explorererweitern oder zum Symbol reduzieren. Hierzu müssen Sie lediglich aufdas Plus- oder Minuszeichen vor dem jeweiligen Eintrag klicken. DieSchaltflächen unterhalb der Titelleiste ermöglichen Ihnen, die Eigen-schaften abzurufen oder bei Formularen das Codefenster zu öffnen. Umden Projektnamen, die Bezeichnung der Projektmappe oder eines Ele-ments zu ändern, klicken Sie dieses mit der rechten Maustaste an undwählen im Kontextmenü UMBENENNEN. Anschließend können Sie einenneuen Namen vergeben. Alternativ können Sie die Namen im Eigen-schaftenfenster der betreffenden Komponente anwählen. Ein Doppel-klick auf das Projektsymbol einer Komponente öffnet deren Fenster inVS.NET.

Das EigenschaftenfensterVisual Studio .NET verwaltet fast jedes Element als ein Objekt, welchesEigenschaften aufweisen kann.

1. Hierzu markieren Sie im Fenster des Projektmappen-Explorers oderim Formularfenster das betreffende Element.

2. Anschließend klicken Sie auf die Schaltfläche EIGENSCHAFTENFENS-TER, um das betreffende Fenster in VS.NET einzublenden.

Der Inhalt des Eigenschaftenfensters hängt dabei vom jeweiligen Objektab. Ein Projektelement wird andere Eigenschaften als ein Formular oderSteuerelement aufweisen. In den folgenden Kapiteln lernen Sie den Ent-wurf von Formularen kennen, wobei auch deren Eigenschaften über einsolches Fenster angepasst werden. Die Abbildung 3.37 zeigt im rechtenTeil das Eigenschaftenfenster eines Formularmoduls, welches im Projekt-mappen-Explorer angewählt wurde. Ein im Formulardesigner angewähl-tes Formular wird dagegen andere Eigenschaften aufweisen, da ersteressich auf eine Projektdatei, letzteres sich aber auf das Formular bezieht.

3.6.6 Arbeiten im CodefensterVisual Studio .NET besitzt ein eigenes Codefenster zur Bearbeitung desQuellcodes. Sobald Sie einen Eintrag (der Programmanweisungen auf-nehmen kann) im Projektmappen-Explorer per Doppelklick anwählen,wird der Quellcode im Codefenster angezeigt. Bei einer Visual Basic-Komponente erscheinen die Anweisungen in der Syntax dieser Sprache(Abbildung 3.37, Mitte). Sie können auf eine Zeile im Fenster klickenund die Programmanweisungen ergänzen.



92

0

magnum

Geben Sie eine Anweisung der Art Sub Main() ein und drücken Sie die(Enter)-Taste, erzeugt der Code-Editor automatisch das benötigteGegenstück End Sub. Dies funktioniert auch bei anderen Schlüsselwörternwie For etc.

Bild 3.37: Toolbox (links), Fenster des Code-Editors (Mitte) und Eigenschaftenfenster (rechts)

Fügen Sie Programmcode für Objekte und deren Methoden etc. im Code-fenster ein, wird die Intellisense-Unterstützung wirksam. Sobald der Edi-tor einen von Ihnen eingegebenen Ausdruck erkennt (z.B. nach Abschlie-ßen eines Objektnamens durch einen Punkt), erscheint ein Kontextmenümit den für das betreffende Objekt verfügbaren Members (Eigenschaf-ten, Konstanten und Methoden). Dies ist in Abbildung 3.37 (Mitte) zusehen, wo ich das Schlüsselwort Me als Objektname durch einen Punktabgeschlossen habe. Im Kontextmenü erscheinen dann die Members.Das vor dem Namen des Members eingeblendete Symbol erlaubt die

Schlüsselwörter (dies sind die in Visual Basic festgelegten Befehle wieSub, End Sub etc.) werden im Codefenster in blauer Farbe hervorgeho-ben. Normale Anweisungen erscheinen schwarz, während von Ihneneingegebene Kommentare grün dargestellt werden. Mit einer blauengeschlängelten Linie unterstrichene Textstellen weisen auf einen Fehlerin der Anweisung hin. Einige Stellen sind ggf. in grauem Text ausge-führt. An diesen Stellen ist automatisch generierter Code hinterlegt, derjedoch in der Regel ausgeblendet wird. Sie können sich den Code anse-hen, indem Sie auf das Kästchen mit dem Pluszeichen links vor derAnweisungszeile klicken.

Objektmemberliste anzeigenParameterliste

QuickInfoWortvervollständigung

Block kommentieren ein/ausLesezeichen verwalten



93

Unterscheidung zwischen Objekten, Eigenschaften und Methoden. Kli-cken Sie auf einen Eintrag, wird der Name automatisch im Code über-nommen.

Bild 3.38: QuickInfo zu einer Methode

Bei Methoden oder Funktionen wird nach Eingabe des Methodennamensautomatisch eine QuickInfo mit der Beschreibung der Schnittstelle dieserMethode eingeblendet (Abbildung 3.38).

Die Projektelemente werden in Klassen, Module, Prozeduren etc. unter-teilt. Das Codefenster besitzt zwei Listenfelder am oberen Rand, mitdenen Sie zwischen den Prozeduren der jeweiligen Komponente wechselnkönnen. Abbildung 3.39 zeigt die beiden geöffneten Listenfelder beimgeladenen Objekt Form1.

Bild 3.39: Listenfelder zur Auswahl der Klassen und Methoden

� Das linke Listenfeld aus Abbildung 3.39 dient zum Abrufen unter-schiedlicher Objekte (Klassen). Arbeiten Sie mit einem Formular alsObjekt, kann dieses Steuerelemente enthalten. Diese Steuerelemente(Schaltflächen, Texte, Felder etc.) werden ihrerseits aber als Objektebetrachtet. In diesem Beispiel sehen Sie das Objekt Button1, welcheseine im Formular eingefügte Schaltfläche repräsentiert.

� Ein Objekt (z.B. eine Klasse) kann mehrere Prozeduren enthalten, diesich über das rechte Listenfeld wählen lassen. Bei dem in Abbildung3.39 gezeigten Formular werden im rechten Listenfeld die Namender definierten Ereignisprozeduren für das Objekt aufgeführt.Dadurch gelangen Sie direkt zum Code der Prozedur.

Die in Abbildung 3.37 in der linken oberen Ecke gezeigten Schaltflä-chen erlauben solche Informationen direkt abzurufen. Weiterhin kön-nen Sie mit der rechten Maustaste auf die Codestelle klicken und dieentsprechenden Befehle im Kontextmenü wählen.



94

0

magnum

Ansonsten bietet der Code-Editor die üblichen Funktionen, um Codeteilezu markieren, in die Zwischenablage zu übernehmen oder aus ihr einzu-fügen. In der Symbolleiste des Codefensters gibt es zudem Schaltflächen(Abbildung 3.37), mit denen sich markierte Zeilen auf einen Rutsch alsKommentarzeilen auszeichnen lassen oder die das Einfügen von Lesezei-chen erlauben. Über weitere Schaltflächen lässt sich zu gesetzten Lesezei-chen springen. Dadurch können Sie noch zu bearbeitende Codeteile imProjekt markieren und sehr schnell im Editor anspringen.

3.6.7 Der Objektbrowser.NET Framework stellt eine Klassenbibliothek mit spezifischen Funk-tionen zur Verfügung. Zudem lassen sich weitere Klassen im Projekt ein-binden. Jede Bibliothek enthält Informationen über die Objekte, Eigen-schaften, Methoden, Ereignisse und Konstante. Über das Fenster desObjektbrowsers lassen sich Informationen über die Member einer Klasse(sprich über die Objekte, Methoden und Eigenschaften) abrufen (Abbil-dung 3.40, Hintergrund). Den Objektbrowser rufen Sie über das MenüANSICHT, Befehle ANDERE FENSTER/OBJEKTBROWSER ab. Die dargestell-ten Einträge lassen sich über das Listenfeld DURCHSUCHEN sowie überdie Schaltflächen des Fensters nach verschiedenen Kriterien filtern undsortieren.

Bild 3.40: Objektbrowser und Suchfenster

In der linken Liste Objekte zeigt der Objektbrowser Klassen an (Abbil-dung 3.40). Markieren Sie einen solchen Eintrag, werden die in dieserKlasse verfügbaren Elemente (Members) in der rechten Kategorie ange-zeigt. In Abbildung 3.40 ist beispielsweise die Klasse Form1 gewählt undSie sehen im rechten Fenster die jeweiligen Elemente dieser Klasse. Dorterkennen Sie auch den Eintrag Button1, der für die Schaltfläche des For-mulars steht.

Klicken Sie auf einen Eintrag des Objektbrowsers, zeigt dieser dessenSchnittstelle bzw. Beschreibung im Fußteil des Fensters an. Bei Klassenerkennen Sie die Definition und über welchen Namensraum die Klasse



95

erreichbar ist. Bei Einträgen der rechten Seite werden die Werte von Kon-stanten oder die Schnittstellen von Methoden angezeigt. Über denObjektbrowser können Sie sich also sehr schnell über die Definition derMembers informieren.

Bei umfangreichen Objektbibliotheken ist es recht aufwändig, ein be-stimmtes Element zu finden. Klicken Sie auf die Schaltfläche SYMBOLSUCHEN im Kopf des Fensters, um den Suchdialog zu öffnen. Geben Sieden Namen des gesuchten Elements im Listenfeld gemäß Abbildung 3.40(rechts) ein. Sie können dabei den vollständigen Namen oder nur einenTeilbegriff vorgeben. Anschließend genügt ein Mausklick auf die Schalt-fläche SUCHEN.

Die gefundenen Suchergebnisse werden anschließend in einem separatenFenster SUCHERGEBNISSE aufgeführt und lassen sich per Doppelklickanwählen. Handelt es sich um einen Member im Codeteil des Projekts,ruft der Code-Editor die betreffende Stelle auf. Bei einem Member auseiner eingebundenen Klassenbibliothek wird dessen Beschreibung imObjektkatalog angezeigt. Weitere Informationen finden Sie in der Hilfeunter dem Stichwort Objektbrowser.

3.6.8 Verweise im Projekt hinzufügenIn den folgenden Kapiteln lernen Sie, dass eine .NET-Anwendung Teileder .NET Framework Klassenbibliothek nutzen kann. Bevor Sie jedochauf die betreffenden Klassen und deren Members zugreifen können, mussVisual Basic wissen, wo diese Klassen im Namensraum zu finden sind.Die Vorlagen für neue Projekte sorgen dafür, dass die wichtigsten Ver-weise im Projektmappen-Explorer aufgeführt sind. Sie haben aber dieMöglichkeit, zusätzliche Verweise einzubinden.

1. Klicken Sie im Fenster des Projektmappen-Explorers mit der rechtenMaustaste auf das Symbol der Gruppe VERWEISE.

2. Wählen Sie im Kontextmenü den Befehl VERWEIS HINZUFÜGEN. Win-dows öffnet das gleichnamige Dialogfeld, welches Registerkarten zurAuswahl von .NET-Komponenten, COM-Objekte und Projektver-weisen enthält (Abbildung 3.41).

3. Im Dialogfeld VERWEIS HINZUFÜGEN wählen Sie die gewünschteRegisterkarte, suchen den gewünschten Eintrag und doppelklickendarauf. Auf diese Weise wird der Eintrag in die untere Liste des Dia-logfelds übernommen.

Sobald Sie das Dialogfeld über die OK-Schaltfläche schließen, werden dieVerweise ins Projekt übernommen und auch in den Konfigurationsda-teien der Projektmappe gesichert. Dies gewährleistet, dass die betreffen-den Bibliotheken beim Erstellen des Projekts mit in die ausführbareAnwendung übernommen werden. Zum Entfernen nicht benötigter Ver-weise wählen Sie den betreffenden Verweis im Projektmappen-Explorermit der rechten Maustaste an und verwenden den KontextmenübefehlENTFERNEN.



96

0

magnum

Bild 3.41: Verweise hinzufügen

3.6.9 Das Fenster des FormulardesignersSobald Sie ein Formular im Projektmappen-Explorer abrufen, wird des-sen Inhalt im Fenster des Formulardesigners angezeigt (Abbildung 3.42,Mitte).

In diesem Fenster lassen sich Formulare interaktiv entwerfen. In dergleichzeitig eingeblendeten Leiste TOOLBOX (Abbildung 3.42, links)wählen Sie die Kategorie WINDOWS FORMS. Diese enthält die Schaltflä-chen zum interaktiven Einfügen der Steuerelemente innerhalb des For-mulars. Um ein Steuerelement im Formular einzubringen, klicken Sie aufdie betreffende Schaltfläche, markieren per Mausklick im Formular dielinke obere Position und ziehen dann die Maus zur diagonal entgegenge-setzten Ecke. Sobald Sie die Maustaste nach dem Ziehen loslassen, fügtder Editor das Steuerelement in das Formular ein. Klicken Sie in derLeiste TOOLBOX auf die Schaltfläche eines Steuerelements und dann aufeine Stelle des Formularlayouts, wird die Schaltfläche in der Standard-größe an der betreffenden Position angefügt. Doppelklicken Sie dagegenauf eine Schaltfläche der Symbolleiste, fügt VS.NET das Steuerelement inder linken oberen Ecke des Formulars in seiner Standardgröße ein. Siekönnen die Elemente des Formulars per Mausklick markieren, um sieanschließend zu verschieben oder ihre Eigenschaften im Eigenschaften-fenster anzupassen. Die Beschriftung von Schaltflächen, der Formular-titel oder die Texte von Beschriftungsfeldern werden beispielsweise über



97

die Eigenschaft Text verwaltet. Ereignisprozeduren für die Steuerele-mente fügen Sie im Codefenster ein. Diese Ansicht lässt sich über dieSchaltfläche CODE ANZEIGEN des Projektmappen-Explorers öffnen.

Bild 3.42: Formulardesigner mit Toolbox und Eigenschaften

3.6.10 Projekt übersetzen und die Anwendung ausführen

Sobald Sie den Code für die Anwendung eingegeben und die Formulareentworfen haben, können Sie das Projekt übersetzen und die Anwendungstarten. Wählen Sie im Menü ERSTELLEN einen der Befehle <PROJEKT-NAME> ERSTELLEN oder <PROJEKTNAME> NEU ERSTELLEN, wobei <Pro-jektname> für den Namen des betreffenden Projekts steht. Visual Studio.NET startet dann den Visual Basic .NET-Compiler und sorgt dafür,dass das gesamte Projekt übersetzt wird. Zudem stellt die Entwicklungs-umgebung sicher, dass die als Verweise angegebenen Bibliotheken miteingebunden werden.

Die Ausgaben des Übersetzungsvorgangs werden dabei als einfache Text-anweisungen im Fenster AUSGABE angezeigt (Abbildung 3.43, unten).Sofern Fehler bei der Übersetzung des Projekts auftreten, generiert VisualStudio .NET eine Aufgabenliste in Form einer Tabelle und zeigt allegefundenen Fehler an (Abbildung 3.43, oben). Doppelklicken Sie aufeine solche Aufgabe, markiert VS.NET die fehlerhafte Stelle im Code-fenster.

Um eine erfolgreich übersetzte Anwendung auszuführen, klicken Sie inder Symbolleiste des VS.NET-Fensters auf die Schaltfläche STARTEN. Dergleiche Befehl steht auch im Menü DEBUGGEN sowie über die Funktions-taste (F5) zur Verfügung. Alternativ können Sie die Befehle des MenüsDEBUGGEN bzw. die Schaltflächen der gleichnamigen Symbolleiste zum



98

0

magnum

Testen des Programms verwenden. Lesen Sie im vorhergehendenAbschnitt nach, was es bezüglich des Debuggens von Anwendungen zuwissen gibt.

Bild 3.43: Meldungen beim Erstellen einer Anwendung

3.6.11 VS.NET anpassenVisual Studio .NET lässt sich über den Befehl OPTIONEN im MenüEXTRAS benutzerspezifisch anpassen. VS.NET öffnet das DialogfeldOPTIONEN, in dessen linker Spalte Sie verschiedene über Ordnersymbolezusammengefasste Kategorien wie Umgebung, Quellcodeverwaltung etc.finden. Klicken Sie auf eine Kategorie, werden die Unterkategorien einge-blendet. Wählen Sie eine Unterkategorie, zeigt das Dialogfeld die verfüg-baren Optionen im rechten Teil des Dialogfelds an.

Erfahrene Umsteiger von Visual Basic oder früheren Visual Studio-Versionen können die Kategorie UMGEBUNG/TASTATUR wählen. Dannlässt sich die Tastaturbelegung über das Listenfeld TASTATURZU-ORDNUNGSSCHEMA von der Vorgabe STANDARDEINSTELLUNGEN aufVISUAL BASIC 6, VISUAL STUDIO 6, VISUAL C++ 6 etc umstellen. In die-sem Buch werden jedoch nur die Tastenkombinationen der Standard-einstellung verwendet.



99

3.7 Die Online-Hilfe nutzen Sowohl Visual Studio .NET als auch der .NET Framework SDK werdenmit einer umfangreichen Hilfe ausgeliefert. Die Hilfe aus Visual Studio.NET umfasst auch die Dokumentation des .NET Framework SDK.Beide Hilfen lassen sich über das Startmenü abrufen.

Bild 3.44: Fenster der .NET Framework SDK-Dokumentation

Die Online-Hilfe wird in der Regel gemäß der Darstellung aus Abbildung3.44 angezeigt, d.h. im linken Teilfenster sehen Sie das Inhaltsverzeichnismit den Hilfethemen. Durch Anklicken der Überschriften lassen sich ein-zelne Themen im rechten Teil des Fensters abrufen. Für Windows-Nutzerist die Anordnung der Registerkarten zum Abrufen der Index- und Such-seiten am unteren Rand der linken Spalte etwas ungewohnt. In derIndexseite lassen sich Begriffe eintippen, die dann in der Liste der Stich-wörter nachgeschlagen werden. Die Suchseite erlaubt die Eingabe einesSuchbegriffs für eine Volltextsuche über den Inhalt der Hilfe. Gibt es zueinem Thema mehrere Einträge, werden diese in einem dritten Fenster inder rechten unteren Ecke als Hyperlinkliste angezeigt. Klicken Sie einenHyperlink an, wird die zugehörige Hilfeseite angezeigt.

Rufen Sie die Hilfe von VS.NET über das Hilfemenü ab, werden dieInformationen direkt im VS.NET-Fenster eingeblendet. Ich bevorzugeaber die Navigation in einem getrennten Hilfefenster und aktiviere des-halb diese über das Startmenü. Die Hilfe zwischen dem SDK undVS.NET unterscheidet sich zudem noch darin, dass sich in der VisualStudio-Fassung nach Programmiersprachen oder dem .NET Frame-work filtern lässt.


Die Online-Hilfe nutzen

100

0

magnum

Informationen zu den Klassen der .NET-Klassenbibliothek sowie denzugehörigen Members (Methoden und Eigenschaften) finden Sie imInhaltsverzeichnis unter Referenz/Klassenbibliothek. Wenn Sie gezieltüber die Indexseite auf Members einer Klasse zugreifen möchten, emp-fiehlt sich die Angabe der betreffenden Klasse im Stichwort. Anstatt z.B.das Stichwort ShowDialog als Index einzugeben, wenn Sie etwas überdie Anzeige von Formularen wissen möchten, verwenden Sie das Stich-wort Form.ShowDialog. Dann wird nur ein Eintrag gefunden.

Bei installiertem .NET Framework SDK werden zudem noch einigeWebseiten mit Zusatzinformationen und Beispielen auf der Festplattehinterlegt. Die Zusatzinformationen beziehen sich auf die Zusatzwerk-zeuge des SDK sowie auf Hinweise zu den Beispielen.

Die dynamische Hilfe in VS.NETVS.NET bietet unter dem Begriff »dynamische Hilfe« noch eine Beson-derheit, die gerade Ein- und Umsteigern unter die Arme greift. Das Fens-ter der dynamischen Hilfe lässt sich über den gleichnamigen Befehl desVS.NET-Hilfemenüs einblenden. Haben Sie eine bestehende Anwendungin VS.NET geladen und klicken Sie im Codefenster auf ein Schlüssel-wort, auf den Namen einer Methode, Eigenschaft etc., dann blendetVS.NET im Fenster DYNAMISCHE HILFE den Hyperlink zum Zugriff aufdie betreffende Hilfeseite ein. Dann genügt ein Mausklick auf denHyperlink, um Details zum jeweiligen Begriff abzurufen.

Damit möchte ich dieses Kapitel schließen. Sie haben einige Beispielekennen gelernt, mit denen sich die Entwicklungsumgebung und derVisual Basic-Compiler testen lassen. Weiterhin wissen Sie, wie beimÜbersetzen verschiedene Compileroptionen nutzbar sind. Der Abschnittüber das Debuggen von .NET-Anwendungen sollte Ihnen die Grundla-gen zum Testen eigener Programme vermittelt haben. Mit dem Überblicküber die Entwicklungsumgebung Visual Studio .NET werden Sie auchdie ersten Schritte meistern können. Das Kapitel konnte bei weitem nichtalle Informationen liefern. Falls Sie weitergehenden Informationsbedarfhaben, möchte ich an dieser Stelle auf die den Produkten beiliegendeDokumentation in Form der Online-Hilfe verweisen. Sollten Sie als Ein-steiger nicht alles begriffen haben, ist dies nicht weiter schlimm (Sie kön-nen ja später im Kapitel die betreffenden Stellen nachschlagen). In denfolgenden Kapiteln lernen Sie Schritt für Schritt Visual Basic .NET ken-nen und erfahren, wie sich Anwendungen erstellen lassen. Dabei verfolgeich den Ansatz, möglichst wenig VS.NET und dafür möglichst viel Visual

Bei der Installation der .NET Redistributable wird keine Hilfe mitgelie-fert. Falls Sie unter Windows 9x entwickeln müssen, lässt sich der.NET Framework SDK aber nicht installieren. Sie brauchen dennochnicht auf eine Hilfe zu verzichten. Einmal finden Sie viele Informatio-nen in diesem Buch. Zudem hat Microsoft die Dokumentation zuVisual Studio .NET und zum SDK komplett ins Internet gestellt. Siekönnen die Seiten unter msdn.microsoft.com abrufen (einfach nach derBeschreibung der .NET-Klassenbibliothek suchen).



101

Basic .NET zu vermitteln. Sie können also weiterhin mit dem .NET Fra-mework SDK oder der Redistributable arbeiten. Greifen Sie ggf. auf diein diesem Kapitel vorgestellte DotNET-IDE zurück, um sich die Arbeitzu erleichtern. Bei den in den nachfolgenden Kapiteln gezeigten Beispie-len werden die zum Übersetzen erforderlichen Anweisungen mit angege-ben.


3.1 Das erste Visual Basic-Beispiel - · PDF fileKapitel 3 · Werkzeugtest, Debuggen,...

Documents

Transcript of 3.1 Das erste Visual Basic-Beispiel - · PDF fileKapitel 3 · Werkzeugtest, Debuggen,...