C# Debugging - Tutorials.de

1. Vorwort
2. Einleitung
C#
Debugging
3. Entwicklungsumgebung
4. Grundlagen
5. Debugging (Ver. 1.03)
6. Objektorientierung
7. Fehlerbehandlung
by Erik Bartmann
1

Debugging............................................................................................................3
2
Debuggen mit Haltepunkten ............................................................................4
Haltepunkt setzen.........................................................................................4
Haltepunkt löschen.......................................................................................5
In einen Haltepunkt laufen...........................................................................5
Daten inspizieren .........................................................................................6
Einzelschritt ...............................................................................................13
Debuggen ohne Haltepunkt(e) .......................................................................18
Ausführen bis Cursor .................................................................................18
Arbeiten mit der Klasse „Debug“ ..............................................................19
Fehlermeldung ...............................................................................................26
Source-Code im Haltezustand bearbeiten..................................................26
Bedingte Kompilierung..................................................................................26
Attribut Conditional...................................................................................30
Compilermeldungen.......................................................................................31
Deaktivieren / Aktivieren...........................................................................31
Eigene Meldungen erstellen.......................................................................34

Debugging
Fehlersuche hat etwas mit Spurensuche zu tun. Wir müssen einem Umstand auf
die Schliche kommen, der unser Programm nicht wie beabsichtigt laufen lässt.
Syntaktische Fehler, die sich schon zur Entwicklungszeit zu erkennen geben,
sind natürlich einfacher ausfindig zu machen, als logische Fehler. Woher soll
das Programm auch wissen, dass es anders laufen soll, als der Programmierer es
vorgesehen hat? Einer Variablen, der ein falscher Wert zugewiesen wurde,
schleppt sich durch die ganze Applikation. Eine fehlerhafte Formel lässt einem
die Haare zu Berge stehen.
Die Entwicklungsumgebung von Visual C# 2005 Express Edition bietet dem
Entwickler eine Möglichkeit, den oder die Fehler zu lokalisieren. Vergleichbar
mit der Programmunterbrechnung beim Auftreten einer Exception zur Laufzeit,
können wir das Programm kontrolliert an fast jeder beliebigen Stelle im Code
anhalten. Wie das funktioniert, habe ich Ihnen im Kapitel über Arrays schon
kurz gezeigt. Dort haben wir uns die Array-Inhalte nach Setzten eines so
genannten Haltepunktes, auch Breakpoint genannt, angeschaut. Wurde die
Programmausführung an einer Stelle unterbrochen, können wir uns
Variableninhalte anschauen und ihnen sogar manuell Werte zuweisen, die nicht
per Anweisung im Source-Code existieren. Auf diese Weise gestaltet sich das
Debuggen sehr flexibel. Sie können, ohne das Programm erneut zu starten und
es am Breakpoint anzuhalten, Variableninhalte modifizieren und die
3

Programmfortsetzung den eigenen Wünschen anpassen. Nehmen wir an, dass
einer Variablen ein bestimmter Wert zugewiesen wurde, um sie in der nächsten
Zeile in einer Berechnung zu verwenden. Leider entspricht das Ergebnis nicht
unseren Erwartungen. Den Breakpoint haben wir hinter die Ausgabe des
Ergebnisses an die Konsole gesetzt. Jetzt starten Sie die Anwendung und lassen
sich das Ergebnis anzeigen. Sie modifizieren die Variable und setzten die
Programmzeiger in die Zeile, in der die Berechnung stattfindet. Wird das
Programm fortgesetzt, erfolgt die Berechnung mit den neuen Daten. Ich werde
Ihnen die einzelnen Schritte auf jeden Fall an einem Beispiel erläutern.
Debuggen mit Haltepunkten
Wie schon mehrfach erwähnt, müssen Sie zur Programmunterbrechung einen
Haltepunkt an einer Stelle Ihres Source-Codes setzten. Starten Sie das
Programm z.B. mit , stoppt die Ausführung genau am definierten Haltepunkt.
Haltepunkt setzen
Um der Entwicklungsumgebung einen Haltepunkt mitzuteilen, klicken Sie mit
der linken Maustaste in der entsprechenden Zeile auf den linken grauen Rand
im Editor.
4

Der Haltepunkt wird durch einen roten Kreis gekennzeichnet, wobei sich die
Hintergrundfarbe der Code-Zeile zusätzlich in Rot ändert.
Haltepunkt löschen
Das Löschen eines Haltepunktes erfolgt auf die gleiche Weise wie das Setzen.
Klicken Sie mit der linken Maustaste auf den roten Kreis, wird der zuvor
gesetzte Haltepunkt gelöscht.
In einen Haltepunkt laufen
Schauen wir uns den Source-Code aus Code 1 genauer an. Der Haltepunkt ist in
Zeile 16 gesetzt.
Dotty: „Wenn wir das Programm starten und die Ausführung den Haltepunkt
erreicht, wird dann die Zeile noch ausgeführt?“
Wird der Haltepunkt erreicht, dann bedeutet das, dass in dieser Zeile erst einmal
die Programmausführung unterbrochen ist. Die Anweisung in der betreffenden
Zeile wurde zu diesem Zeitpunkt noch nicht zur Ausführung gebracht. Doch
schauen wir uns den Editor nach dem Start des Programms mit genauer an:
5

Unsere Anwendung hat den gesetzten Haltepunkt erreicht. Sie erkennen es am
gelben Pfeil, der sich im Moment vor den roten Kreis gesetzt hat. Der Pfeil
stellt den Programmzeiger dar, der auf die Zeile weist, die als nächste zur
Ausführung gebracht wird. Zusätzlich ist die Anweisung in gelb hinterlegt.
Daten inspizieren
Wurde der Haltepunkt erreicht, haben wir die Möglichkeit, auf diverse
Programmdaten zuzugreifen. Im Fensterbereich, in dem sich die Fehlerliste
befindet, erscheit hinter einem zusätzlichen Reiter verborgen, ein neues Fenster
mit der Bezeichnung lokal. Sollten Sie das Fenster einmal geschlossen haben,
so kann es über das Programm-Menü Debuggen|Fenster|Lokal angezeigt
werden.
Daten im Fenster „Lokal“ auswerten
Abb. 1: Daten nach Erreichen von Haltepunkt inspizieren
In diesem Fenster wird eine Liste mit 3 Spalten angezeigt.
6

Spaltenbezeichnung Bedeutung
Name Angabe des Variablennamen
Wert Anzeige des Wertes, mit dem die Variable initialisiert ist
Typ Anzeige des Datentyps der Variablen
Tab. 1: Spalten im Fenster Lokal
Wir erkennen, dass die Liste zwei Einträge enthält und somit zwei Variablen
zum Zeitpunkt des Erreichens des Haltepunktes existieren. Konzentrieren wir
uns auf den zweiten Eintrag, der die Variable intWert1 enthält. Sie ist mit dem
numerischen Wert 10 initialisiert und vom Datentyp int. Die Initialisierung
erfolgte über die Anweisung in Zeile 14. Schauen wir uns das Konsolenfenster
an, so sehen wir das Ergebnis der Berechnung aus Zeile 15. Sollten Sie jetzt
versucht sein, im Konsolenfenster die Taste zu drücken, so wird dies keine
Auswirkung auf die Fortsetzung des Programms haben, da die Ausführung
angehalten wurde und Zeile 16 noch nicht erreicht ist.
Dotty: „Wie können wir das Programm fortsetzen?“
Aus dem jetzigen statischen Zustand gibt es unterschiedliche Möglichkeiten der
Fortführung:
Taste Aktion Beschreibung
Programmausführung
fortsetzen
Fortsetzten der Programmausführung ab dem
momentanen Haltepunkt bzw. ab Programmzeiger.
Einzelschritt Fortsetzten der Programmausführung ab dem
momentanen Haltepunkt bzw. Programmzeiger. Die
Ausführung stoppt vor der nächsten Anweisung.
Beinhaltet die momentane Anweisung einen
Methodenaufruf, so wird in die Methode gesprungen
und vor der ersten Anweisung angehalten.
Prozedurschritt Fortsetzten der Programmausführung ab dem
momentanen Haltepunkt bzw. Programmzeiger. Die
7

Ausführung stoppt vor der nächsten Anweisung.
Beinhaltet die momentane Anweisung einen
Methodenaufruf, so wird die Methode in ihrer Gänze
abgearbeitet und die Ausführung an der Stelle
angehalten, die dem Methodenaufruf unmittelbar folgt.
+ Ausführen bis Fortsetzten der Programmausführung ab dem
Rücksprung
momentanen Haltepunkt bzw. Programmzeiger.
Befindet sich der Haltepunkt innerhalb einer Methode,
so werden die restlichen Zeilen abgearbeitet und die
Ausführung an der Stelle angehalten, die dem
Methodenaufruf unmittelbar folgt.
Tab. 2: Programmfortführung nach Haltepunkt
Die Anzeige der Variableninhalte im Fenster Lokal kann wahlweise in
dezimaler (Standard) oder hexadezimaler Schreibweise erfolgen. Das
Umschalten erfolgt über das Kontext-Menü des Fensters. Wählen Sie dazu den
Eintrag „Hexadezimale Anzeige“, der daraufhin mit einem Haken versehen
wird. Das Zurückschalten auf die dezimale Anzeige erfolgt in gleicher Weise
über denselben Eintrag; der Haken wird entfernt.
Daten über Tooltip anzeigen
Die zweite Möglichkeit, Programminformationen bzw. Variableninhalte im
Haltemodus anzuzeigen, ist durch das Verweilen des Mauszeigers über einer
Variablen gegeben.
8

Ich habe den Mauszeiger über der Variablen intWert in Zeile 13 stehen
lassen. Der Tooltip hat sich einen kurzen Augenblick später geöffnet und nennt
uns den Variablennamen inklusive Variableninhalt.
Daten über Tooltip modifizieren
Haben Sie sich auf diese Weise über den Variableninhalt informiert, so ist es
Ihnen sogar gestattet, der Variablen einen neunen Wert zuzuweisen. Führen Sie
folgende Schritte aus:
1. Fahren Sie dazu mit dem Mauszeiger in das Rechteck des Tooltips hinein.
Der Hintergrund wechselt, sofern Sie die Standardfarben verwenden, von
Hellgrau nach Dunkelgrau.
2. Klicken Sie innerhalb des Tooltips mit der linken Maustaste. Vor dem
momentanen Variablenwert erscheint ein blinkender Cursor.
3. Modifizieren Sie den Wert nach Ihren Vorstellungen.
4. Bestätigen Sie Ihre Eingabe mit der Taste oder verwerfen die
Modifikation durch einen Klick mit der linken Maustaste außerhalb des
Tooltips.
Daten im Direktfenster
Ist ein Haltepunkt erreicht und das Programm unterbrochen, so können Sie im
Direktfenster z.B. folgende Aktionen ausführen:
♦ Anzeige von Variableninhalten
♦ Auswerten und Ausführen von Ausdrücken
♦ Aufrufen von Methoden
Die Anzeige des Fensters erfolgt über das Programm-Menü
Debuggen|Fenster|Direkt. Schauen Sie sich den folgenden Code an:
9

Die Variable intWert wird deklariert und mit einem Wert von 10 initialisiert.
Der Haltepunkt befindet sich in Zeile 13, in der die Berechnung vorgenommen
werden soll. Starten Sie das Programm über , stoppt das Programm kurz vor
der Multiplikation der Variablen mit dem Wert 2. Gehen Sie jetzt in Ihr
Direktfenster und geben nacheinander die gezeigten Eingaben ein.
Abb. 2: Eingaben im Direktfenster
Ihre erste Eingabe hat den Inhalt der Variablen intWert zur Anzeige
gebracht. Dazu wird das Fragezeichen vor den Variablennamen gesetzt und die
Eingabe mit der Taste bestätigt. Mit der zweiten Eingabe haben Sie der
Variablen den neuen Wert 90 zugewiesen. Lassen Sie das Programm z.B. mit
weiterlaufen, so meldet sich Ihr Konsolenfenster zurück. Das Ergebnis
wurde mit der von Ihnen neu initialisierten Variablen berechnet und lautet
korrekter Weise 80 und nicht 20.
Daten überwachen
Kommen wir jetzt zu einem weiteren Fenster, dass uns Debugging-
Informationen zur Verfügung stellt. Es ist das Überwachen-Fenster. Schauen
wir uns dazu den folgenden simplen Source-Code an:
10

Nach dem Start mit stoppt die Ausführung aufgrund des Haltepunktes in
Zeile 12. Jetzt rufen wir über den Menüpunkt Debuggen|Fenster|Überwachen
das Überwachen-Fenster auf den Schirm. Es enthält eine Liste aus 3 Spalten mit
Informationen über Name, Wert und Typ. Da wir noch keine zu überwachenden
Informationen hinzugefügt haben, ist die Liste leer. Jetzt möchte ich der Liste
die Variable intWert1 hinzufügen, die im Laufe des Programms überwacht
werden soll. Folgende Schritte sind notwendig:
Erste Möglichkeit
1. Programm mit starten
2. Nach Erreichen des Haltepunktes den Mauszeiger über die Variable
intWert1 platzieren.
3. Das Kontext-Menü über die rechte Maustaste aufrufen.
4. „Überwachung hinzufügen“ auswählen.
Die Liste hat sich mit einem Eintrag gefüllt.
11

Abb. 3: Überwachen Liste
Zweite Möglichkeit
1. Programm mit starten
2. Nach Erreichen des Haltepunktes einen Doppelklick mit der linken
Maustaste auf die Variable intWert1 absetzten. Die Variable wird
dadurch im Editor markiert, was Sie am dunkelblauen Hintergrund erkennen
können.
3. Mit gedrückter linker Maustaste den Namen der Variablen in das Fenster
ziehen und dort loslassen (Drag & Drop). Der Mauszeiger ändert sich wie in
der folgenden Abbildung gezeigt.
Abb. 4: Überwachung per Drag & Drop hinzufügen
Nach dem Loslassen der linken Maustaste hat sich die Liste wie bei der ersten
Möglichkeit um einen Eintrag erweitert. Führen Sie den Programmablauf im
Einzelschrittverfahren mit fort, können Sie den Änderungen des
Variableninhaltes aufgrund der Operationen in Zeile 13 bzw. 14 folgen. In jeder
dieser beiden Zeilen wird der Wert der Variablen um 1 erhöht. Möchten Sie
weitere Variablen zur Überwachung hinzufügen, so verfahren Sie wie gerade
12

eschrieben. Das Entfernen einer Variablen aus der Liste kann auf folgende
Weisen erfolgen:
Erste Möglichkeit
1. Den gewünschten Listeneintrag mit linker Maustaste markieren.
2. Die Taste drücken.
Zweite Möglichkeit
1. Den gewünschten Listeneintrag mit linker Maustaste markieren.
2. Das Kontext-Menü über die rechte Maustaste aufrufen.
3. „Überwachung löschen“ wählen.
Die Anzeige der Variableninhalte im Überwachungsfenster kann wahlweise in
dezimaler (Standard) oder hexadezimaler Schreibweise erfolgen. Das
Umschalten erfolgt über das Kontext-Menü des Überwachungsfensters. Wählen
Sie dazu den Eintrag „Hexadezimale Anzeige“, der daraufhin mit einem Haken
versehen wird. Das Zurückschalten auf die dezimale Anzeige erfolgt in gleicher
Weise über denselben Eintrag; der Haken wird entfernt.
Einzelschritt
Ich möchte mit dem nun folgenden einfachen Source-Code das Debuggen
mittels Einzelschritt erklären.
1. Setzen des Haltepunktes in Zeile 15
13

Programm mit Haltepunkt
2. Starten des Programm mit
Nach dem Start mit wird der Haltepunkt in Zeile 15 erreicht. Die Anweisung
ist noch nicht zur Ausführung gebracht worden. Im Fenster „Lokal“ hat die
Variable intWert1 noch immer den Wert 0.
3. Fortführung durch Einzelschritt mit
14

Durch den Einzelschritt mit ist die erste Anweisung in Zeile 15 ausgeführt
und die Variable intWert1 mit dem Wert 10 initialisiert worden. Das Fenster
„Lokal“ bestätigt uns die Wertzuweisung. Der Programmzeiger ist in die
nächste Zeile gewandert und zeigt auf die nächste auszuführende Anweisung.
4. Fortführung durch Einzelschritt
Durch den nächsten Einzelschritt mit wurde die Anweisung in Zeile 16
ausgeführt und die Variable intWert2 mit dem Wert 42 initialisiert. Zwar hat
sich nach dem Start des Programms das Konsolenfenster geöffnet, doch außer
einem schwarzen leeren Hintergrund ist nicht allzu viel zu sehen.
15

5. Fortführung durch Einzelschritt
Der letzte Einzelschritt führte die Berechnung in Zeile 17 durch und wies das
Ergebnis der deklarierten Variablen intWert3 zu. Der Programmzeiger steht
mittlerweile in der Zeile, die das Ergebnis im nächsten Schritt an die Konsole
ausgibt.
6. Fortführung durch Einzelschritt
Durch diesen Einzelschritt wurde das Ergebnis der letzten Berechnung an die
Konsole ausgegeben. Geben Sie dem Konsolenfenster über Ihre Taskleiste den
Fokus, so dass es sichtbar wird. Die Anzeige sollte mit dem Wert 52 der
Variablen intWert3 aus dem Fenster „Lokal“ übereinstimmen.
16

7. Fortführung mit Einzelschritt
Durch den Einzelschritt wurde die Kontrolle an die Konsole übergeben, die dort
auf eine Bestätigung durch die Taste wartet. Der Programmzeiger hat sich
vorübergehend ausgeblendet, da eine Einzelschritt Aktion nicht möglich ist.
8. Taste im Konsolenfenster drücken
Erst nachdem die Konsole die Kontrolle durch den Tastendruck zurückgegeben
hat, wird der Programmzeiger wieder sichtbar.
9. Fortführen mit Einzelschritt
17

Der Programmzeiger steht jetzt vor der schließenden geschweiften Klammer der
Main-Methode, was bedeutet, dass der nun folgende Einzelschritt das
Programm beendet.
Debuggen ohne Haltepunkt(e)
Ausführen bis Cursor
Bis jetzt haben Sie zum kontrollierten Anhalten des Programms, einen
Haltepunkt an eine bestimmte Stelle Ihres Source-Codes gesetzt. Möchten Sie
Ihre Anwendung einmal ohne Haltepunkt bis zu einer gewissen Zeile ausführen,
um sich Variableninhalte anzuschauen, gehen Sie folgendermaßen vor:
1. Setzen Sie den Cursor in die Zeile, in der Die Ausführung unterbrochen
werden soll
2. Öffnen Sie das Kontext-Menü über die rechte Maustaste
3. Wählen Sie den Eintrag „Ausführen bis Cursor“
18

Abb. 5: Ausführen bis Cursor
Nach dem Start Ihrer Anwendung mit stoppt die Ausführung in Zeile 15
gleichermaßen, als wenn Sie dort einen Haltepunkt eingefügt hätten. Der gelbe
Programmzeiger verharrt an dieser Position jedoch mit dem Unterschied, dass
kein Haltepunkt unter ihm zu erkennen ist.
Haben Sie an verschiedenen Stellen Im Source-Code Haltepunkte gesetzt und
wählen diese Art des Debuggen, so stoppt die Ausführung trotz alledem an
einem Haltepunkt, falls dieser vor der Cursorzeile erreicht wird.
Arbeiten mit der Klasse „Debug“
Die bis jetzt vorgestellte Technik des Debuggen bezog sich auf das Ausführen
des Programms bis zu einer bestimmten Stelle im Source-Code. Dies wurde
entweder durch das Setzen von einem oder mehreren Haltepunkten oder durch
19

das Ausführen bis zum platzierten Cursor erreicht. Im erreichten Haltezustand
war es Ihnen möglich, Daten zu inspizieren oder sogar zu manipulieren. Um zur
Laufzeit des Programms Variableninhalte sichtbar zu machen, bedienten wir
uns der Ausgabe auf die Konsole durch die Methode Console.WriteLine().
Natürlich ist gegen diese Art des Monitorens nichts einzuwenden.
Die Ausgabe lautet erwartungsgemäß:
10
42
52
Schwierig wird es nur, wenn Sie nicht erkennen, welches sie regulären
Ausgaben sind und welche nur als Debug-Informationen fungieren. Visual
Studio C# 2005 Express Edition bietet uns eine Variante an, diese Ausgaben
statt an die Konsole in einem separaten Fenster auszugeben. Sie erreichen es
über den Menüpunkt Debuggen|Fenster|Ausgabe. Doch wie findet eine
Ausgabe in dieses Fenster statt? Wir müssen uns die Funktionalität der Klasse
„Debug“ zu Nutze machen. Sie stellt eine Reihe von Methoden zur Verfügung,
derer wir uns bedienen können. Ersetzten Sie einfach den Klassennamen
Console durch Debug. Die Ausgabemethode lautet in beiden Klassen
WriteLine(). Ändern wir also den Source-Code entsprechend ab, so dass Debug-
20

Informationen nur an die dafür vorgesehene Stelle geschickt werden. Ersetzten
Sie in den Zeilen 17 und 20 die Klassenbezeichnung Console durch Debug.
Dotty: „So einfach scheint das nicht zu sein! Ich bekomme sofort einen
Fehler angezeigt.“
Die Klasse Debug befindet sich im Namespace System.Diagnostics. Sie müssen
also entweder den kompletten Pfad
System.Diagnostics.Debug.WriteLine(…)
angeben oder die Using-Direktive
using System.Diagnostics;
setzten. Anschließend können Sie Debug.WriteLine(…) schreiben, weil
der Namensraum dadurch bekannt gemacht wurde. Der komplette Source-Code
schaut folgendermaßen aus:
21

Sie sehen, dass ich in Zeile 4 die Using-Direktive hinzugefügt habe. Das
verkürzt die Schreibweise in den Zeilen 14 und 17, die jetzt ohne komplette
Pfadangaben auskommen. Starten Sie jetzt das Programm, so sehen Sie nur das
Ergebnis der Anweisung aus Zeile 20 im Konsolenfenster. Die Debug-
Informationen sind, wie erwartet, im Ausgabe-Fenster zu finden.
22

Abb. 6: Ausgabe Fenster
Wie unschwer zu erkennen ist, beschickt der Compiler dieses Fenster mit einer
ganzen Reihe von Informationen. U.a. sehen Sie die Ausgabe der Werte 10 bzw.
42 der Variableninhalte.
Die Methode Debug.WriteLine() kennt im Gegensatz zur Methode
Console.WriteLine() keine Formatanweisungen. Die Anweisung
Console.WriteLine("intWert1= {0}", intWert1);
muss für die die Klasse Debug folgendermaßen lauten:
Debug.WriteLine("intWert1= " + intWert1);
Dotty: „Ich kann meine Debug-Informationen - zwar nicht auf den ersten
Blick - erkennen, doch optimal finde ich die Ausgabe nicht.“
Da gebe ich Dir Recht. Es existiert eine Methode mit Namen Ident(), welche
alle folgenden Ausgaben einrückt. Entscheidend für den Level der Einrückung
ist die Eigenschaft IdentLevel, wobei die Eigenschaft IdentSize die Anzahl der
einzurückenden Zeichen angibt.
23

Die Ausgabe lautet folgendermaßen:
Abb. 7: Ausgabefenster von Debug
Speichern der Ausgabe
Manche logische Fehler mögen sich als recht hartnäckig herausstellen und Sie
sind auf die Debug-Informationen in chronologischer Reihenfolge angewiesen.
Da bei jedem neuen Start Ihrer Anwendung der Inhalt des Ausgabefensters
24

gelöscht wird, kann es sinnvoll sein, diesen vor jedem neuen Durchlauf zu
sichern.
1. Markieren Sie alle Einträge im Ausgabefenster mit der linken Maustaste
2. Klicken Sie mit der rechten Maustaste in das Ausgabefenster und öffnen das
Kontext-Menü
3. Wählen Sie den Eintrag „kopieren“
4. Öffnen Sie einen Texteditor (z.B. Notepad) und fügen den zuvor kopierten
Inhalt dort ein
5. Speichern Sie die Informationen in eine Datei unter einem aussagekräftigen
Namen
Nachfolgend eine Übersicht über die wichtigsten Methoden und Eigenschaften
der Klasse Debug.
Methode Eigenschaft Erklärung
Ident() Einrückung der Ausgabe um einen Level erhöhen
UnIdent() Einrückung der Ausgabe um einen Level vermindern
IdentLevel Angabe des Einrück-Levels
IdentSize Angabe der Einrück-Zeichenanzahl pro Level
Tab. 3: Methoden und Eigenschaften der Klasse Debug
25

Fehlermeldung
Source-Code im Haltezustand bearbeiten
Mir ist es schon einige Male passiert, dass sich meine Anwendung - ohne es zu
wissen - noch im Haltezustand befand und ich geneigt war, den Source-Code zu
bearbeiten. Ich wurde deshalb regelmäßig mit dem folgenden Dialog erfreut.
Beenden Sie das Debuggen durch + . Danach erhalten Sie wieder die
Möglichkeit, Ihren Source-Code zu bearbeiten.
Bedingte Kompilierung
Stellen Sie sich vor, Sie befinden sich in einer Testphase ihrer Applikation und
möchten in Abhängigkeit von bestimmten Faktoren den Programmverlauf
steuern. Gerade beim Debuggen ist es sinnvoll, so viele Informationen wie
möglich über den Programmablauf zu erhalten. Um diesen Code, der z.B.
Variableninhalte auf die Konsole ausgibt, nach dem Debuggen nicht wieder zu
löschen - man könnte ihn vielleicht bei später bei erneut auftauchenden
26

Problemen wieder verwenden - nutzt man die bedingte Kompilierung. Das
bedeutet, dass in Abhängigkeit von existierenden Symbolen ein bestimmter
Programmcode kompiliert wird oder nicht.
Dotty: „Was bedeuten in diesem Zusammenhang Symbole und wie werden sie
definiert?“
Wir benutzten zum definieren bzw. löschen von Symbolen so genannte
Direktiven.
Direktive Erklärung
#define
#undef
Tab. 4: Direktiven für Symbole
Definiert ein Symbol
Löscht das Symbol
Zu beachten ist, dass sich diese beiden Direktiven am Beginn des Source-Codes
befinden müssen. Also noch vor den eigentlichen Anweisungen. Andernfalls
gibt’s die folgende Fehlermeldung:
27

Sie sehen direkt in Zeile 1 die Direktive #define mit dem definierten Symbol
TEST. In der Zeile 12 wird eine Abfrage mittels #if TEST gestartet, die
überprüft, ob das Symbol TEST definiert wurde. Falls die Antwort positiv
ausfällt, wird der Anweisungsblock zwischen #if bzw. #endif ausgeführt.
Dotty: „Kann man irgendwie zu Entwicklungszeit erkennen, ob ein Symbol
definiert wurde, ohne an den Anfang des Source-Codes zu springen?“
Das ist möglich. Die Entwicklungsumgebung stellt die Codezeilen, die sich
innerhalb eines Anweisungsblocks befinden, grau dar, wenn das Symbol für
diesen Block nicht definiert wurde. Andernfalls sehen wir das übliche Syntax-
Highlighting. Symbole können nicht nur innerhalb einer Datei definiert werden,
sondern projektbezogen in den Projektoptionen
1. Projekt im Projektmappenexplorer markieren
2. Projekteigenschaften über Kontextmenü (rechte Maustaste) aufrufen
3. In den Reiter Erstellen wechseln
Sie erkennen auf der rechten Seite ein Text-Eingabefeld, in das Sie ein oder
mehrere Symbole eingeben können. Diese sind dann für das komplette Projekt
definiert. Trennen Sie mehrere Symbole entweder durch Leerzeichen oder
Kommata. In diesem Fall wurden zwei Symbole (TEST und OUT) definiert.
28

Im vorliegen Code sehen Sie anhand der farblichen Kodierung der IDE, dass die
Symbole TEST und OUT definiert wurden, jedoch nicht OUT2. Folgende
Direktiven sind zur Steuerung der Kompilierung verfügbar:
Direktive Erklärung
#if
#else
#elif
#endif
Tab. 5: Direktiven für Symbole
Einleitung des Anweisungsblocks
Else-Anweisung
Else-If Anweisung
Beendung des Anweisungsblocks
29

Attribut Conditional
Sie können den Programmablauf zusätzlich über ein Attribut steuern, welches
das Vorhandensein eines Symbols auswertet, das mit einer Direktive gesetzt
oder gelöscht wurde. Das Attribut nennt sich Conditional. Das zu
überprüfende Symbol wird als Zeichenkette innerhalb von doppelten
Hochkommata und den runden Klammern hinter dem Attribut aufgeführt.
Schauen Sie sich das folgende Beispiel an:
30

Das Attribut Conditional platzieren Sie einfach vor jede Methode, die über
ein Symbol gesteuert werden soll.
1. Definieren des Symbols TEST
2. Namespace System.Diagnostics über using bekannt machen
3. Platzieren des Attributes vor die zu kontrollierenden Methoden
In Zeile 12 bzw. 13 werden die beiden Methoden aufgerufen, doch vor der
eigentlichen Ausführung wertet das Attribut das nachfolgend aufgeführte
Symbol aus. Existiert es, wird die Methode ausgeführt, andernfalls ignoriert.
Compilermeldungen
Deaktivieren / Aktivieren
Ihnen ist es sicherlich schon aufgefallen, dass Sie einen Warnhinweis vom
Compiler erhalten, wenn eine Variable zwar deklariert, jedoch an keiner Stelle
Ihres Programms genutzt wird. Falls Sie diese Warnungen stören, weil Sie
vielleicht doch diese Variablen im späteren Verlauf Ihres Projektes nutzen
möchten, gibt es eine Möglichkeit Compilermeldungen zu konfigurieren. Der
folgende kurze Code deklariert und initialisiert zwar die Variable intVariable1,
doch sie es wird nie darauf zugegriffen.
Die grünen Schlangenlinien weisen auf einen Warnhinweis hin, der da lautet:
31

Jede Warnmeldung besitzt intern einen Code bzw. eine Nummer. Leider wird
der an dieser Stelle nicht angezeigt. Wie können wir ihn also ermitteln? Gehen
Sie dabei folgende Schritte durch:
1. Platzieren Sie den Cursor über die Variable, die mit Schlangenlinien
unterlegt ist
2. Drücken Sie die Funktionstaste F1
Es dauert eine Weile, bis sich die Visual C#-Referenz öffnet.
Der entscheidende Hinweis ist die Zeile, in der die Compilerwarnung steht. Der
für uns wichtige Code lautet 219. Jetzt müssen wir dem Compiler mitteilen,
dass wir nicht mehr an Warnungen interessiert sind, die in diese Kategorie
fallen. dazu existiert eine Direktive. Sie lautet:
#pragma warning
Um die Warnung zu deaktivieren, fügen Sie die in Zeile 3 stehende Direktive an
den Anfang Ihres Codes ein:
32

Die Direktive
#pragma warning restore 219
veranlasst den Compiler wieder Meldungen zu schicken und die Zeile
#pragma warning restore
stellt den Urzustand wieder her, so dass alle Meldungen den Entwickler
erfreuen. Bedenken Sie aber auf jeden Fall, dass der Compiler nicht ohne Grund
diese Meldungen verschickt. Es könnte u.U. wichtig sein.
Sie können mehrere Codes durch Kommata getrennt angeben, um
Warnungen zu deaktivieren bzw. aktivieren.
33

Eigene Meldungen erstellen
Es ist unter gewissen Umständen sogar sinnvoll, eigene Warnungen zu
erstellen, um Sie bei passender Gelegenheit auszulösen.
Dotty: „Wann sollte das denn nötig sein? Stellt der Compiler etwas fest, das
für den Programmierer wichtig ist, bekommt er doch sicherlich einen
Hinweis.“
Das ist sicherlich korrekt. Doch mal angenommen, wir haben die schon
angesprochene bedinge Kompilierung aktiviert. Da kann es u.U. nützlich sein,
eine entsprechende Meldung zu generieren, damit der Programmierer über
dieses geänderte Programmverhalten informiert wird.
34

Die Meldung im Fehlerlisten-Fenster lautet entsprechend:
35